diff --git a/Pages/Folder.cshtml b/Pages/Folder.cshtml
new file mode 100644
index 0000000..7ec3a11
--- /dev/null
+++ b/Pages/Folder.cshtml
@@ -0,0 +1,151 @@
+@page
+@model FolderModel
+@{
+    ViewData["Title"] = Model.Folder?.Title ?? "Folder";
+}
+
+<div class="mt-3">
+    <div class="d-flex flex-wrap gap-2 align-items-center mb-3">
+        <div class="d-flex flex-wrap gap-2 align-items-center flex-grow-1">
+            <h2 class="h5 mb-0">@Model.Folder?.Title</h2>
+            @if (Model.Folder is not null)
+            {
+                <span class="text-muted small">@Model.Folder.Date.ToString("yyyy-MM-dd") · @Model.Folder.Author · @((Model.Folder.FileCount ?? 0).ToString()) files</span>
+            }
+            @if (Model.Keywords.Count > 0)
+            {
+                <div class="d-flex flex-wrap gap-1">
+                    @foreach (var tag in Model.Keywords)
+                    {
+                        <a class="badge text-bg-light text-decoration-none" href="@Url.Page("Index", null, new { keyword = tag })">@tag</a>
+                    }
+                </div>
+            }
+        </div>
+        <a class="btn btn-outline-secondary" href="@Model.BackUrl">Back</a>
+    </div>
+
+    @if (Model.Folder is null)
+    {
+        <div class="alert alert-secondary">Folder not found.</div>
+    }
+    else if (Model.Images.Count == 0)
+    {
+        <div class="alert alert-secondary">No images found.</div>
+    }
+    else
+    {
+        <div id="thumbs" class="row g-3">
+            @foreach (var image in Model.Images)
+            {
+                <div class="col-6 col-md-4 col-lg-3">
+                    <button class="card text-start border-0 shadow-sm w-100"
+                            type="button"
+                            data-thumb="true"
+                            data-url="@image.Url"
+                            data-name="@image.FileName">
+                        <img class="card-img-top" src="@image.ThumbnailUrl" alt="@image.FileName" loading="lazy" style="aspect-ratio: 1 / 1; object-fit: cover;" />
+                    </button>
+                </div>
+            }
+        </div>
+    }
+</div>
+
+<div class="modal fade" id="folderImageModal" tabindex="-1" aria-labelledby="folderImageModalLabel" aria-hidden="true">
+    <div class="modal-dialog modal-fullscreen modal-xl modal-dialog-centered">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h5 class="modal-title" id="folderImageModalLabel">Image</h5>
+                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
+            </div>
+            <div class="modal-body">
+                <img id="folderModalImage" class="img-fluid d-block mx-auto" alt="image" />
+            </div>
+        </div>
+    </div>
+</div>
+
+@section Scripts {
+    <script>
+        const modalEl = document.getElementById("folderImageModal");
+        const modalImage = document.getElementById("folderModalImage");
+        const modalTitle = document.getElementById("folderImageModalLabel");
+        const modalBody = modalEl?.querySelector(".modal-body");
+        const modal = new bootstrap.Modal(modalEl);
+        const thumbs = Array.from(document.querySelectorAll("[data-thumb='true']"));
+        let currentIndex = 0;
+
+        function setModalByIndex(index) {
+            if (thumbs.length === 0) {
+                return;
+            }
+
+            const clamped = Math.max(0, Math.min(index, thumbs.length - 1));
+            const target = thumbs[clamped];
+            const url = target.dataset.url;
+            const name = target.dataset.name || "image";
+            if (url) {
+                modalImage.src = url;
+                modalImage.alt = name;
+                modalTitle.textContent = name;
+                currentIndex = clamped;
+            }
+        }
+
+        thumbs.forEach((button, index) => {
+            button.addEventListener("click", () => {
+                currentIndex = index;
+                setModalByIndex(currentIndex);
+                modal.show();
+            });
+        });
+
+        document.addEventListener("keydown", event => {
+            if (!modalEl?.classList.contains("show")) {
+                return;
+            }
+
+            if (event.key === "ArrowLeft") {
+                event.preventDefault();
+                setModalByIndex(currentIndex - 1);
+            } else if (event.key === "ArrowRight") {
+                event.preventDefault();
+                setModalByIndex(currentIndex + 1);
+            }
+        });
+
+        if (modalBody) {
+            let touchStartX = 0;
+            let touchStartY = 0;
+
+            modalBody.addEventListener("touchstart", event => {
+                const touch = event.touches[0];
+                if (!touch) {
+                    return;
+                }
+                touchStartX = touch.clientX;
+                touchStartY = touch.clientY;
+            }, { passive: true });
+
+            modalBody.addEventListener("touchend", event => {
+                const touch = event.changedTouches[0];
+                if (!touch) {
+                    return;
+                }
+
+                const dx = touch.clientX - touchStartX;
+                const dy = touch.clientY - touchStartY;
+                if (Math.abs(dx) < 40 || Math.abs(dx) < Math.abs(dy)) {
+                    return;
+                }
+
+                if (dx > 0) {
+                    setModalByIndex(currentIndex - 1);
+                } else {
+                    setModalByIndex(currentIndex + 1);
+                }
+            }, { passive: true });
+        }
+    </script>
+}
diff --git a/Pages/Folder.cshtml.cs b/Pages/Folder.cshtml.cs
new file mode 100644
index 0000000..d880968
--- /dev/null
+++ b/Pages/Folder.cshtml.cs
@@ -0,0 +1,134 @@
+using Microsoft.AspNetCore.Mvc;
+using Microsoft.AspNetCore.Mvc.RazorPages;
+using Microsoft.AspNetCore.StaticFiles;
+using Microsoft.EntityFrameworkCore;
+using Sakayaki.Models;
+using Sakayaki.Services;
+
+namespace Sakayaki.Pages;
+
+public class FolderModel(AppDbContext dbContext, ThumbnailService thumbnailService, IConfiguration configuration) : PageModel
+{
+    private static readonly HashSet<string> ImageExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"
+    };
+
+    private readonly AppDbContext _dbContext = dbContext;
+    private readonly ThumbnailService _thumbnailService = thumbnailService;
+    private readonly string? _rootPath = configuration["Fanbox:RootPath"];
+
+    public sealed record ImageItem(string FileName, string Url, string ThumbnailUrl);
+
+    public FanboxFolder? Folder { get; private set; }
+    public IReadOnlyList<string> Keywords { get; private set; } = Array.Empty<string>();
+    public IReadOnlyList<ImageItem> Images { get; private set; } = Array.Empty<ImageItem>();
+    public string? Keyword { get; private set; }
+    public int? ReturnPage { get; private set; }
+
+    public string BackUrl =>
+        Url.Page("Index", null, new { keyword = Keyword, p = ReturnPage }) ?? Url.Page("Index") ?? "/";
+
+    public async Task OnGetAsync(Guid id, string? keyword, int? p)
+    {
+        Keyword = string.IsNullOrWhiteSpace(keyword) ? null : keyword.Trim();
+        ReturnPage = p is > 1 ? p : null;
+
+        Folder = await _dbContext.FanboxFolders.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id);
+        if (Folder is null)
+        {
+            return;
+        }
+
+        if (!string.IsNullOrWhiteSpace(Folder.Keywords))
+        {
+            Keywords = Folder.Keywords
+                .Split(",", StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+                .ToArray();
+        }
+
+        if (string.IsNullOrWhiteSpace(_rootPath))
+        {
+            return;
+        }
+
+        var folderPath = Path.Combine(_rootPath, Folder.FolderName);
+        if (!Directory.Exists(folderPath))
+        {
+            return;
+        }
+
+        var images = Directory.GetFiles(folderPath)
+            .Where(path => ImageExtensions.Contains(Path.GetExtension(path)))
+            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
+            .Select(path =>
+            {
+                var fileName = Path.GetFileName(path);
+                var url = Url.Page("Folder", "Image", new { id = Folder.Id, file = fileName }) ?? string.Empty;
+                var thumbnailUrl = Url.Page("Folder", "Thumbnail", new { id = Folder.Id, file = fileName }) ?? string.Empty;
+                return new ImageItem(fileName, url, thumbnailUrl);
+            })
+            .ToArray();
+
+        Images = images;
+    }
+
+    public async Task<IActionResult> OnGetImageAsync(Guid id, string file)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath) || string.IsNullOrWhiteSpace(file))
+            return NotFound();
+
+        var safeFile = Path.GetFileName(file);
+        if (string.IsNullOrWhiteSpace(safeFile))
+            return NotFound();
+        if (!ImageExtensions.Contains(Path.GetExtension(safeFile)))
+            return NotFound();
+
+        var folder = await _dbContext.FanboxFolders.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id);
+        if (folder is null)
+            return NotFound();
+
+        var filePath = Path.Combine(_rootPath, folder.FolderName, safeFile);
+        if (!System.IO.File.Exists(filePath))
+            return NotFound();
+
+        var provider = new FileExtensionContentTypeProvider();
+        if (!provider.TryGetContentType(filePath, out var contentType))
+            contentType = "application/octet-stream";
+
+        return PhysicalFile(filePath, contentType);
+    }
+
+    public async Task<IActionResult> OnGetThumbnailAsync(Guid id, string file)
+    {
+        if (string.IsNullOrWhiteSpace(file))
+            return NotFound();
+
+        var safeFile = Path.GetFileName(file);
+        if (string.IsNullOrWhiteSpace(safeFile))
+            return NotFound();
+        if (!ImageExtensions.Contains(Path.GetExtension(safeFile)))
+            return NotFound();
+
+        var folder = await _dbContext.FanboxFolders.AsNoTracking()
+            .FirstOrDefaultAsync(x => x.Id == id);
+        if (folder is null)
+            return NotFound();
+
+        var thumbPath = _thumbnailService.GetThumbnailPath(folder.Id, safeFile);
+        if (string.IsNullOrWhiteSpace(thumbPath))
+            return NotFound();
+
+        if (!System.IO.File.Exists(thumbPath))
+        {
+            await _thumbnailService.EnsureThumbnailAsync(folder.Id, folder.FolderName, safeFile, HttpContext.RequestAborted);
+        }
+
+        if (!System.IO.File.Exists(thumbPath))
+            return NotFound();
+
+        return PhysicalFile(thumbPath, "image/jpeg");
+    }
+}
diff --git a/Pages/Index.cshtml b/Pages/Index.cshtml
index 4c75cf9..a3bc793 100644
--- a/Pages/Index.cshtml
+++ b/Pages/Index.cshtml
@@ -30,7 +30,7 @@
     <div class="alert alert-info mt-3">@Model.StatusMessage</div>
 }
 
-<div class="row row-cols-1 row-cols-sm-2 row-cols-lg-6 g-3 mt-3">
+<div class="row row-cols-1 row-cols-sm-2 row-cols-lg-4 g-3 mt-3">
     @if (Model.Folders.Count == 0)
     {
         <div class="col">
@@ -43,14 +43,10 @@
         {
             var item = card.Folder;
             <div class="col">
-                <button type="button"
-                        class="card h-100 text-start shadow-sm folder-card"
-                        data-folder-id="@item.Id"
-                        data-title="@item.Title"
-                        data-date="@item.Date.ToString("yyyy-MM-dd")"
-                        data-author="@item.Author"
-                        data-count="@(item.FileCount ?? 0)"
-                        data-keywords="@item.Keywords">
+                <a class="card h-100 text-start shadow-sm text-decoration-none"
+                   data-folder-link="true"
+                   data-folder-id="@item.Id"
+                   href="@Url.Page("Folder", null, new { id = item.Id, keyword = Model.Keyword, p = Model.PageNumber > 1 ? Model.PageNumber : (int?)null })">
                     @if (!string.IsNullOrWhiteSpace(card.CoverUrl))
                     {
                         <img src="@card.CoverUrl" alt="@card.CoverFileName" class="card-img-top" />
@@ -66,7 +62,7 @@
                             <span class="badge text-bg-light">@((item.FileCount ?? 0).ToString()) files</span>
                         </div>
                     </div>
-                </button>
+                </a>
             </div>
         }
     }
@@ -78,7 +74,7 @@
         <ul class="pagination mb-0">
             <li class="page-item @(Model.PageNumber <= 1 ? "disabled" : "")">
                 <a class="page-link"
-                   href="@Url.Page("Index", null, new { page = Model.PageNumber - 1, keyword = Model.Keyword })"
+                   href="@Url.Page("Index", null, new { p = Model.PageNumber - 1, keyword = Model.Keyword })"
                    aria-label="Previous">
                     <span aria-hidden="true">«</span>
                 </a>
@@ -86,12 +82,12 @@
             @for (var i = 1; i <= Model.TotalPages; i++)
             {
                 <li class="page-item @(i == Model.PageNumber ? "active" : "")">
-                    <a class="page-link" href="@Url.Page("Index", null, new { page = i, keyword = Model.Keyword })">@i</a>
+                    <a class="page-link" href="@Url.Page("Index", null, new { p = i, keyword = Model.Keyword })">@i</a>
                 </li>
             }
             <li class="page-item @(Model.PageNumber >= Model.TotalPages ? "disabled" : "")">
                 <a class="page-link"
-                   href="@Url.Page("Index", null, new { page = Model.PageNumber + 1, keyword = Model.Keyword })"
+                   href="@Url.Page("Index", null, new { p = Model.PageNumber + 1, keyword = Model.Keyword })"
                    aria-label="Next">
                     <span aria-hidden="true">»</span>
                 </a>
@@ -100,125 +96,39 @@
     </nav>
 }
 
-<div class="modal fade" id="folderModal" tabindex="-1" aria-labelledby="folderModalLabel" aria-hidden="true">
-    <div class="modal-dialog modal-xl modal-dialog-scrollable">
-        <div class="modal-content">
-            <div class="modal-header">
-                <h5 class="modal-title" id="folderModalLabel">Files</h5>
-                <button type="button" class="btn-close" data-bs-dismiss="modal" aria-label="Close"></button>
-            </div>
-            <div class="modal-body">
-                <div id="folderMeta" class="mb-2 text-muted small"></div>
-                <div id="folderKeywords" class="mb-2"></div>
-                <div id="folderLoading" class="alert alert-light border">Loading...</div>
-                <div id="folderEmpty" class="alert alert-secondary d-none">No images found.</div>
-                <div id="folderImages" class="row g-2"></div>
-            </div>
+<div id="thumbWait" class="position-fixed top-0 start-0 w-100 h-100 d-none" style="z-index: 1080;">
+    <div class="d-flex align-items-center justify-content-center w-100 h-100 bg-dark bg-opacity-50">
+        <div class="text-center text-white">
+            <div class="spinner-border text-light" role="status" aria-hidden="true"></div>
+            <div class="mt-2">Please wait, generating thumbnails...</div>
         </div>
     </div>
 </div>
 
 @section Scripts {
     <script>
-        const modalEl = document.getElementById("folderModal");
-        const folderModal = new bootstrap.Modal(modalEl);
-        const titleEl = document.getElementById("folderModalLabel");
-        const metaEl = document.getElementById("folderMeta");
-        const keywordsEl = document.getElementById("folderKeywords");
-        const loadingEl = document.getElementById("folderLoading");
-        const emptyEl = document.getElementById("folderEmpty");
-        const imagesEl = document.getElementById("folderImages");
-
-        function setLoading(isLoading) {
-            loadingEl.classList.toggle("d-none", !isLoading);
-        }
-
-        function setEmpty(isEmpty) {
-            emptyEl.classList.toggle("d-none", !isEmpty);
-        }
-
-        function clearImages() {
-            imagesEl.innerHTML = "";
-        }
-
-        function renderKeywords(raw) {
-            keywordsEl.innerHTML = "";
-            if (!raw) {
-                return;
-            }
-
-            const list = raw.split(",").map(k => k.trim()).filter(k => k.length > 0);
-            if (list.length === 0) {
-                return;
-            }
-
-            const label = document.createElement("span");
-            label.className = "text-muted small me-2";
-            label.textContent = "Keywords:";
-            keywordsEl.appendChild(label);
-
-            for (const keyword of list) {
-                const link = document.createElement("a");
-                link.href = `?keyword=${encodeURIComponent(keyword)}`;
-                link.className = "badge text-bg-light me-1 text-decoration-none";
-                link.textContent = keyword;
-                keywordsEl.appendChild(link);
-            }
-        }
-
-        async function loadImages(folderId) {
-            setLoading(true);
-            setEmpty(false);
-            clearImages();
-
-            try {
-                const response = await fetch(`?handler=Images&id=${encodeURIComponent(folderId)}`);
-                if (!response.ok) {
-                    setEmpty(true);
+        const waitOverlay = document.getElementById("thumbWait");
+        document.querySelectorAll("[data-folder-link='true']").forEach(link => {
+            link.addEventListener("click", async event => {
+                if (event.button !== 0 || event.metaKey || event.ctrlKey || event.shiftKey || event.altKey) {
                     return;
                 }
 
-                const files = await response.json();
-                if (!files || files.length === 0) {
-                    setEmpty(true);
+                const folderId = link.dataset.folderId;
+                if (!folderId) {
                     return;
                 }
 
-                for (const file of files) {
-                    const col = document.createElement("div");
-                    col.className = "col-6 col-md-4 col-lg-3";
+                event.preventDefault();
+                waitOverlay?.classList.remove("d-none");
 
-                    const img = document.createElement("img");
-                    img.src = file.url;
-                    img.alt = file.fileName || "image";
-                    img.loading = "lazy";
-                    img.className = "img-fluid rounded border";
-
-                    col.appendChild(img);
-                    imagesEl.appendChild(col);
+                try {
+                    await fetch(`?handler=EnsureThumbnails&id=${encodeURIComponent(folderId)}`);
+                } catch (error) {
+                    console.warn("Thumbnail generation failed", error);
                 }
-            } finally {
-                setLoading(false);
-            }
-        }
 
-        document.querySelectorAll(".folder-card").forEach(card => {
-            card.addEventListener("click", () => {
-                const title = card.dataset.title || "Files";
-                const date = card.dataset.date || "";
-                const author = card.dataset.author || "";
-                const count = card.dataset.count || "0";
-                const keywords = card.dataset.keywords || "";
-
-                titleEl.textContent = title;
-                metaEl.textContent = `${date} · ${author} · ${count} files`;
-                renderKeywords(keywords);
-
-                const folderId = card.dataset.folderId;
-                if (folderId) {
-                    loadImages(folderId);
-                    folderModal.show();
-                }
+                window.location.href = link.href;
             });
         });
     </script>
diff --git a/Pages/Index.cshtml.cs b/Pages/Index.cshtml.cs
index 9147cce..e21e06d 100644
--- a/Pages/Index.cshtml.cs
+++ b/Pages/Index.cshtml.cs
@@ -7,7 +7,7 @@
 
 namespace Sakayaki.Pages;
 
-public class IndexModel(SyncService syncService, AppDbContext dbContext, IConfiguration configuration) : PageModel
+public class IndexModel(SyncService syncService, ThumbnailService thumbnailService, AppDbContext dbContext, IConfiguration configuration) : PageModel
 {
     private static readonly HashSet<string> ImageExtensions = new(StringComparer.OrdinalIgnoreCase)
     {
@@ -15,6 +15,7 @@
     };
 
     private readonly SyncService _syncService = syncService;
+    private readonly ThumbnailService _thumbnailService = thumbnailService;
     private readonly AppDbContext _dbContext = dbContext;
     private readonly string? _rootPath = configuration["Fanbox:RootPath"];
     private readonly string? _author = configuration["Fanbox:Author"];
@@ -35,10 +36,10 @@
     public int TotalPages { get; private set; } = 1;
     public int PageSize { get; } = 30;
 
-    public async Task OnGetAsync(string? keyword, int page = 1)
+    public async Task OnGetAsync(string? keyword, int p = 1)
     {
         Keyword = string.IsNullOrWhiteSpace(keyword) ? null : keyword.Trim();
-        PageNumber = Math.Max(1, page);
+        PageNumber = Math.Max(1, p);
 
         var query = _dbContext.FanboxFolders.AsNoTracking();
         if (!string.IsNullOrWhiteSpace(Keyword))
@@ -111,31 +112,17 @@
         return RedirectToPage();
     }
 
-    public async Task<IActionResult> OnGetImagesAsync(Guid id)
+    public async Task<IActionResult> OnGetEnsureThumbnailsAsync(Guid id)
     {
-        if (string.IsNullOrWhiteSpace(_rootPath))
-            return new JsonResult(Array.Empty<object>());
-
         var folder = await _dbContext.FanboxFolders.AsNoTracking()
             .FirstOrDefaultAsync(x => x.Id == id);
         if (folder is null)
-            return new JsonResult(Array.Empty<object>());
+        {
+            return NotFound();
+        }
 
-        var folderPath = Path.Combine(_rootPath, folder.FolderName);
-        if (!Directory.Exists(folderPath))
-            return new JsonResult(Array.Empty<object>());
-
-        var images = Directory.GetFiles(folderPath)
-            .Where(path => ImageExtensions.Contains(Path.GetExtension(path)))
-            .OrderBy(path => path, StringComparer.OrdinalIgnoreCase)
-            .Select(path => new
-            {
-                fileName = Path.GetFileName(path),
-                url = Url.Page("Index", "Image", new { id = folder.Id, file = Path.GetFileName(path) }) ?? string.Empty
-            })
-            .ToArray();
-
-        return new JsonResult(images);
+        var created = await _thumbnailService.EnsureFolderThumbnailsAsync(folder.Id, folder.FolderName, HttpContext.RequestAborted);
+        return new JsonResult(new { created });
     }
 
     public async Task<IActionResult> OnGetImageAsync(Guid id, string file)
diff --git a/Pages/Shared/_Layout.cshtml b/Pages/Shared/_Layout.cshtml
index 95871c8..3dea9c8 100644
--- a/Pages/Shared/_Layout.cshtml
+++ b/Pages/Shared/_Layout.cshtml
@@ -8,7 +8,7 @@
     <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous" />
 </head>
 <body>
-    <div class="container-fluid m-3">
+    <div class="container my-3">
         <main role="main" class="pb-3">
             @RenderBody()
         </main>
diff --git a/Program.cs b/Program.cs
index f8d18ae..7318a08 100644
--- a/Program.cs
+++ b/Program.cs
@@ -8,6 +8,7 @@
 builder.Services.AddDbContext<AppDbContext>(options =>
     options.UseSqlServer(builder.Configuration.GetConnectionString("DefaultConnection")));
 builder.Services.AddScoped<SyncService>();
+builder.Services.AddSingleton<ThumbnailService>();
 
 var app = builder.Build();
 
diff --git a/Sakayaki.csproj b/Sakayaki.csproj
index 76ab7a1..8aece80 100644
--- a/Sakayaki.csproj
+++ b/Sakayaki.csproj
@@ -9,6 +9,8 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.EntityFrameworkCore" Version="9.0.0" />
     <PackageReference Include="Microsoft.EntityFrameworkCore.SqlServer" Version="9.0.0" />
+    <PackageReference Include="SkiaSharp" Version="2.88.8" />
+    <PackageReference Include="SkiaSharp.NativeAssets.Linux.NoDependencies" Version="2.88.8" />
   </ItemGroup>
 
 </Project>
diff --git a/Services/ThumbnailService.cs b/Services/ThumbnailService.cs
new file mode 100644
index 0000000..7b10351
--- /dev/null
+++ b/Services/ThumbnailService.cs
@@ -0,0 +1,217 @@
+using SkiaSharp;
+
+namespace Sakayaki.Services;
+
+public sealed class ThumbnailService
+{
+    private static readonly HashSet<string> ImageExtensions = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"
+    };
+
+    private const int MinSize = 250;
+    private const int JpegQuality = 82;
+    private readonly string? _rootPath;
+    private readonly string? _thumbnailRoot;
+    private readonly ILogger<ThumbnailService> _logger;
+
+    public ThumbnailService(IConfiguration configuration, ILogger<ThumbnailService> logger)
+    {
+        _rootPath = configuration["Fanbox:RootPath"];
+        _thumbnailRoot = configuration["Fanbox:ThumbnailRoot"];
+        _logger = logger;
+        TryEnsureRoot();
+    }
+
+    public string? GetThumbnailPath(Guid folderId, string fileName)
+    {
+        if (string.IsNullOrWhiteSpace(fileName))
+        {
+            return null;
+        }
+
+        var safeName = Path.GetFileName(fileName);
+        if (string.IsNullOrWhiteSpace(safeName))
+        {
+            return null;
+        }
+
+        var thumbName = Path.ChangeExtension(safeName, ".jpg");
+        if (string.IsNullOrWhiteSpace(_thumbnailRoot))
+        {
+            return null;
+        }
+
+        var dir = Path.Combine(_thumbnailRoot, folderId.ToString("N"));
+        return Path.Combine(dir, thumbName);
+    }
+
+    public string? GetOriginalPath(string folderName, string fileName)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath))
+        {
+            return null;
+        }
+
+        var safeName = Path.GetFileName(fileName);
+        if (string.IsNullOrWhiteSpace(safeName))
+        {
+            return null;
+        }
+
+        return Path.Combine(_rootPath, folderName, safeName);
+    }
+
+    public async Task<int> EnsureFolderThumbnailsAsync(Guid folderId, string folderName, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath))
+        {
+            return 0;
+        }
+
+        var folderPath = Path.Combine(_rootPath, folderName);
+        if (!Directory.Exists(folderPath))
+        {
+            return 0;
+        }
+
+        var files = Directory.GetFiles(folderPath)
+            .Where(path => ImageExtensions.Contains(Path.GetExtension(path)))
+            .Select(Path.GetFileName)
+            .Where(name => !string.IsNullOrWhiteSpace(name))
+            .ToArray();
+
+        if (files.Length == 0)
+        {
+            return 0;
+        }
+
+        var created = 0;
+        var maxConcurrency = Math.Max(1, Environment.ProcessorCount);
+        using var gate = new SemaphoreSlim(maxConcurrency, maxConcurrency);
+        var tasks = new List<Task>(files.Length);
+
+        foreach (var fileName in files)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var thumbPath = GetThumbnailPath(folderId, fileName);
+            if (thumbPath is null || File.Exists(thumbPath))
+            {
+                continue;
+            }
+
+            await gate.WaitAsync(cancellationToken);
+            tasks.Add(Task.Run(async () =>
+            {
+                try
+                {
+                    if (await EnsureThumbnailAsync(folderId, folderName, fileName, cancellationToken))
+                    {
+                        Interlocked.Increment(ref created);
+                    }
+                }
+                finally
+                {
+                    gate.Release();
+                }
+            }, cancellationToken));
+        }
+
+        await Task.WhenAll(tasks);
+        return created;
+    }
+
+    public Task<bool> EnsureThumbnailAsync(Guid folderId, string folderName, string fileName, CancellationToken cancellationToken)
+    {
+        if (string.IsNullOrWhiteSpace(_rootPath))
+        {
+            return Task.FromResult(false);
+        }
+
+        var originalPath = GetOriginalPath(folderName, fileName);
+        if (string.IsNullOrWhiteSpace(originalPath) || !File.Exists(originalPath))
+        {
+            return Task.FromResult(false);
+        }
+
+        var thumbPath = GetThumbnailPath(folderId, fileName);
+        if (string.IsNullOrWhiteSpace(thumbPath))
+        {
+            return Task.FromResult(false);
+        }
+
+        if (File.Exists(thumbPath))
+        {
+            return Task.FromResult(true);
+        }
+
+        return Task.Run(() =>
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                Directory.CreateDirectory(Path.GetDirectoryName(thumbPath) ?? _thumbnailRoot);
+                return TryCreateThumbnail(originalPath, thumbPath);
+            }
+            catch (Exception ex)
+            {
+                _logger.LogWarning(ex, "Failed to create thumbnail for {FileName}", fileName);
+                return false;
+            }
+        }, cancellationToken);
+    }
+
+    private static bool TryCreateThumbnail(string sourcePath, string thumbPath)
+    {
+        using var bitmap = SKBitmap.Decode(sourcePath);
+        if (bitmap is null)
+        {
+            return false;
+        }
+
+        var minSide = Math.Min(bitmap.Width, bitmap.Height);
+        var scale = minSide > 0 ? MinSize / (float)minSide : 1f;
+        var targetWidth = Math.Max(1, (int)Math.Round(bitmap.Width * scale));
+        var targetHeight = Math.Max(1, (int)Math.Round(bitmap.Height * scale));
+
+        SKBitmap? resized = null;
+        var target = bitmap;
+        if (scale < 1f)
+        {
+            resized = bitmap.Resize(new SKImageInfo(targetWidth, targetHeight), SKFilterQuality.Medium);
+            if (resized is null)
+            {
+                return false;
+            }
+            target = resized;
+        }
+
+        using var image = SKImage.FromBitmap(target);
+        using var data = image.Encode(SKEncodedImageFormat.Jpeg, JpegQuality);
+        using var stream = File.Open(thumbPath, FileMode.Create, FileAccess.Write, FileShare.None);
+        data.SaveTo(stream);
+
+        resized?.Dispose();
+        return true;
+    }
+
+    private void TryEnsureRoot()
+    {
+        try
+        {
+            if (string.IsNullOrWhiteSpace(_thumbnailRoot))
+            {
+                return;
+            }
+
+            Directory.CreateDirectory(_thumbnailRoot);
+        }
+        catch (Exception ex)
+        {
+            _logger.LogWarning(ex, "Failed to ensure thumbnail root at {ThumbnailRoot}", _thumbnailRoot);
+        }
+    }
+
+}
diff --git a/appsettings.Development.json b/appsettings.Development.json
index b2e80a1..77ef33d 100644
--- a/appsettings.Development.json
+++ b/appsettings.Development.json
@@ -7,7 +7,8 @@
     }
   },
   "Fanbox": {
-    "RootPath": "C:\\Users\\smdhz\\Downloads\\fanbox\\月代",
-    "Author": "月代"
+    "RootPath": "E:\\Picture\\fanbox\\月代",
+    "Author": "月代",
+    "ThumbnailRoot": "D:\\Workspace\\Temp\\fanbox-thumbnail"
   }
 }
diff --git a/appsettings.json b/appsettings.json
index 76a1b7b..c99a150 100644
--- a/appsettings.json
+++ b/appsettings.json
@@ -10,7 +10,8 @@
   },
   "Fanbox": {
     "RootPath": "/mnt/media/Picture/fanbox/月代",
-    "Author": "月代"
+    "Author": "月代",
+    "ThumbnailRoot": "/var/thumbnail"
   },
   "AllowedHosts": "*"
 }