Merge ee718e9047 into 49f97b69ca

## Summary

* **What is the goal of this PR?** 

Add support for reading plain text (.txt) files, enabling users to
browse, read, and track progress in TXT documents alongside existing
EPUB and XTC formats.

* **What changes are included?**

- New Txt library for loading and parsing plain text files
- New TxtReaderActivity with streaming page rendering using 8KB chunks
to handle large files without memory issues on ESP32-C3
- Page index caching system (index.bin) for instant re-open after sleep
or app restart
- Progress bar UI during initial file indexing (matching EPUB style)
- Word wrapping with proper UTF-8 support
- Cover image support for TXT files:
- Primary: image with same filename as TXT (e.g., book.jpg for book.txt)
  - Fallback: cover.bmp/jpg/jpeg in the same folder
  - JPG to BMP conversion using existing converter
  - Sleep screen cover mode now works with TXT files
- File browser now shows .txt files

## Additional Context

* Add any other information that might be helpful for the reviewer

* Memory constraints: The streaming approach was necessary because
ESP32-C3 only has 320KB RAM. A 700KB TXT file cannot be loaded entirely
into memory, so we read 8KB chunks and build a page offset index
instead.

* Cache invalidation: The page index cache automatically invalidates
when file size, viewport width, or lines per page changes (e.g., font
size or orientation change).

* Performance: First open requires indexing (with progress bar),
subsequent opens load from cache instantly.

* Cover image format: PNG is detected but not supported for conversion
(no PNG decoder available). Only BMP and JPG/JPEG work.

.github/workflows/pr-formatting-check.yml

@@ -0,0 +1,26 @@
+name: "PR Formatting"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+      - edited
+
+permissions:
+  statuses: write
+
+jobs:
+  title-check:
+    name: Title Check
+    runs-on: ubuntu-latest
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@ec9f2d5744a09debf3a187a3f4f675c53b671911 # v2.13.0
+        with:
+          egress-policy: audit
+
+      - name: Check PR Title
+        uses: amannn/action-semantic-pull-request@v6
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

lib/Epub/Epub.cpp

@@ -409,6 +409,70 @@ bool Epub::generateCoverBmp(bool cropped) const {
   return false;
 }
 
+std::string Epub::getThumbBmpPath() const { return cachePath + "/thumb.bmp"; }
+
+bool Epub::generateThumbBmp() const {
+  // Already generated, return true
+  if (SdMan.exists(getThumbBmpPath().c_str())) {
+    return true;
+  }
+
+  if (!bookMetadataCache || !bookMetadataCache->isLoaded()) {
+    Serial.printf("[%lu] [EBP] Cannot generate thumb BMP, cache not loaded\n", millis());
+    return false;
+  }
+
+  const auto coverImageHref = bookMetadataCache->coreMetadata.coverItemHref;
+  if (coverImageHref.empty()) {
+    Serial.printf("[%lu] [EBP] No known cover image for thumbnail\n", millis());
+    return false;
+  }
+
+  if (coverImageHref.substr(coverImageHref.length() - 4) == ".jpg" ||
+      coverImageHref.substr(coverImageHref.length() - 5) == ".jpeg") {
+    Serial.printf("[%lu] [EBP] Generating thumb BMP from JPG cover image\n", millis());
+    const auto coverJpgTempPath = getCachePath() + "/.cover.jpg";
+
+    FsFile coverJpg;
+    if (!SdMan.openFileForWrite("EBP", coverJpgTempPath, coverJpg)) {
+      return false;
+    }
+    readItemContentsToStream(coverImageHref, coverJpg, 1024);
+    coverJpg.close();
+
+    if (!SdMan.openFileForRead("EBP", coverJpgTempPath, coverJpg)) {
+      return false;
+    }
+
+    FsFile thumbBmp;
+    if (!SdMan.openFileForWrite("EBP", getThumbBmpPath(), thumbBmp)) {
+      coverJpg.close();
+      return false;
+    }
+    // Use smaller target size for Continue Reading card (half of screen: 240x400)
+    // Generate 1-bit BMP for fast home screen rendering (no gray passes needed)
+    constexpr int THUMB_TARGET_WIDTH = 240;
+    constexpr int THUMB_TARGET_HEIGHT = 400;
+    const bool success = JpegToBmpConverter::jpegFileTo1BitBmpStreamWithSize(coverJpg, thumbBmp, THUMB_TARGET_WIDTH,
+                                                                             THUMB_TARGET_HEIGHT);
+    coverJpg.close();
+    thumbBmp.close();
+    SdMan.remove(coverJpgTempPath.c_str());
+
+    if (!success) {
+      Serial.printf("[%lu] [EBP] Failed to generate thumb BMP from JPG cover image\n", millis());
+      SdMan.remove(getThumbBmpPath().c_str());
+    }
+    Serial.printf("[%lu] [EBP] Generated thumb BMP from JPG cover image, success: %s\n", millis(),
+                  success ? "yes" : "no");
+    return success;
+  } else {
+    Serial.printf("[%lu] [EBP] Cover image is not a JPG, skipping thumbnail\n", millis());
+  }
+
+  return false;
+}
+
 uint8_t* Epub::readItemContentsToBytes(const std::string& itemHref, size_t* size, const bool trailingNullByte) const {
   if (itemHref.empty()) {
     Serial.printf("[%lu] [EBP] Failed to read item, empty href\n", millis());

lib/Epub/Epub.h

@@ -46,6 +46,8 @@ class Epub {
   const std::string& getAuthor() const;
   std::string getCoverBmpPath(bool cropped = false) const;
   bool generateCoverBmp(bool cropped = false) const;
+  std::string getThumbBmpPath() const;
+  bool generateThumbBmp() const;
   uint8_t* readItemContentsToBytes(const std::string& itemHref, size_t* size = nullptr,
                                    bool trailingNullByte = false) const;
   bool readItemContentsToStream(const std::string& itemHref, Print& out, size_t chunkSize) const;

lib/GfxRenderer/Bitmap.cpp

@@ -228,7 +228,10 @@ BmpReaderError Bitmap::readNextRow(uint8_t* data, uint8_t* rowBuffer) const {
     }
     case 1: {
       for (int x = 0; x < width; x++) {
-        lum = (rowBuffer[x >> 3] & (0x80 >> (x & 7))) ? 0xFF : 0x00;
+        // Get palette index (0 or 1) from bit at position x
+        const uint8_t palIndex = (rowBuffer[x >> 3] & (0x80 >> (x & 7))) ? 1 : 0;
+        // Use palette lookup for proper black/white mapping
+        lum = paletteLum[palIndex];
         packPixel(lum);
       }
       break;

lib/GfxRenderer/Bitmap.h

@@ -42,6 +42,8 @@ class Bitmap {
   bool isTopDown() const { return topDown; }
   bool hasGreyscale() const { return bpp > 1; }
   int getRowBytes() const { return rowBytes; }
+  bool is1Bit() const { return bpp == 1; }
+  uint16_t getBpp() const { return bpp; }
 
  private:
   static uint16_t readLE16(FsFile& f);

lib/GfxRenderer/BitmapHelpers.cpp

@@ -88,3 +88,19 @@ uint8_t quantize(int gray, int x, int y) {
     return quantizeSimple(gray);
   }
 }
+
+// 1-bit noise dithering for fast home screen rendering
+// Uses hash-based noise for consistent dithering that works well at small sizes
+uint8_t quantize1bit(int gray, int x, int y) {
+  gray = adjustPixel(gray);
+
+  // Generate noise threshold using integer hash (no regular pattern to alias)
+  uint32_t hash = static_cast<uint32_t>(x) * 374761393u + static_cast<uint32_t>(y) * 668265263u;
+  hash = (hash ^ (hash >> 13)) * 1274126177u;
+  const int threshold = static_cast<int>(hash >> 24);  // 0-255
+
+  // Simple threshold with noise: gray >= (128 + noise offset) -> white
+  // The noise adds variation around the 128 midpoint
+  const int adjustedThreshold = 128 + ((threshold - 128) / 2);  // Range: 64-192
+  return (gray >= adjustedThreshold) ? 1 : 0;
+}

lib/GfxRenderer/BitmapHelpers.h

@@ -5,8 +5,89 @@
 // Helper functions
 uint8_t quantize(int gray, int x, int y);
 uint8_t quantizeSimple(int gray);
+uint8_t quantize1bit(int gray, int x, int y);
 int adjustPixel(int gray);
 
+// 1-bit Atkinson dithering - better quality than noise dithering for thumbnails
+// Error distribution pattern (same as 2-bit but quantizes to 2 levels):
+//     X  1/8 1/8
+// 1/8 1/8 1/8
+//     1/8
+class Atkinson1BitDitherer {
+ public:
+  explicit Atkinson1BitDitherer(int width) : width(width) {
+    errorRow0 = new int16_t[width + 4]();  // Current row
+    errorRow1 = new int16_t[width + 4]();  // Next row
+    errorRow2 = new int16_t[width + 4]();  // Row after next
+  }
+
+  ~Atkinson1BitDitherer() {
+    delete[] errorRow0;
+    delete[] errorRow1;
+    delete[] errorRow2;
+  }
+
+  // EXPLICITLY DELETE THE COPY CONSTRUCTOR
+  Atkinson1BitDitherer(const Atkinson1BitDitherer& other) = delete;
+
+  // EXPLICITLY DELETE THE COPY ASSIGNMENT OPERATOR
+  Atkinson1BitDitherer& operator=(const Atkinson1BitDitherer& other) = delete;
+
+  uint8_t processPixel(int gray, int x) {
+    // Apply brightness/contrast/gamma adjustments
+    gray = adjustPixel(gray);
+
+    // Add accumulated error
+    int adjusted = gray + errorRow0[x + 2];
+    if (adjusted < 0) adjusted = 0;
+    if (adjusted > 255) adjusted = 255;
+
+    // Quantize to 2 levels (1-bit): 0 = black, 1 = white
+    uint8_t quantized;
+    int quantizedValue;
+    if (adjusted < 128) {
+      quantized = 0;
+      quantizedValue = 0;
+    } else {
+      quantized = 1;
+      quantizedValue = 255;
+    }
+
+    // Calculate error (only distribute 6/8 = 75%)
+    int error = (adjusted - quantizedValue) >> 3;  // error/8
+
+    // Distribute 1/8 to each of 6 neighbors
+    errorRow0[x + 3] += error;  // Right
+    errorRow0[x + 4] += error;  // Right+1
+    errorRow1[x + 1] += error;  // Bottom-left
+    errorRow1[x + 2] += error;  // Bottom
+    errorRow1[x + 3] += error;  // Bottom-right
+    errorRow2[x + 2] += error;  // Two rows down
+
+    return quantized;
+  }
+
+  void nextRow() {
+    int16_t* temp = errorRow0;
+    errorRow0 = errorRow1;
+    errorRow1 = errorRow2;
+    errorRow2 = temp;
+    memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
+  }
+
+  void reset() {
+    memset(errorRow0, 0, (width + 4) * sizeof(int16_t));
+    memset(errorRow1, 0, (width + 4) * sizeof(int16_t));
+    memset(errorRow2, 0, (width + 4) * sizeof(int16_t));
+  }
+
+ private:
+  int width;
+  int16_t* errorRow0;
+  int16_t* errorRow1;
+  int16_t* errorRow2;
+};
+
 // Atkinson dithering - distributes only 6/8 (75%) of error for cleaner results
 // Error distribution pattern:
 //     X  1/8 1/8

lib/GfxRenderer/GfxRenderer.cpp

@@ -154,6 +154,12 @@ void GfxRenderer::drawImage(const uint8_t bitmap[], const int x, const int y, co
 
 void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, const int maxWidth, const int maxHeight,
                              const float cropX, const float cropY) const {
+  // For 1-bit bitmaps, use optimized 1-bit rendering path (no crop support for 1-bit)
+  if (bitmap.is1Bit() && cropX == 0.0f && cropY == 0.0f) {
+    drawBitmap1Bit(bitmap, x, y, maxWidth, maxHeight);
+    return;
+  }
+
   float scale = 1.0f;
   bool isScaled = false;
   int cropPixX = std::floor(bitmap.getWidth() * cropX / 2.0f);
@@ -195,6 +201,9 @@ void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, con
     if (screenY >= getScreenHeight()) {
       break;
     }
+    if (screenY < 0) {
+      continue;
+    }
 
     if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) {
       Serial.printf("[%lu] [GFX] Failed to read row %d from bitmap\n", millis(), bmpY);
@@ -217,6 +226,9 @@ void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, con
       if (screenX >= getScreenWidth()) {
         break;
       }
+      if (screenX < 0) {
+        continue;
+      }
 
       const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
 
@@ -234,6 +246,143 @@ void GfxRenderer::drawBitmap(const Bitmap& bitmap, const int x, const int y, con
   free(rowBytes);
 }
 
+void GfxRenderer::drawBitmap1Bit(const Bitmap& bitmap, const int x, const int y, const int maxWidth,
+                                 const int maxHeight) const {
+  float scale = 1.0f;
+  bool isScaled = false;
+  if (maxWidth > 0 && bitmap.getWidth() > maxWidth) {
+    scale = static_cast<float>(maxWidth) / static_cast<float>(bitmap.getWidth());
+    isScaled = true;
+  }
+  if (maxHeight > 0 && bitmap.getHeight() > maxHeight) {
+    scale = std::min(scale, static_cast<float>(maxHeight) / static_cast<float>(bitmap.getHeight()));
+    isScaled = true;
+  }
+
+  // For 1-bit BMP, output is still 2-bit packed (for consistency with readNextRow)
+  const int outputRowSize = (bitmap.getWidth() + 3) / 4;
+  auto* outputRow = static_cast<uint8_t*>(malloc(outputRowSize));
+  auto* rowBytes = static_cast<uint8_t*>(malloc(bitmap.getRowBytes()));
+
+  if (!outputRow || !rowBytes) {
+    Serial.printf("[%lu] [GFX] !! Failed to allocate 1-bit BMP row buffers\n", millis());
+    free(outputRow);
+    free(rowBytes);
+    return;
+  }
+
+  for (int bmpY = 0; bmpY < bitmap.getHeight(); bmpY++) {
+    // Read rows sequentially using readNextRow
+    if (bitmap.readNextRow(outputRow, rowBytes) != BmpReaderError::Ok) {
+      Serial.printf("[%lu] [GFX] Failed to read row %d from 1-bit bitmap\n", millis(), bmpY);
+      free(outputRow);
+      free(rowBytes);
+      return;
+    }
+
+    // Calculate screen Y based on whether BMP is top-down or bottom-up
+    const int bmpYOffset = bitmap.isTopDown() ? bmpY : bitmap.getHeight() - 1 - bmpY;
+    int screenY = y + (isScaled ? static_cast<int>(std::floor(bmpYOffset * scale)) : bmpYOffset);
+    if (screenY >= getScreenHeight()) {
+      continue;  // Continue reading to keep row counter in sync
+    }
+    if (screenY < 0) {
+      continue;
+    }
+
+    for (int bmpX = 0; bmpX < bitmap.getWidth(); bmpX++) {
+      int screenX = x + (isScaled ? static_cast<int>(std::floor(bmpX * scale)) : bmpX);
+      if (screenX >= getScreenWidth()) {
+        break;
+      }
+      if (screenX < 0) {
+        continue;
+      }
+
+      // Get 2-bit value (result of readNextRow quantization)
+      const uint8_t val = outputRow[bmpX / 4] >> (6 - ((bmpX * 2) % 8)) & 0x3;
+
+      // For 1-bit source: 0 or 1 -> map to black (0,1,2) or white (3)
+      // val < 3 means black pixel (draw it)
+      if (val < 3) {
+        drawPixel(screenX, screenY, true);
+      }
+      // White pixels (val == 3) are not drawn (leave background)
+    }
+  }
+
+  free(outputRow);
+  free(rowBytes);
+}
+
+void GfxRenderer::fillPolygon(const int* xPoints, const int* yPoints, int numPoints, bool state) const {
+  if (numPoints < 3) return;
+
+  // Find bounding box
+  int minY = yPoints[0], maxY = yPoints[0];
+  for (int i = 1; i < numPoints; i++) {
+    if (yPoints[i] < minY) minY = yPoints[i];
+    if (yPoints[i] > maxY) maxY = yPoints[i];
+  }
+
+  // Clip to screen
+  if (minY < 0) minY = 0;
+  if (maxY >= getScreenHeight()) maxY = getScreenHeight() - 1;
+
+  // Allocate node buffer for scanline algorithm
+  auto* nodeX = static_cast<int*>(malloc(numPoints * sizeof(int)));
+  if (!nodeX) {
+    Serial.printf("[%lu] [GFX] !! Failed to allocate polygon node buffer\n", millis());
+    return;
+  }
+
+  // Scanline fill algorithm
+  for (int scanY = minY; scanY <= maxY; scanY++) {
+    int nodes = 0;
+
+    // Find all intersection points with edges
+    int j = numPoints - 1;
+    for (int i = 0; i < numPoints; i++) {
+      if ((yPoints[i] < scanY && yPoints[j] >= scanY) || (yPoints[j] < scanY && yPoints[i] >= scanY)) {
+        // Calculate X intersection using fixed-point to avoid float
+        int dy = yPoints[j] - yPoints[i];
+        if (dy != 0) {
+          nodeX[nodes++] = xPoints[i] + (scanY - yPoints[i]) * (xPoints[j] - xPoints[i]) / dy;
+        }
+      }
+      j = i;
+    }
+
+    // Sort nodes by X (simple bubble sort, numPoints is small)
+    for (int i = 0; i < nodes - 1; i++) {
+      for (int k = i + 1; k < nodes; k++) {
+        if (nodeX[i] > nodeX[k]) {
+          int temp = nodeX[i];
+          nodeX[i] = nodeX[k];
+          nodeX[k] = temp;
+        }
+      }
+    }
+
+    // Fill between pairs of nodes
+    for (int i = 0; i < nodes - 1; i += 2) {
+      int startX = nodeX[i];
+      int endX = nodeX[i + 1];
+
+      // Clip to screen
+      if (startX < 0) startX = 0;
+      if (endX >= getScreenWidth()) endX = getScreenWidth() - 1;
+
+      // Draw horizontal line
+      for (int x = startX; x <= endX; x++) {
+        drawPixel(x, scanY, state);
+      }
+    }
+  }
+
+  free(nodeX);
+}
+
 void GfxRenderer::clearScreen(const uint8_t color) const { einkDisplay.clearScreen(color); }
 
 void GfxRenderer::invertScreen() const {

lib/GfxRenderer/GfxRenderer.h

@@ -68,6 +68,8 @@ class GfxRenderer {
   void drawImage(const uint8_t bitmap[], int x, int y, int width, int height) const;
   void drawBitmap(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight, float cropX = 0,
                   float cropY = 0) const;
+  void drawBitmap1Bit(const Bitmap& bitmap, int x, int y, int maxWidth, int maxHeight) const;
+  void fillPolygon(const int* xPoints, const int* yPoints, int numPoints, bool state = true) const;
 
   // Text
   int getTextWidth(int fontId, const char* text, EpdFontFamily::Style style = EpdFontFamily::REGULAR) const;
@@ -97,8 +99,8 @@ class GfxRenderer {
   void copyGrayscaleLsbBuffers() const;
   void copyGrayscaleMsbBuffers() const;
   void displayGrayBuffer() const;
-  bool storeBwBuffer();  // Returns true if buffer was stored successfully
-  void restoreBwBuffer();
+  bool storeBwBuffer();    // Returns true if buffer was stored successfully
+  void restoreBwBuffer();  // Restore and free the stored buffer
   void cleanupGrayscaleWithFrameBuffer() const;
 
   // Low level functions

lib/JpegToBmpConverter/JpegToBmpConverter.cpp

@@ -87,8 +87,47 @@ void writeBmpHeader8bit(Print& bmpOut, const int width, const int height) {
   }
 }
 
+// Helper function: Write BMP header with 1-bit color depth (black and white)
+static void writeBmpHeader1bit(Print& bmpOut, const int width, const int height) {
+  // Calculate row padding (each row must be multiple of 4 bytes)
+  const int bytesPerRow = (width + 31) / 32 * 4;  // 1 bit per pixel, round up to 4-byte boundary
+  const int imageSize = bytesPerRow * height;
+  const uint32_t fileSize = 62 + imageSize;  // 14 (file header) + 40 (DIB header) + 8 (palette) + image
+
+  // BMP File Header (14 bytes)
+  bmpOut.write('B');
+  bmpOut.write('M');
+  write32(bmpOut, fileSize);  // File size
+  write32(bmpOut, 0);         // Reserved
+  write32(bmpOut, 62);        // Offset to pixel data (14 + 40 + 8)
+
+  // DIB Header (BITMAPINFOHEADER - 40 bytes)
+  write32(bmpOut, 40);
+  write32Signed(bmpOut, width);
+  write32Signed(bmpOut, -height);  // Negative height = top-down bitmap
+  write16(bmpOut, 1);              // Color planes
+  write16(bmpOut, 1);              // Bits per pixel (1 bit)
+  write32(bmpOut, 0);              // BI_RGB (no compression)
+  write32(bmpOut, imageSize);
+  write32(bmpOut, 2835);  // xPixelsPerMeter (72 DPI)
+  write32(bmpOut, 2835);  // yPixelsPerMeter (72 DPI)
+  write32(bmpOut, 2);     // colorsUsed
+  write32(bmpOut, 2);     // colorsImportant
+
+  // Color Palette (2 colors x 4 bytes = 8 bytes)
+  // Format: Blue, Green, Red, Reserved (BGRA)
+  // Note: In 1-bit BMP, palette index 0 = black, 1 = white
+  uint8_t palette[8] = {
+      0x00, 0x00, 0x00, 0x00,  // Color 0: Black
+      0xFF, 0xFF, 0xFF, 0x00   // Color 1: White
+  };
+  for (const uint8_t i : palette) {
+    bmpOut.write(i);
+  }
+}
+
 // Helper function: Write BMP header with 2-bit color depth
-void JpegToBmpConverter::writeBmpHeader(Print& bmpOut, const int width, const int height) {
+static void writeBmpHeader2bit(Print& bmpOut, const int width, const int height) {
   // Calculate row padding (each row must be multiple of 4 bytes)
   const int bytesPerRow = (width * 2 + 31) / 32 * 4;  // 2 bits per pixel, round up
   const int imageSize = bytesPerRow * height;
@@ -159,9 +198,11 @@ unsigned char JpegToBmpConverter::jpegReadCallback(unsigned char* pBuf, const un
   return 0;  // Success
 }
 
-// Core function: Convert JPEG file to 2-bit BMP
-bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
-  Serial.printf("[%lu] [JPG] Converting JPEG to BMP\n", millis());
+// Internal implementation with configurable target size and bit depth
+bool JpegToBmpConverter::jpegFileToBmpStreamInternal(FsFile& jpegFile, Print& bmpOut, int targetWidth, int targetHeight,
+                                                     bool oneBit) {
+  Serial.printf("[%lu] [JPG] Converting JPEG to %s BMP (target: %dx%d)\n", millis(), oneBit ? "1-bit" : "2-bit",
+                targetWidth, targetHeight);
 
   // Setup context for picojpeg callback
   JpegReadContext context = {.file = jpegFile, .bufferPos = 0, .bufferFilled = 0};
@@ -196,10 +237,10 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
   uint32_t scaleY_fp = 65536;
   bool needsScaling = false;
 
-  if (USE_PRESCALE && (imageInfo.m_width > TARGET_MAX_WIDTH || imageInfo.m_height > TARGET_MAX_HEIGHT)) {
+  if (targetWidth > 0 && targetHeight > 0 && (imageInfo.m_width > targetWidth || imageInfo.m_height > targetHeight)) {
     // Calculate scale to fit within target dimensions while maintaining aspect ratio
-    const float scaleToFitWidth = static_cast<float>(TARGET_MAX_WIDTH) / imageInfo.m_width;
-    const float scaleToFitHeight = static_cast<float>(TARGET_MAX_HEIGHT) / imageInfo.m_height;
+    const float scaleToFitWidth = static_cast<float>(targetWidth) / imageInfo.m_width;
+    const float scaleToFitHeight = static_cast<float>(targetHeight) / imageInfo.m_height;
     // We scale to the smaller dimension, so we can potentially crop later.
     // TODO: ideally, we already crop here.
     const float scale = (scaleToFitWidth > scaleToFitHeight) ? scaleToFitWidth : scaleToFitHeight;
@@ -218,16 +259,19 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
     needsScaling = true;
 
     Serial.printf("[%lu] [JPG] Pre-scaling %dx%d -> %dx%d (fit to %dx%d)\n", millis(), imageInfo.m_width,
-                  imageInfo.m_height, outWidth, outHeight, TARGET_MAX_WIDTH, TARGET_MAX_HEIGHT);
+                  imageInfo.m_height, outWidth, outHeight, targetWidth, targetHeight);
   }
 
   // Write BMP header with output dimensions
   int bytesPerRow;
-  if (USE_8BIT_OUTPUT) {
+  if (USE_8BIT_OUTPUT && !oneBit) {
     writeBmpHeader8bit(bmpOut, outWidth, outHeight);
     bytesPerRow = (outWidth + 3) / 4 * 4;
+  } else if (oneBit) {
+    writeBmpHeader1bit(bmpOut, outWidth, outHeight);
+    bytesPerRow = (outWidth + 31) / 32 * 4;  // 1 bit per pixel
   } else {
-    writeBmpHeader(bmpOut, outWidth, outHeight);
+    writeBmpHeader2bit(bmpOut, outWidth, outHeight);
     bytesPerRow = (outWidth * 2 + 31) / 32 * 4;
   }
 
@@ -258,11 +302,16 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
     return false;
   }
 
-  // Create ditherer if enabled (only for 2-bit output)
+  // Create ditherer if enabled
   // Use OUTPUT dimensions for dithering (after prescaling)
   AtkinsonDitherer* atkinsonDitherer = nullptr;
   FloydSteinbergDitherer* fsDitherer = nullptr;
-  if (!USE_8BIT_OUTPUT) {
+  Atkinson1BitDitherer* atkinson1BitDitherer = nullptr;
+
+  if (oneBit) {
+    // For 1-bit output, use Atkinson dithering for better quality
+    atkinson1BitDitherer = new Atkinson1BitDitherer(outWidth);
+  } else if (!USE_8BIT_OUTPUT) {
     if (USE_ATKINSON) {
       atkinsonDitherer = new AtkinsonDitherer(outWidth);
     } else if (USE_FLOYD_STEINBERG) {
@@ -348,12 +397,25 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
         // No scaling - direct output (1:1 mapping)
         memset(rowBuffer, 0, bytesPerRow);
 
-        if (USE_8BIT_OUTPUT) {
+        if (USE_8BIT_OUTPUT && !oneBit) {
           for (int x = 0; x < outWidth; x++) {
             const uint8_t gray = mcuRowBuffer[bufferY * imageInfo.m_width + x];
             rowBuffer[x] = adjustPixel(gray);
           }
+        } else if (oneBit) {
+          // 1-bit output with Atkinson dithering for better quality
+          for (int x = 0; x < outWidth; x++) {
+            const uint8_t gray = mcuRowBuffer[bufferY * imageInfo.m_width + x];
+            const uint8_t bit =
+                atkinson1BitDitherer ? atkinson1BitDitherer->processPixel(gray, x) : quantize1bit(gray, x, y);
+            // Pack 1-bit value: MSB first, 8 pixels per byte
+            const int byteIndex = x / 8;
+            const int bitOffset = 7 - (x % 8);
+            rowBuffer[byteIndex] |= (bit << bitOffset);
+          }
+          if (atkinson1BitDitherer) atkinson1BitDitherer->nextRow();
         } else {
+          // 2-bit output
           for (int x = 0; x < outWidth; x++) {
             const uint8_t gray = adjustPixel(mcuRowBuffer[bufferY * imageInfo.m_width + x]);
             uint8_t twoBit;
@@ -411,12 +473,25 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
         if (srcY_fp >= nextOutY_srcStart && currentOutY < outHeight) {
           memset(rowBuffer, 0, bytesPerRow);
 
-          if (USE_8BIT_OUTPUT) {
+          if (USE_8BIT_OUTPUT && !oneBit) {
             for (int x = 0; x < outWidth; x++) {
               const uint8_t gray = (rowCount[x] > 0) ? (rowAccum[x] / rowCount[x]) : 0;
               rowBuffer[x] = adjustPixel(gray);
             }
+          } else if (oneBit) {
+            // 1-bit output with Atkinson dithering for better quality
+            for (int x = 0; x < outWidth; x++) {
+              const uint8_t gray = (rowCount[x] > 0) ? (rowAccum[x] / rowCount[x]) : 0;
+              const uint8_t bit = atkinson1BitDitherer ? atkinson1BitDitherer->processPixel(gray, x)
+                                                       : quantize1bit(gray, x, currentOutY);
+              // Pack 1-bit value: MSB first, 8 pixels per byte
+              const int byteIndex = x / 8;
+              const int bitOffset = 7 - (x % 8);
+              rowBuffer[byteIndex] |= (bit << bitOffset);
+            }
+            if (atkinson1BitDitherer) atkinson1BitDitherer->nextRow();
           } else {
+            // 2-bit output
             for (int x = 0; x < outWidth; x++) {
               const uint8_t gray = adjustPixel((rowCount[x] > 0) ? (rowAccum[x] / rowCount[x]) : 0);
               uint8_t twoBit;
@@ -464,9 +539,29 @@ bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
   if (fsDitherer) {
     delete fsDitherer;
   }
+  if (atkinson1BitDitherer) {
+    delete atkinson1BitDitherer;
+  }
   free(mcuRowBuffer);
   free(rowBuffer);
 
   Serial.printf("[%lu] [JPG] Successfully converted JPEG to BMP\n", millis());
   return true;
 }
+
+// Core function: Convert JPEG file to 2-bit BMP (uses default target size)
+bool JpegToBmpConverter::jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut) {
+  return jpegFileToBmpStreamInternal(jpegFile, bmpOut, TARGET_MAX_WIDTH, TARGET_MAX_HEIGHT, false);
+}
+
+// Convert with custom target size (for thumbnails, 2-bit)
+bool JpegToBmpConverter::jpegFileToBmpStreamWithSize(FsFile& jpegFile, Print& bmpOut, int targetMaxWidth,
+                                                     int targetMaxHeight) {
+  return jpegFileToBmpStreamInternal(jpegFile, bmpOut, targetMaxWidth, targetMaxHeight, false);
+}
+
+// Convert to 1-bit BMP (black and white only, no grays) for fast home screen rendering
+bool JpegToBmpConverter::jpegFileTo1BitBmpStreamWithSize(FsFile& jpegFile, Print& bmpOut, int targetMaxWidth,
+                                                         int targetMaxHeight) {
+  return jpegFileToBmpStreamInternal(jpegFile, bmpOut, targetMaxWidth, targetMaxHeight, true);
+}

lib/JpegToBmpConverter/JpegToBmpConverter.h

@@ -5,11 +5,15 @@ class Print;
 class ZipFile;
 
 class JpegToBmpConverter {
-  static void writeBmpHeader(Print& bmpOut, int width, int height);
-  // [COMMENTED OUT] static uint8_t grayscaleTo2Bit(uint8_t grayscale, int x, int y);
   static unsigned char jpegReadCallback(unsigned char* pBuf, unsigned char buf_size,
                                         unsigned char* pBytes_actually_read, void* pCallback_data);
+  static bool jpegFileToBmpStreamInternal(class FsFile& jpegFile, Print& bmpOut, int targetWidth, int targetHeight,
+                                          bool oneBit);
 
  public:
   static bool jpegFileToBmpStream(FsFile& jpegFile, Print& bmpOut);
+  // Convert with custom target size (for thumbnails)
+  static bool jpegFileToBmpStreamWithSize(FsFile& jpegFile, Print& bmpOut, int targetMaxWidth, int targetMaxHeight);
+  // Convert to 1-bit BMP (black and white only, no grays) for fast home screen rendering
+  static bool jpegFileTo1BitBmpStreamWithSize(FsFile& jpegFile, Print& bmpOut, int targetMaxWidth, int targetMaxHeight);
 };

lib/Txt/Txt.cpp

@@ -0,0 +1,191 @@
+#include "Txt.h"
+
+#include <FsHelpers.h>
+#include <JpegToBmpConverter.h>
+
+Txt::Txt(std::string path, std::string cacheBasePath)
+    : filepath(std::move(path)), cacheBasePath(std::move(cacheBasePath)) {
+  // Generate cache path from file path hash
+  const size_t hash = std::hash<std::string>{}(filepath);
+  cachePath = this->cacheBasePath + "/txt_" + std::to_string(hash);
+}
+
+bool Txt::load() {
+  if (loaded) {
+    return true;
+  }
+
+  if (!SdMan.exists(filepath.c_str())) {
+    Serial.printf("[%lu] [TXT] File does not exist: %s\n", millis(), filepath.c_str());
+    return false;
+  }
+
+  FsFile file;
+  if (!SdMan.openFileForRead("TXT", filepath, file)) {
+    Serial.printf("[%lu] [TXT] Failed to open file: %s\n", millis(), filepath.c_str());
+    return false;
+  }
+
+  fileSize = file.size();
+  file.close();
+
+  loaded = true;
+  Serial.printf("[%lu] [TXT] Loaded TXT file: %s (%zu bytes)\n", millis(), filepath.c_str(), fileSize);
+  return true;
+}
+
+std::string Txt::getTitle() const {
+  // Extract filename without path and extension
+  size_t lastSlash = filepath.find_last_of('/');
+  std::string filename = (lastSlash != std::string::npos) ? filepath.substr(lastSlash + 1) : filepath;
+
+  // Remove .txt extension
+  if (filename.length() >= 4 && filename.substr(filename.length() - 4) == ".txt") {
+    filename = filename.substr(0, filename.length() - 4);
+  }
+
+  return filename;
+}
+
+void Txt::setupCacheDir() const {
+  if (!SdMan.exists(cacheBasePath.c_str())) {
+    SdMan.mkdir(cacheBasePath.c_str());
+  }
+  if (!SdMan.exists(cachePath.c_str())) {
+    SdMan.mkdir(cachePath.c_str());
+  }
+}
+
+std::string Txt::findCoverImage() const {
+  // Get the folder containing the txt file
+  size_t lastSlash = filepath.find_last_of('/');
+  std::string folder = (lastSlash != std::string::npos) ? filepath.substr(0, lastSlash) : "";
+  if (folder.empty()) {
+    folder = "/";
+  }
+
+  // Get the base filename without extension (e.g., "mybook" from "/books/mybook.txt")
+  std::string baseName = getTitle();
+
+  // Image extensions to try
+  const char* extensions[] = {".bmp", ".jpg", ".jpeg", ".png", ".BMP", ".JPG", ".JPEG", ".PNG"};
+
+  // First priority: look for image with same name as txt file (e.g., mybook.jpg)
+  for (const auto& ext : extensions) {
+    std::string coverPath = folder + "/" + baseName + ext;
+    if (SdMan.exists(coverPath.c_str())) {
+      Serial.printf("[%lu] [TXT] Found matching cover image: %s\n", millis(), coverPath.c_str());
+      return coverPath;
+    }
+  }
+
+  // Fallback: look for cover image files
+  const char* coverNames[] = {"cover", "Cover", "COVER"};
+  for (const auto& name : coverNames) {
+    for (const auto& ext : extensions) {
+      std::string coverPath = folder + "/" + std::string(name) + ext;
+      if (SdMan.exists(coverPath.c_str())) {
+        Serial.printf("[%lu] [TXT] Found fallback cover image: %s\n", millis(), coverPath.c_str());
+        return coverPath;
+      }
+    }
+  }
+
+  return "";
+}
+
+std::string Txt::getCoverBmpPath() const { return cachePath + "/cover.bmp"; }
+
+bool Txt::generateCoverBmp() const {
+  // Already generated, return true
+  if (SdMan.exists(getCoverBmpPath().c_str())) {
+    return true;
+  }
+
+  std::string coverImagePath = findCoverImage();
+  if (coverImagePath.empty()) {
+    Serial.printf("[%lu] [TXT] No cover image found for TXT file\n", millis());
+    return false;
+  }
+
+  // Setup cache directory
+  setupCacheDir();
+
+  // Get file extension
+  const size_t len = coverImagePath.length();
+  const bool isJpg =
+      (len >= 4 && (coverImagePath.substr(len - 4) == ".jpg" || coverImagePath.substr(len - 4) == ".JPG")) ||
+      (len >= 5 && (coverImagePath.substr(len - 5) == ".jpeg" || coverImagePath.substr(len - 5) == ".JPEG"));
+  const bool isBmp = len >= 4 && (coverImagePath.substr(len - 4) == ".bmp" || coverImagePath.substr(len - 4) == ".BMP");
+
+  if (isBmp) {
+    // Copy BMP file to cache
+    Serial.printf("[%lu] [TXT] Copying BMP cover image to cache\n", millis());
+    FsFile src, dst;
+    if (!SdMan.openFileForRead("TXT", coverImagePath, src)) {
+      return false;
+    }
+    if (!SdMan.openFileForWrite("TXT", getCoverBmpPath(), dst)) {
+      src.close();
+      return false;
+    }
+    uint8_t buffer[1024];
+    while (src.available()) {
+      size_t bytesRead = src.read(buffer, sizeof(buffer));
+      dst.write(buffer, bytesRead);
+    }
+    src.close();
+    dst.close();
+    Serial.printf("[%lu] [TXT] Copied BMP cover to cache\n", millis());
+    return true;
+  }
+
+  if (isJpg) {
+    // Convert JPG/JPEG to BMP (same approach as Epub)
+    Serial.printf("[%lu] [TXT] Generating BMP from JPG cover image\n", millis());
+    FsFile coverJpg, coverBmp;
+    if (!SdMan.openFileForRead("TXT", coverImagePath, coverJpg)) {
+      return false;
+    }
+    if (!SdMan.openFileForWrite("TXT", getCoverBmpPath(), coverBmp)) {
+      coverJpg.close();
+      return false;
+    }
+    const bool success = JpegToBmpConverter::jpegFileToBmpStream(coverJpg, coverBmp);
+    coverJpg.close();
+    coverBmp.close();
+
+    if (!success) {
+      Serial.printf("[%lu] [TXT] Failed to generate BMP from JPG cover image\n", millis());
+      SdMan.remove(getCoverBmpPath().c_str());
+    } else {
+      Serial.printf("[%lu] [TXT] Generated BMP from JPG cover image\n", millis());
+    }
+    return success;
+  }
+
+  // PNG files are not supported (would need a PNG decoder)
+  Serial.printf("[%lu] [TXT] Cover image format not supported (only BMP/JPG/JPEG)\n", millis());
+  return false;
+}
+
+bool Txt::readContent(uint8_t* buffer, size_t offset, size_t length) const {
+  if (!loaded) {
+    return false;
+  }
+
+  FsFile file;
+  if (!SdMan.openFileForRead("TXT", filepath, file)) {
+    return false;
+  }
+
+  if (!file.seek(offset)) {
+    file.close();
+    return false;
+  }
+
+  size_t bytesRead = file.read(buffer, length);
+  file.close();
+
+  return bytesRead > 0;
+}

lib/Txt/Txt.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include <SDCardManager.h>
+
+#include <memory>
+#include <string>
+
+class Txt {
+  std::string filepath;
+  std::string cacheBasePath;
+  std::string cachePath;
+  bool loaded = false;
+  size_t fileSize = 0;
+
+ public:
+  explicit Txt(std::string path, std::string cacheBasePath);
+
+  bool load();
+  [[nodiscard]] const std::string& getPath() const { return filepath; }
+  [[nodiscard]] const std::string& getCachePath() const { return cachePath; }
+  [[nodiscard]] std::string getTitle() const;
+  [[nodiscard]] size_t getFileSize() const { return fileSize; }
+
+  void setupCacheDir() const;
+
+  // Cover image support - looks for cover.bmp/jpg/jpeg/png in same folder as txt file
+  [[nodiscard]] std::string getCoverBmpPath() const;
+  [[nodiscard]] bool generateCoverBmp() const;
+  [[nodiscard]] std::string findCoverImage() const;
+
+  // Read content from file
+  [[nodiscard]] bool readContent(uint8_t* buffer, size_t offset, size_t length) const;
+};

lib/Xtc/Xtc.cpp

@@ -293,6 +293,267 @@ bool Xtc::generateCoverBmp() const {
   return true;
 }
 
+std::string Xtc::getThumbBmpPath() const { return cachePath + "/thumb.bmp"; }
+
+bool Xtc::generateThumbBmp() const {
+  // Already generated
+  if (SdMan.exists(getThumbBmpPath().c_str())) {
+    return true;
+  }
+
+  if (!loaded || !parser) {
+    Serial.printf("[%lu] [XTC] Cannot generate thumb BMP, file not loaded\n", millis());
+    return false;
+  }
+
+  if (parser->getPageCount() == 0) {
+    Serial.printf("[%lu] [XTC] No pages in XTC file\n", millis());
+    return false;
+  }
+
+  // Setup cache directory
+  setupCacheDir();
+
+  // Get first page info for cover
+  xtc::PageInfo pageInfo;
+  if (!parser->getPageInfo(0, pageInfo)) {
+    Serial.printf("[%lu] [XTC] Failed to get first page info\n", millis());
+    return false;
+  }
+
+  // Get bit depth
+  const uint8_t bitDepth = parser->getBitDepth();
+
+  // Calculate target dimensions for thumbnail (fit within 240x400 Continue Reading card)
+  constexpr int THUMB_TARGET_WIDTH = 240;
+  constexpr int THUMB_TARGET_HEIGHT = 400;
+
+  // Calculate scale factor
+  float scaleX = static_cast<float>(THUMB_TARGET_WIDTH) / pageInfo.width;
+  float scaleY = static_cast<float>(THUMB_TARGET_HEIGHT) / pageInfo.height;
+  float scale = (scaleX < scaleY) ? scaleX : scaleY;
+
+  // Only scale down, never up
+  if (scale >= 1.0f) {
+    // Page is already small enough, just use cover.bmp
+    // Copy cover.bmp to thumb.bmp
+    if (generateCoverBmp()) {
+      FsFile src, dst;
+      if (SdMan.openFileForRead("XTC", getCoverBmpPath(), src)) {
+        if (SdMan.openFileForWrite("XTC", getThumbBmpPath(), dst)) {
+          uint8_t buffer[512];
+          while (src.available()) {
+            size_t bytesRead = src.read(buffer, sizeof(buffer));
+            dst.write(buffer, bytesRead);
+          }
+          dst.close();
+        }
+        src.close();
+      }
+      Serial.printf("[%lu] [XTC] Copied cover to thumb (no scaling needed)\n", millis());
+      return SdMan.exists(getThumbBmpPath().c_str());
+    }
+    return false;
+  }
+
+  uint16_t thumbWidth = static_cast<uint16_t>(pageInfo.width * scale);
+  uint16_t thumbHeight = static_cast<uint16_t>(pageInfo.height * scale);
+
+  Serial.printf("[%lu] [XTC] Generating thumb BMP: %dx%d -> %dx%d (scale: %.3f)\n", millis(), pageInfo.width,
+                pageInfo.height, thumbWidth, thumbHeight, scale);
+
+  // Allocate buffer for page data
+  size_t bitmapSize;
+  if (bitDepth == 2) {
+    bitmapSize = ((static_cast<size_t>(pageInfo.width) * pageInfo.height + 7) / 8) * 2;
+  } else {
+    bitmapSize = ((pageInfo.width + 7) / 8) * pageInfo.height;
+  }
+  uint8_t* pageBuffer = static_cast<uint8_t*>(malloc(bitmapSize));
+  if (!pageBuffer) {
+    Serial.printf("[%lu] [XTC] Failed to allocate page buffer (%lu bytes)\n", millis(), bitmapSize);
+    return false;
+  }
+
+  // Load first page (cover)
+  size_t bytesRead = const_cast<xtc::XtcParser*>(parser.get())->loadPage(0, pageBuffer, bitmapSize);
+  if (bytesRead == 0) {
+    Serial.printf("[%lu] [XTC] Failed to load cover page for thumb\n", millis());
+    free(pageBuffer);
+    return false;
+  }
+
+  // Create thumbnail BMP file - use 1-bit format for fast home screen rendering (no gray passes)
+  FsFile thumbBmp;
+  if (!SdMan.openFileForWrite("XTC", getThumbBmpPath(), thumbBmp)) {
+    Serial.printf("[%lu] [XTC] Failed to create thumb BMP file\n", millis());
+    free(pageBuffer);
+    return false;
+  }
+
+  // Write 1-bit BMP header for fast home screen rendering
+  const uint32_t rowSize = (thumbWidth + 31) / 32 * 4;  // 1 bit per pixel, aligned to 4 bytes
+  const uint32_t imageSize = rowSize * thumbHeight;
+  const uint32_t fileSize = 14 + 40 + 8 + imageSize;  // 8 bytes for 2-color palette
+
+  // File header
+  thumbBmp.write('B');
+  thumbBmp.write('M');
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&fileSize), 4);
+  uint32_t reserved = 0;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&reserved), 4);
+  uint32_t dataOffset = 14 + 40 + 8;  // 1-bit palette has 2 colors (8 bytes)
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&dataOffset), 4);
+
+  // DIB header
+  uint32_t dibHeaderSize = 40;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&dibHeaderSize), 4);
+  int32_t widthVal = thumbWidth;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&widthVal), 4);
+  int32_t heightVal = -static_cast<int32_t>(thumbHeight);  // Negative for top-down
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&heightVal), 4);
+  uint16_t planes = 1;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&planes), 2);
+  uint16_t bitsPerPixel = 1;  // 1-bit for black and white
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&bitsPerPixel), 2);
+  uint32_t compression = 0;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&compression), 4);
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&imageSize), 4);
+  int32_t ppmX = 2835;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&ppmX), 4);
+  int32_t ppmY = 2835;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&ppmY), 4);
+  uint32_t colorsUsed = 2;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&colorsUsed), 4);
+  uint32_t colorsImportant = 2;
+  thumbBmp.write(reinterpret_cast<const uint8_t*>(&colorsImportant), 4);
+
+  // Color palette (2 colors for 1-bit: black and white)
+  uint8_t palette[8] = {
+      0x00, 0x00, 0x00, 0x00,  // Color 0: Black
+      0xFF, 0xFF, 0xFF, 0x00   // Color 1: White
+  };
+  thumbBmp.write(palette, 8);
+
+  // Allocate row buffer for 1-bit output
+  uint8_t* rowBuffer = static_cast<uint8_t*>(malloc(rowSize));
+  if (!rowBuffer) {
+    free(pageBuffer);
+    thumbBmp.close();
+    return false;
+  }
+
+  // Fixed-point scale factor (16.16)
+  uint32_t scaleInv_fp = static_cast<uint32_t>(65536.0f / scale);
+
+  // Pre-calculate plane info for 2-bit mode
+  const size_t planeSize = (bitDepth == 2) ? ((static_cast<size_t>(pageInfo.width) * pageInfo.height + 7) / 8) : 0;
+  const uint8_t* plane1 = (bitDepth == 2) ? pageBuffer : nullptr;
+  const uint8_t* plane2 = (bitDepth == 2) ? pageBuffer + planeSize : nullptr;
+  const size_t colBytes = (bitDepth == 2) ? ((pageInfo.height + 7) / 8) : 0;
+  const size_t srcRowBytes = (bitDepth == 1) ? ((pageInfo.width + 7) / 8) : 0;
+
+  for (uint16_t dstY = 0; dstY < thumbHeight; dstY++) {
+    memset(rowBuffer, 0xFF, rowSize);  // Start with all white (bit 1)
+
+    // Calculate source Y range with bounds checking
+    uint32_t srcYStart = (static_cast<uint32_t>(dstY) * scaleInv_fp) >> 16;
+    uint32_t srcYEnd = (static_cast<uint32_t>(dstY + 1) * scaleInv_fp) >> 16;
+    if (srcYStart >= pageInfo.height) srcYStart = pageInfo.height - 1;
+    if (srcYEnd > pageInfo.height) srcYEnd = pageInfo.height;
+    if (srcYEnd <= srcYStart) srcYEnd = srcYStart + 1;
+    if (srcYEnd > pageInfo.height) srcYEnd = pageInfo.height;
+
+    for (uint16_t dstX = 0; dstX < thumbWidth; dstX++) {
+      // Calculate source X range with bounds checking
+      uint32_t srcXStart = (static_cast<uint32_t>(dstX) * scaleInv_fp) >> 16;
+      uint32_t srcXEnd = (static_cast<uint32_t>(dstX + 1) * scaleInv_fp) >> 16;
+      if (srcXStart >= pageInfo.width) srcXStart = pageInfo.width - 1;
+      if (srcXEnd > pageInfo.width) srcXEnd = pageInfo.width;
+      if (srcXEnd <= srcXStart) srcXEnd = srcXStart + 1;
+      if (srcXEnd > pageInfo.width) srcXEnd = pageInfo.width;
+
+      // Area averaging: sum grayscale values (0-255 range)
+      uint32_t graySum = 0;
+      uint32_t totalCount = 0;
+
+      for (uint32_t srcY = srcYStart; srcY < srcYEnd && srcY < pageInfo.height; srcY++) {
+        for (uint32_t srcX = srcXStart; srcX < srcXEnd && srcX < pageInfo.width; srcX++) {
+          uint8_t grayValue = 255;  // Default: white
+
+          if (bitDepth == 2) {
+            // XTH 2-bit mode: pixel value 0-3
+            // Bounds check for column index
+            if (srcX < pageInfo.width) {
+              const size_t colIndex = pageInfo.width - 1 - srcX;
+              const size_t byteInCol = srcY / 8;
+              const size_t bitInByte = 7 - (srcY % 8);
+              const size_t byteOffset = colIndex * colBytes + byteInCol;
+              // Bounds check for buffer access
+              if (byteOffset < planeSize) {
+                const uint8_t bit1 = (plane1[byteOffset] >> bitInByte) & 1;
+                const uint8_t bit2 = (plane2[byteOffset] >> bitInByte) & 1;
+                const uint8_t pixelValue = (bit1 << 1) | bit2;
+                // Convert 2-bit (0-3) to grayscale: 0=black, 3=white
+                // pixelValue: 0=white, 1=light gray, 2=dark gray, 3=black (XTC polarity)
+                grayValue = (3 - pixelValue) * 85;  // 0->255, 1->170, 2->85, 3->0
+              }
+            }
+          } else {
+            // 1-bit mode
+            const size_t byteIdx = srcY * srcRowBytes + srcX / 8;
+            const size_t bitIdx = 7 - (srcX % 8);
+            // Bounds check for buffer access
+            if (byteIdx < bitmapSize) {
+              const uint8_t pixelBit = (pageBuffer[byteIdx] >> bitIdx) & 1;
+              // XTC polarity: 1=black, 0=white
+              grayValue = pixelBit ? 0 : 255;
+            }
+          }
+
+          graySum += grayValue;
+          totalCount++;
+        }
+      }
+
+      // Calculate average grayscale and quantize to 1-bit with noise dithering
+      uint8_t avgGray = (totalCount > 0) ? static_cast<uint8_t>(graySum / totalCount) : 255;
+
+      // Hash-based noise dithering for 1-bit output
+      uint32_t hash = static_cast<uint32_t>(dstX) * 374761393u + static_cast<uint32_t>(dstY) * 668265263u;
+      hash = (hash ^ (hash >> 13)) * 1274126177u;
+      const int threshold = static_cast<int>(hash >> 24);           // 0-255
+      const int adjustedThreshold = 128 + ((threshold - 128) / 2);  // Range: 64-192
+
+      // Quantize to 1-bit: 0=black, 1=white
+      uint8_t oneBit = (avgGray >= adjustedThreshold) ? 1 : 0;
+
+      // Pack 1-bit value into row buffer (MSB first, 8 pixels per byte)
+      const size_t byteIndex = dstX / 8;
+      const size_t bitOffset = 7 - (dstX % 8);
+      // Bounds check for row buffer access
+      if (byteIndex < rowSize) {
+        if (oneBit) {
+          rowBuffer[byteIndex] |= (1 << bitOffset);  // Set bit for white
+        } else {
+          rowBuffer[byteIndex] &= ~(1 << bitOffset);  // Clear bit for black
+        }
+      }
+    }
+
+    // Write row (already padded to 4-byte boundary by rowSize)
+    thumbBmp.write(rowBuffer, rowSize);
+  }
+
+  free(rowBuffer);
+  thumbBmp.close();
+  free(pageBuffer);
+
+  Serial.printf("[%lu] [XTC] Generated thumb BMP (%dx%d): %s\n", millis(), thumbWidth, thumbHeight,
+                getThumbBmpPath().c_str());
+  return true;
+}
+
 uint32_t Xtc::getPageCount() const {
   if (!loaded || !parser) {
     return 0;

lib/Xtc/Xtc.h

@@ -62,6 +62,9 @@ class Xtc {
   // Cover image support (for sleep screen)
   std::string getCoverBmpPath() const;
   bool generateCoverBmp() const;
+  // Thumbnail support (for Continue Reading card)
+  std::string getThumbBmpPath() const;
+  bool generateThumbBmp() const;
 
   // Page access
   uint32_t getPageCount() const;

open-x4-sdk

@@ -1 +1 @@
-Subproject commit bd4e6707503ab9c97d13ee0d8f8c69e9ff03cd12
+Subproject commit fe766f15cb9ff1ef8214210a8667037df4c60b81

src/CrossPointState.cpp

@@ -5,7 +5,7 @@
 #include <Serialization.h>
 
 namespace {
-constexpr uint8_t STATE_FILE_VERSION = 1;
+constexpr uint8_t STATE_FILE_VERSION = 2;
 constexpr char STATE_FILE[] = "/.crosspoint/state.bin";
 }  // namespace
 
@@ -19,6 +19,7 @@ bool CrossPointState::saveToFile() const {
 
   serialization::writePod(outputFile, STATE_FILE_VERSION);
   serialization::writeString(outputFile, openEpubPath);
+  serialization::writePod(outputFile, lastSleepImage);
   outputFile.close();
   return true;
 }
@@ -31,13 +32,18 @@ bool CrossPointState::loadFromFile() {
 
   uint8_t version;
   serialization::readPod(inputFile, version);
-  if (version != STATE_FILE_VERSION) {
+  if (version > STATE_FILE_VERSION) {
     Serial.printf("[%lu] [CPS] Deserialization failed: Unknown version %u\n", millis(), version);
     inputFile.close();
     return false;
   }
 
   serialization::readString(inputFile, openEpubPath);
+  if (version >= 2) {
+    serialization::readPod(inputFile, lastSleepImage);
+  } else {
+    lastSleepImage = 0;
+  }
 
   inputFile.close();
   return true;

src/CrossPointState.h

@@ -8,6 +8,7 @@ class CrossPointState {
 
  public:
   std::string openEpubPath;
+  uint8_t lastSleepImage;
   ~CrossPointState() = default;
 
   // Get singleton instance

src/activities/boot_sleep/SleepActivity.cpp

@@ -3,6 +3,7 @@
 #include <Epub.h>
 #include <GfxRenderer.h>
 #include <SDCardManager.h>
+#include <Txt.h>
 #include <Xtc.h>
 
 #include "CrossPointSettings.h"
@@ -80,7 +81,13 @@ void SleepActivity::renderCustomSleepScreen() const {
     const auto numFiles = files.size();
     if (numFiles > 0) {
       // Generate a random number between 1 and numFiles
-      const auto randomFileIndex = random(numFiles);
+      auto randomFileIndex = random(numFiles);
+      // If we picked the same image as last time, reroll
+      while (numFiles > 1 && randomFileIndex == APP_STATE.lastSleepImage) {
+        randomFileIndex = random(numFiles);
+      }
+      APP_STATE.lastSleepImage = randomFileIndex;
+      APP_STATE.saveToFile();
       const auto filename = "/sleep/" + files[randomFileIndex];
       FsFile file;
       if (SdMan.openFileForRead("SLP", filename, file)) {
@@ -201,6 +208,7 @@ void SleepActivity::renderCoverSleepScreen() const {
   std::string coverBmpPath;
   bool cropped = SETTINGS.sleepScreenCoverMode == CrossPointSettings::SLEEP_SCREEN_COVER_MODE::CROP;
 
+  // Check if the current book is XTC, TXT, or EPUB
   if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtc") ||
       StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".xtch")) {
     // Handle XTC file
@@ -216,6 +224,20 @@ void SleepActivity::renderCoverSleepScreen() const {
     }
 
     coverBmpPath = lastXtc.getCoverBmpPath();
+  } else if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".txt")) {
+    // Handle TXT file - looks for cover image in the same folder
+    Txt lastTxt(APP_STATE.openEpubPath, "/.crosspoint");
+    if (!lastTxt.load()) {
+      Serial.println("[SLP] Failed to load last TXT");
+      return renderDefaultSleepScreen();
+    }
+
+    if (!lastTxt.generateCoverBmp()) {
+      Serial.println("[SLP] No cover image found for TXT file");
+      return renderDefaultSleepScreen();
+    }
+
+    coverBmpPath = lastTxt.getCoverBmpPath();
   } else if (StringUtils::checkFileExtension(APP_STATE.openEpubPath, ".epub")) {
     // Handle EPUB file
     Epub lastEpub(APP_STATE.openEpubPath, "/.crosspoint");

src/activities/home/HomeActivity.cpp

@@ -1,8 +1,10 @@
 #include "HomeActivity.h"
 
+#include <Bitmap.h>
 #include <Epub.h>
 #include <GfxRenderer.h>
 #include <SDCardManager.h>
+#include <Xtc.h>
 
 #include <cstring>
 #include <vector>
@@ -46,7 +48,7 @@ void HomeActivity::onEnter() {
       lastBookTitle = lastBookTitle.substr(lastSlash + 1);
     }
 
-    // If epub, try to load the metadata for title/author
+    // If epub, try to load the metadata for title/author and cover
     if (StringUtils::checkFileExtension(lastBookTitle, ".epub")) {
       Epub epub(APP_STATE.openEpubPath, "/.crosspoint");
       epub.load(false);
@@ -56,10 +58,31 @@ void HomeActivity::onEnter() {
       if (!epub.getAuthor().empty()) {
         lastBookAuthor = std::string(epub.getAuthor());
       }
-    } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtch")) {
-      lastBookTitle.resize(lastBookTitle.length() - 5);
-    } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtc")) {
-      lastBookTitle.resize(lastBookTitle.length() - 4);
+      // Try to generate thumbnail image for Continue Reading card
+      if (epub.generateThumbBmp()) {
+        coverBmpPath = epub.getThumbBmpPath();
+        hasCoverImage = true;
+      }
+    } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtch") ||
+               StringUtils::checkFileExtension(lastBookTitle, ".xtc")) {
+      // Handle XTC file
+      Xtc xtc(APP_STATE.openEpubPath, "/.crosspoint");
+      if (xtc.load()) {
+        if (!xtc.getTitle().empty()) {
+          lastBookTitle = std::string(xtc.getTitle());
+        }
+        // Try to generate thumbnail image for Continue Reading card
+        if (xtc.generateThumbBmp()) {
+          coverBmpPath = xtc.getThumbBmpPath();
+          hasCoverImage = true;
+        }
+      }
+      // Remove extension from title if we don't have metadata
+      if (StringUtils::checkFileExtension(lastBookTitle, ".xtch")) {
+        lastBookTitle.resize(lastBookTitle.length() - 5);
+      } else if (StringUtils::checkFileExtension(lastBookTitle, ".xtc")) {
+        lastBookTitle.resize(lastBookTitle.length() - 4);
+      }
     }
   }
 
@@ -69,7 +92,7 @@ void HomeActivity::onEnter() {
   updateRequired = true;
 
   xTaskCreate(&HomeActivity::taskTrampoline, "HomeActivityTask",
-              4096,               // Stack size
+              4096,               // Stack size (increased for cover image rendering)
               this,               // Parameters
               1,                  // Priority
               &displayTaskHandle  // Task handle
@@ -87,6 +110,51 @@ void HomeActivity::onExit() {
   }
   vSemaphoreDelete(renderingMutex);
   renderingMutex = nullptr;
+
+  // Free the stored cover buffer if any
+  freeCoverBuffer();
+}
+
+bool HomeActivity::storeCoverBuffer() {
+  uint8_t* frameBuffer = renderer.getFrameBuffer();
+  if (!frameBuffer) {
+    return false;
+  }
+
+  // Free any existing buffer first
+  freeCoverBuffer();
+
+  const size_t bufferSize = GfxRenderer::getBufferSize();
+  coverBuffer = static_cast<uint8_t*>(malloc(bufferSize));
+  if (!coverBuffer) {
+    return false;
+  }
+
+  memcpy(coverBuffer, frameBuffer, bufferSize);
+  return true;
+}
+
+bool HomeActivity::restoreCoverBuffer() {
+  if (!coverBuffer) {
+    return false;
+  }
+
+  uint8_t* frameBuffer = renderer.getFrameBuffer();
+  if (!frameBuffer) {
+    return false;
+  }
+
+  const size_t bufferSize = GfxRenderer::getBufferSize();
+  memcpy(frameBuffer, coverBuffer, bufferSize);
+  return true;
+}
+
+void HomeActivity::freeCoverBuffer() {
+  if (coverBuffer) {
+    free(coverBuffer);
+    coverBuffer = nullptr;
+  }
+  coverBufferStored = false;
 }
 
 void HomeActivity::loop() {
@@ -138,8 +206,12 @@ void HomeActivity::displayTaskLoop() {
   }
 }
 
-void HomeActivity::render() const {
-  renderer.clearScreen();
+void HomeActivity::render() {
+  // If we have a stored cover buffer, restore it instead of clearing
+  const bool bufferRestored = coverBufferStored && restoreCoverBuffer();
+  if (!bufferRestored) {
+    renderer.clearScreen();
+  }
 
   const auto pageWidth = renderer.getScreenWidth();
   const auto pageHeight = renderer.getScreenHeight();
@@ -154,34 +226,101 @@ void HomeActivity::render() const {
   constexpr int bookY = 30;
   const bool bookSelected = hasContinueReading && selectorIndex == 0;
 
+  // Bookmark dimensions (used in multiple places)
+  const int bookmarkWidth = bookWidth / 8;
+  const int bookmarkHeight = bookHeight / 5;
+  const int bookmarkX = bookX + bookWidth - bookmarkWidth - 10;
+  const int bookmarkY = bookY + 5;
+
   // Draw book card regardless, fill with message based on `hasContinueReading`
   {
-    if (bookSelected) {
-      renderer.fillRect(bookX, bookY, bookWidth, bookHeight);
-    } else {
-      renderer.drawRect(bookX, bookY, bookWidth, bookHeight);
+    // Draw cover image as background if available (inside the box)
+    // Only load from SD on first render, then use stored buffer
+    if (hasContinueReading && hasCoverImage && !coverBmpPath.empty() && !coverRendered) {
+      // First time: load cover from SD and render
+      FsFile file;
+      if (SdMan.openFileForRead("HOME", coverBmpPath, file)) {
+        Bitmap bitmap(file);
+        if (bitmap.parseHeaders() == BmpReaderError::Ok) {
+          // Calculate position to center image within the book card
+          int coverX, coverY;
+
+          if (bitmap.getWidth() > bookWidth || bitmap.getHeight() > bookHeight) {
+            const float imgRatio = static_cast<float>(bitmap.getWidth()) / static_cast<float>(bitmap.getHeight());
+            const float boxRatio = static_cast<float>(bookWidth) / static_cast<float>(bookHeight);
+
+            if (imgRatio > boxRatio) {
+              coverX = bookX;
+              coverY = bookY + (bookHeight - static_cast<int>(bookWidth / imgRatio)) / 2;
+            } else {
+              coverX = bookX + (bookWidth - static_cast<int>(bookHeight * imgRatio)) / 2;
+              coverY = bookY;
+            }
+          } else {
+            coverX = bookX + (bookWidth - bitmap.getWidth()) / 2;
+            coverY = bookY + (bookHeight - bitmap.getHeight()) / 2;
+          }
+
+          // Draw the cover image centered within the book card
+          renderer.drawBitmap(bitmap, coverX, coverY, bookWidth, bookHeight);
+
+          // Draw border around the card
+          renderer.drawRect(bookX, bookY, bookWidth, bookHeight);
+
+          // No bookmark ribbon when cover is shown - it would just cover the art
+
+          // Store the buffer with cover image for fast navigation
+          coverBufferStored = storeCoverBuffer();
+          coverRendered = true;
+
+          // First render: if selected, draw selection indicators now
+          if (bookSelected) {
+            renderer.drawRect(bookX + 1, bookY + 1, bookWidth - 2, bookHeight - 2);
+            renderer.drawRect(bookX + 2, bookY + 2, bookWidth - 4, bookHeight - 4);
+          }
+        }
+        file.close();
+      }
+    } else if (!bufferRestored && !coverRendered) {
+      // No cover image: draw border or fill, plus bookmark as visual flair
+      if (bookSelected) {
+        renderer.fillRect(bookX, bookY, bookWidth, bookHeight);
+      } else {
+        renderer.drawRect(bookX, bookY, bookWidth, bookHeight);
+      }
+
+      // Draw bookmark ribbon when no cover image (visual decoration)
+      if (hasContinueReading) {
+        const int notchDepth = bookmarkHeight / 3;
+        const int centerX = bookmarkX + bookmarkWidth / 2;
+
+        const int xPoints[5] = {
+            bookmarkX,                  // top-left
+            bookmarkX + bookmarkWidth,  // top-right
+            bookmarkX + bookmarkWidth,  // bottom-right
+            centerX,                    // center notch point
+            bookmarkX                   // bottom-left
+        };
+        const int yPoints[5] = {
+            bookmarkY,                                // top-left
+            bookmarkY,                                // top-right
+            bookmarkY + bookmarkHeight,               // bottom-right
+            bookmarkY + bookmarkHeight - notchDepth,  // center notch point
+            bookmarkY + bookmarkHeight                // bottom-left
+        };
+
+        // Draw bookmark ribbon (inverted if selected)
+        renderer.fillPolygon(xPoints, yPoints, 5, !bookSelected);
+      }
     }
 
-    // Bookmark icon in the top-right corner of the card
-    const int bookmarkWidth = bookWidth / 8;
-    const int bookmarkHeight = bookHeight / 5;
-    const int bookmarkX = bookX + bookWidth - bookmarkWidth - 8;
-    constexpr int bookmarkY = bookY + 1;
-
-    // Main bookmark body (solid)
-    renderer.fillRect(bookmarkX, bookmarkY, bookmarkWidth, bookmarkHeight, !bookSelected);
-
-    // Carve out an inverted triangle notch at the bottom center to create angled points
-    const int notchHeight = bookmarkHeight / 2;  // depth of the notch
-    for (int i = 0; i < notchHeight; ++i) {
-      const int y = bookmarkY + bookmarkHeight - 1 - i;
-      const int xStart = bookmarkX + i;
-      const int width = bookmarkWidth - 2 * i;
-      if (width <= 0) {
-        break;
-      }
-      // Draw a horizontal strip in the opposite color to "cut" the notch
-      renderer.fillRect(xStart, y, width, 1, bookSelected);
+    // If buffer was restored, draw selection indicators if needed
+    if (bufferRestored && bookSelected && coverRendered) {
+      // Draw selection border (no bookmark inversion needed since cover has no bookmark)
+      renderer.drawRect(bookX + 1, bookY + 1, bookWidth - 2, bookHeight - 2);
+      renderer.drawRect(bookX + 2, bookY + 2, bookWidth - 4, bookHeight - 4);
+    } else if (!coverRendered && !bufferRestored) {
+      // Selection border already handled above in the no-cover case
     }
   }
 
@@ -218,18 +357,25 @@ void HomeActivity::render() const {
         lines.back().append("...");
 
         while (!lines.back().empty() && renderer.getTextWidth(UI_12_FONT_ID, lines.back().c_str()) > maxLineWidth) {
-          lines.back().resize(lines.back().size() - 5);
+          // Remove "..." first, then remove one UTF-8 char, then add "..." back
+          lines.back().resize(lines.back().size() - 3);  // Remove "..."
+          StringUtils::utf8RemoveLastChar(lines.back());
           lines.back().append("...");
         }
         break;
       }
 
       int wordWidth = renderer.getTextWidth(UI_12_FONT_ID, i.c_str());
-      while (wordWidth > maxLineWidth && i.size() > 5) {
-        // Word itself is too long, trim it
-        i.resize(i.size() - 5);
-        i.append("...");
-        wordWidth = renderer.getTextWidth(UI_12_FONT_ID, i.c_str());
+      while (wordWidth > maxLineWidth && !i.empty()) {
+        // Word itself is too long, trim it (UTF-8 safe)
+        StringUtils::utf8RemoveLastChar(i);
+        // Check if we have room for ellipsis
+        std::string withEllipsis = i + "...";
+        wordWidth = renderer.getTextWidth(UI_12_FONT_ID, withEllipsis.c_str());
+        if (wordWidth <= maxLineWidth) {
+          i = withEllipsis;
+          break;
+        }
       }
 
       int newLineWidth = renderer.getTextWidth(UI_12_FONT_ID, currentLine.c_str());
@@ -261,24 +407,85 @@ void HomeActivity::render() const {
     // Vertically center the title block within the card
     int titleYStart = bookY + (bookHeight - totalTextHeight) / 2;
 
+    // If cover image was rendered, draw white box behind title and author
+    if (coverRendered) {
+      constexpr int boxPadding = 8;
+      // Calculate the max text width for the box
+      int maxTextWidth = 0;
+      for (const auto& line : lines) {
+        const int lineWidth = renderer.getTextWidth(UI_12_FONT_ID, line.c_str());
+        if (lineWidth > maxTextWidth) {
+          maxTextWidth = lineWidth;
+        }
+      }
+      if (!lastBookAuthor.empty()) {
+        std::string trimmedAuthor = lastBookAuthor;
+        while (renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str()) > maxLineWidth && !trimmedAuthor.empty()) {
+          StringUtils::utf8RemoveLastChar(trimmedAuthor);
+        }
+        if (renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str()) <
+            renderer.getTextWidth(UI_10_FONT_ID, lastBookAuthor.c_str())) {
+          trimmedAuthor.append("...");
+        }
+        const int authorWidth = renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str());
+        if (authorWidth > maxTextWidth) {
+          maxTextWidth = authorWidth;
+        }
+      }
+
+      const int boxWidth = maxTextWidth + boxPadding * 2;
+      const int boxHeight = totalTextHeight + boxPadding * 2;
+      const int boxX = (pageWidth - boxWidth) / 2;
+      const int boxY = titleYStart - boxPadding;
+
+      // Draw white filled box
+      renderer.fillRect(boxX, boxY, boxWidth, boxHeight, false);
+      // Draw black border around the box
+      renderer.drawRect(boxX, boxY, boxWidth, boxHeight, true);
+    }
+
     for (const auto& line : lines) {
-      renderer.drawCenteredText(UI_12_FONT_ID, titleYStart, line.c_str(), !bookSelected);
+      renderer.drawCenteredText(UI_12_FONT_ID, titleYStart, line.c_str(), !bookSelected || coverRendered);
       titleYStart += renderer.getLineHeight(UI_12_FONT_ID);
     }
 
     if (!lastBookAuthor.empty()) {
       titleYStart += renderer.getLineHeight(UI_10_FONT_ID) / 2;
       std::string trimmedAuthor = lastBookAuthor;
-      // Trim author if too long
+      // Trim author if too long (UTF-8 safe)
+      bool wasTrimmed = false;
       while (renderer.getTextWidth(UI_10_FONT_ID, trimmedAuthor.c_str()) > maxLineWidth && !trimmedAuthor.empty()) {
-        trimmedAuthor.resize(trimmedAuthor.size() - 5);
+        StringUtils::utf8RemoveLastChar(trimmedAuthor);
+        wasTrimmed = true;
+      }
+      if (wasTrimmed && !trimmedAuthor.empty()) {
+        // Make room for ellipsis
+        while (renderer.getTextWidth(UI_10_FONT_ID, (trimmedAuthor + "...").c_str()) > maxLineWidth &&
+               !trimmedAuthor.empty()) {
+          StringUtils::utf8RemoveLastChar(trimmedAuthor);
+        }
         trimmedAuthor.append("...");
       }
-      renderer.drawCenteredText(UI_10_FONT_ID, titleYStart, trimmedAuthor.c_str(), !bookSelected);
+      renderer.drawCenteredText(UI_10_FONT_ID, titleYStart, trimmedAuthor.c_str(), !bookSelected || coverRendered);
     }
 
-    renderer.drawCenteredText(UI_10_FONT_ID, bookY + bookHeight - renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2,
-                              "Continue Reading", !bookSelected);
+    // "Continue Reading" label at the bottom
+    const int continueY = bookY + bookHeight - renderer.getLineHeight(UI_10_FONT_ID) * 3 / 2;
+    if (coverRendered) {
+      // Draw white box behind "Continue Reading" text
+      const char* continueText = "Continue Reading";
+      const int continueTextWidth = renderer.getTextWidth(UI_10_FONT_ID, continueText);
+      constexpr int continuePadding = 6;
+      const int continueBoxWidth = continueTextWidth + continuePadding * 2;
+      const int continueBoxHeight = renderer.getLineHeight(UI_10_FONT_ID) + continuePadding;
+      const int continueBoxX = (pageWidth - continueBoxWidth) / 2;
+      const int continueBoxY = continueY - continuePadding / 2;
+      renderer.fillRect(continueBoxX, continueBoxY, continueBoxWidth, continueBoxHeight, false);
+      renderer.drawRect(continueBoxX, continueBoxY, continueBoxWidth, continueBoxHeight, true);
+      renderer.drawCenteredText(UI_10_FONT_ID, continueY, continueText, true);
+    } else {
+      renderer.drawCenteredText(UI_10_FONT_ID, continueY, "Continue Reading", !bookSelected);
+    }
   } else {
     // No book to continue reading
     const int y =

src/activities/home/HomeActivity.h

@@ -14,8 +14,13 @@ class HomeActivity final : public Activity {
   bool updateRequired = false;
   bool hasContinueReading = false;
   bool hasOpdsUrl = false;
+  bool hasCoverImage = false;
+  bool coverRendered = false;      // Track if cover has been rendered once
+  bool coverBufferStored = false;  // Track if cover buffer is stored
+  uint8_t* coverBuffer = nullptr;  // HomeActivity's own buffer for cover image
   std::string lastBookTitle;
   std::string lastBookAuthor;
+  std::string coverBmpPath;
   const std::function<void()> onContinueReading;
   const std::function<void()> onReaderOpen;
   const std::function<void()> onSettingsOpen;
@@ -24,8 +29,11 @@ class HomeActivity final : public Activity {
 
   static void taskTrampoline(void* param);
   [[noreturn]] void displayTaskLoop();
-  void render() const;
+  void render();
   int getMenuItemCount() const;
+  bool storeCoverBuffer();    // Store frame buffer for cover image
+  bool restoreCoverBuffer();  // Restore frame buffer from stored cover
+  void freeCoverBuffer();     // Free the stored cover buffer
 
  public:
   explicit HomeActivity(GfxRenderer& renderer, MappedInputManager& mappedInput,

src/activities/reader/FileSelectionActivity.cpp

@@ -52,7 +52,7 @@ void FileSelectionActivity::loadFiles() {
     } else {
       auto filename = std::string(name);
       if (StringUtils::checkFileExtension(filename, ".epub") || StringUtils::checkFileExtension(filename, ".xtch") ||
-          StringUtils::checkFileExtension(filename, ".xtc")) {
+          StringUtils::checkFileExtension(filename, ".xtc") || StringUtils::checkFileExtension(filename, ".txt")) {
         files.emplace_back(filename);
       }
     }

src/activities/reader/ReaderActivity.cpp

@@ -3,6 +3,8 @@
 #include "Epub.h"
 #include "EpubReaderActivity.h"
 #include "FileSelectionActivity.h"
+#include "Txt.h"
+#include "TxtReaderActivity.h"
 #include "Xtc.h"
 #include "XtcReaderActivity.h"
 #include "activities/util/FullScreenMessageActivity.h"
@@ -20,6 +22,12 @@ bool ReaderActivity::isXtcFile(const std::string& path) {
   return StringUtils::checkFileExtension(path, ".xtc") || StringUtils::checkFileExtension(path, ".xtch");
 }
 
+bool ReaderActivity::isTxtFile(const std::string& path) {
+  if (path.length() < 4) return false;
+  std::string ext4 = path.substr(path.length() - 4);
+  return ext4 == ".txt" || ext4 == ".TXT";
+}
+
 std::unique_ptr<Epub> ReaderActivity::loadEpub(const std::string& path) {
   if (!SdMan.exists(path.c_str())) {
     Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
@@ -50,6 +58,21 @@ std::unique_ptr<Xtc> ReaderActivity::loadXtc(const std::string& path) {
   return nullptr;
 }
 
+std::unique_ptr<Txt> ReaderActivity::loadTxt(const std::string& path) {
+  if (!SdMan.exists(path.c_str())) {
+    Serial.printf("[%lu] [   ] File does not exist: %s\n", millis(), path.c_str());
+    return nullptr;
+  }
+
+  auto txt = std::unique_ptr<Txt>(new Txt(path, "/.crosspoint"));
+  if (txt->load()) {
+    return txt;
+  }
+
+  Serial.printf("[%lu] [   ] Failed to load TXT\n", millis());
+  return nullptr;
+}
+
 void ReaderActivity::onSelectBookFile(const std::string& path) {
   currentBookPath = path;  // Track current book path
   exitActivity();
@@ -67,6 +90,18 @@ void ReaderActivity::onSelectBookFile(const std::string& path) {
       delay(2000);
       onGoToFileSelection();
     }
+  } else if (isTxtFile(path)) {
+    // Load TXT file
+    auto txt = loadTxt(path);
+    if (txt) {
+      onGoToTxtReader(std::move(txt));
+    } else {
+      exitActivity();
+      enterNewActivity(new FullScreenMessageActivity(renderer, mappedInput, "Failed to load TXT",
+                                                     EpdFontFamily::REGULAR, EInkDisplay::HALF_REFRESH));
+      delay(2000);
+      onGoToFileSelection();
+    }
   } else {
     // Load EPUB file
     auto epub = loadEpub(path);
@@ -108,6 +143,15 @@ void ReaderActivity::onGoToXtcReader(std::unique_ptr<Xtc> xtc) {
       [this] { onGoBack(); }));
 }
 
+void ReaderActivity::onGoToTxtReader(std::unique_ptr<Txt> txt) {
+  const auto txtPath = txt->getPath();
+  currentBookPath = txtPath;
+  exitActivity();
+  enterNewActivity(new TxtReaderActivity(
+      renderer, mappedInput, std::move(txt), [this, txtPath] { onGoToFileSelection(txtPath); },
+      [this] { onGoBack(); }));
+}
+
 void ReaderActivity::onEnter() {
   ActivityWithSubactivity::onEnter();
 
@@ -125,6 +169,13 @@ void ReaderActivity::onEnter() {
       return;
     }
     onGoToXtcReader(std::move(xtc));
+  } else if (isTxtFile(initialBookPath)) {
+    auto txt = loadTxt(initialBookPath);
+    if (!txt) {
+      onGoBack();
+      return;
+    }
+    onGoToTxtReader(std::move(txt));
   } else {
     auto epub = loadEpub(initialBookPath);
     if (!epub) {

src/activities/reader/ReaderActivity.h

@@ -5,6 +5,7 @@
 
 class Epub;
 class Xtc;
+class Txt;
 
 class ReaderActivity final : public ActivityWithSubactivity {
   std::string initialBookPath;
@@ -12,13 +13,16 @@ class ReaderActivity final : public ActivityWithSubactivity {
   const std::function<void()> onGoBack;
   static std::unique_ptr<Epub> loadEpub(const std::string& path);
   static std::unique_ptr<Xtc> loadXtc(const std::string& path);
+  static std::unique_ptr<Txt> loadTxt(const std::string& path);
   static bool isXtcFile(const std::string& path);
+  static bool isTxtFile(const std::string& path);
 
   static std::string extractFolderPath(const std::string& filePath);
   void onSelectBookFile(const std::string& path);
   void onGoToFileSelection(const std::string& fromBookPath = "");
   void onGoToEpubReader(std::unique_ptr<Epub> epub);
   void onGoToXtcReader(std::unique_ptr<Xtc> xtc);
+  void onGoToTxtReader(std::unique_ptr<Txt> txt);
 
  public:
   explicit ReaderActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::string initialBookPath,

src/activities/reader/TxtReaderActivity.cpp

@@ -0,0 +1,700 @@
+#include "TxtReaderActivity.h"
+
+#include <GfxRenderer.h>
+#include <SDCardManager.h>
+#include <Serialization.h>
+#include <Utf8.h>
+
+#include "CrossPointSettings.h"
+#include "CrossPointState.h"
+#include "MappedInputManager.h"
+#include "ScreenComponents.h"
+#include "fontIds.h"
+
+namespace {
+constexpr unsigned long goHomeMs = 1000;
+constexpr int statusBarMargin = 25;
+constexpr size_t CHUNK_SIZE = 8 * 1024;  // 8KB chunk for reading
+
+// Cache file magic and version
+constexpr uint32_t CACHE_MAGIC = 0x54585449;  // "TXTI"
+constexpr uint8_t CACHE_VERSION = 2;          // Increment when cache format changes
+}  // namespace
+
+void TxtReaderActivity::taskTrampoline(void* param) {
+  auto* self = static_cast<TxtReaderActivity*>(param);
+  self->displayTaskLoop();
+}
+
+void TxtReaderActivity::onEnter() {
+  ActivityWithSubactivity::onEnter();
+
+  if (!txt) {
+    return;
+  }
+
+  // Configure screen orientation based on settings
+  switch (SETTINGS.orientation) {
+    case CrossPointSettings::ORIENTATION::PORTRAIT:
+      renderer.setOrientation(GfxRenderer::Orientation::Portrait);
+      break;
+    case CrossPointSettings::ORIENTATION::LANDSCAPE_CW:
+      renderer.setOrientation(GfxRenderer::Orientation::LandscapeClockwise);
+      break;
+    case CrossPointSettings::ORIENTATION::INVERTED:
+      renderer.setOrientation(GfxRenderer::Orientation::PortraitInverted);
+      break;
+    case CrossPointSettings::ORIENTATION::LANDSCAPE_CCW:
+      renderer.setOrientation(GfxRenderer::Orientation::LandscapeCounterClockwise);
+      break;
+    default:
+      break;
+  }
+
+  renderingMutex = xSemaphoreCreateMutex();
+
+  txt->setupCacheDir();
+
+  // Save current txt as last opened file
+  APP_STATE.openEpubPath = txt->getPath();
+  APP_STATE.saveToFile();
+
+  // Trigger first update
+  updateRequired = true;
+
+  xTaskCreate(&TxtReaderActivity::taskTrampoline, "TxtReaderActivityTask",
+              6144,               // Stack size
+              this,               // Parameters
+              1,                  // Priority
+              &displayTaskHandle  // Task handle
+  );
+}
+
+void TxtReaderActivity::onExit() {
+  ActivityWithSubactivity::onExit();
+
+  // Reset orientation back to portrait for the rest of the UI
+  renderer.setOrientation(GfxRenderer::Orientation::Portrait);
+
+  // Wait until not rendering to delete task
+  xSemaphoreTake(renderingMutex, portMAX_DELAY);
+  if (displayTaskHandle) {
+    vTaskDelete(displayTaskHandle);
+    displayTaskHandle = nullptr;
+  }
+  vSemaphoreDelete(renderingMutex);
+  renderingMutex = nullptr;
+  pageOffsets.clear();
+  currentPageLines.clear();
+  txt.reset();
+}
+
+void TxtReaderActivity::loop() {
+  if (subActivity) {
+    subActivity->loop();
+    return;
+  }
+
+  // Long press BACK (1s+) goes directly to home
+  if (mappedInput.isPressed(MappedInputManager::Button::Back) && mappedInput.getHeldTime() >= goHomeMs) {
+    onGoHome();
+    return;
+  }
+
+  // Short press BACK goes to file selection
+  if (mappedInput.wasReleased(MappedInputManager::Button::Back) && mappedInput.getHeldTime() < goHomeMs) {
+    onGoBack();
+    return;
+  }
+
+  const bool prevReleased = mappedInput.wasReleased(MappedInputManager::Button::PageBack) ||
+                            mappedInput.wasReleased(MappedInputManager::Button::Left);
+  const bool nextReleased = mappedInput.wasReleased(MappedInputManager::Button::PageForward) ||
+                            (SETTINGS.shortPwrBtn == CrossPointSettings::SHORT_PWRBTN::PAGE_TURN &&
+                             mappedInput.wasReleased(MappedInputManager::Button::Power)) ||
+                            mappedInput.wasReleased(MappedInputManager::Button::Right);
+
+  if (!prevReleased && !nextReleased) {
+    return;
+  }
+
+  if (prevReleased && currentPage > 0) {
+    currentPage--;
+    updateRequired = true;
+  } else if (nextReleased && currentPage < totalPages - 1) {
+    currentPage++;
+    updateRequired = true;
+  }
+}
+
+void TxtReaderActivity::displayTaskLoop() {
+  while (true) {
+    if (updateRequired) {
+      updateRequired = false;
+      xSemaphoreTake(renderingMutex, portMAX_DELAY);
+      renderScreen();
+      xSemaphoreGive(renderingMutex);
+    }
+    vTaskDelay(10 / portTICK_PERIOD_MS);
+  }
+}
+
+void TxtReaderActivity::initializeReader() {
+  if (initialized) {
+    return;
+  }
+
+  // Store current settings for cache validation
+  cachedFontId = SETTINGS.getReaderFontId();
+  cachedScreenMargin = SETTINGS.screenMargin;
+  cachedParagraphAlignment = SETTINGS.paragraphAlignment;
+
+  // Calculate viewport dimensions
+  int orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft;
+  renderer.getOrientedViewableTRBL(&orientedMarginTop, &orientedMarginRight, &orientedMarginBottom,
+                                   &orientedMarginLeft);
+  orientedMarginTop += cachedScreenMargin;
+  orientedMarginLeft += cachedScreenMargin;
+  orientedMarginRight += cachedScreenMargin;
+  orientedMarginBottom += statusBarMargin;
+
+  viewportWidth = renderer.getScreenWidth() - orientedMarginLeft - orientedMarginRight;
+  const int viewportHeight = renderer.getScreenHeight() - orientedMarginTop - orientedMarginBottom;
+  const int lineHeight = renderer.getLineHeight(cachedFontId);
+
+  linesPerPage = viewportHeight / lineHeight;
+  if (linesPerPage < 1) linesPerPage = 1;
+
+  Serial.printf("[%lu] [TRS] Viewport: %dx%d, lines per page: %d\n", millis(), viewportWidth, viewportHeight,
+                linesPerPage);
+
+  // Try to load cached page index first
+  if (!loadPageIndexCache()) {
+    // Cache not found, build page index
+    buildPageIndex();
+    // Save to cache for next time
+    savePageIndexCache();
+  }
+
+  // Load saved progress
+  loadProgress();
+
+  initialized = true;
+}
+
+void TxtReaderActivity::buildPageIndex() {
+  pageOffsets.clear();
+  pageOffsets.push_back(0);  // First page starts at offset 0
+
+  size_t offset = 0;
+  const size_t fileSize = txt->getFileSize();
+  int lastProgressPercent = -1;
+
+  Serial.printf("[%lu] [TRS] Building page index for %zu bytes...\n", millis(), fileSize);
+
+  // Progress bar dimensions (matching EpubReaderActivity style)
+  constexpr int barWidth = 200;
+  constexpr int barHeight = 10;
+  constexpr int boxMargin = 20;
+  const int textWidth = renderer.getTextWidth(UI_12_FONT_ID, "Indexing...");
+  const int boxWidth = (barWidth > textWidth ? barWidth : textWidth) + boxMargin * 2;
+  const int boxHeight = renderer.getLineHeight(UI_12_FONT_ID) + barHeight + boxMargin * 3;
+  const int boxX = (renderer.getScreenWidth() - boxWidth) / 2;
+  constexpr int boxY = 50;
+  const int barX = boxX + (boxWidth - barWidth) / 2;
+  const int barY = boxY + renderer.getLineHeight(UI_12_FONT_ID) + boxMargin * 2;
+
+  // Draw initial progress box
+  renderer.fillRect(boxX, boxY, boxWidth, boxHeight, false);
+  renderer.drawText(UI_12_FONT_ID, boxX + boxMargin, boxY + boxMargin, "Indexing...");
+  renderer.drawRect(boxX + 5, boxY + 5, boxWidth - 10, boxHeight - 10);
+  renderer.drawRect(barX, barY, barWidth, barHeight);
+  renderer.displayBuffer();
+
+  while (offset < fileSize) {
+    std::vector<std::string> tempLines;
+    size_t nextOffset = offset;
+
+    if (!loadPageAtOffset(offset, tempLines, nextOffset)) {
+      break;
+    }
+
+    if (nextOffset <= offset) {
+      // No progress made, avoid infinite loop
+      break;
+    }
+
+    offset = nextOffset;
+    if (offset < fileSize) {
+      pageOffsets.push_back(offset);
+    }
+
+    // Update progress bar every 10% (matching EpubReaderActivity logic)
+    int progressPercent = (offset * 100) / fileSize;
+    if (lastProgressPercent / 10 != progressPercent / 10) {
+      lastProgressPercent = progressPercent;
+
+      // Fill progress bar
+      const int fillWidth = (barWidth - 2) * progressPercent / 100;
+      renderer.fillRect(barX + 1, barY + 1, fillWidth, barHeight - 2, true);
+      renderer.displayBuffer(EInkDisplay::FAST_REFRESH);
+    }
+
+    // Yield to other tasks periodically
+    if (pageOffsets.size() % 20 == 0) {
+      vTaskDelay(1);
+    }
+  }
+
+  totalPages = pageOffsets.size();
+  Serial.printf("[%lu] [TRS] Built page index: %d pages\n", millis(), totalPages);
+}
+
+bool TxtReaderActivity::loadPageAtOffset(size_t offset, std::vector<std::string>& outLines, size_t& nextOffset) {
+  outLines.clear();
+  const size_t fileSize = txt->getFileSize();
+
+  if (offset >= fileSize) {
+    return false;
+  }
+
+  // Read a chunk from file
+  size_t chunkSize = std::min(CHUNK_SIZE, fileSize - offset);
+  auto* buffer = static_cast<uint8_t*>(malloc(chunkSize + 1));
+  if (!buffer) {
+    Serial.printf("[%lu] [TRS] Failed to allocate %zu bytes\n", millis(), chunkSize);
+    return false;
+  }
+
+  if (!txt->readContent(buffer, offset, chunkSize)) {
+    free(buffer);
+    return false;
+  }
+  buffer[chunkSize] = '\0';
+
+  // Parse lines from buffer
+  size_t pos = 0;
+
+  while (pos < chunkSize && static_cast<int>(outLines.size()) < linesPerPage) {
+    // Find end of line
+    size_t lineEnd = pos;
+    while (lineEnd < chunkSize && buffer[lineEnd] != '\n') {
+      lineEnd++;
+    }
+
+    // Check if we have a complete line
+    bool lineComplete = (lineEnd < chunkSize) || (offset + lineEnd >= fileSize);
+
+    if (!lineComplete && static_cast<int>(outLines.size()) > 0) {
+      // Incomplete line and we already have some lines, stop here
+      break;
+    }
+
+    // Calculate the actual length of line content in the buffer (excluding newline)
+    size_t lineContentLen = lineEnd - pos;
+
+    // Check for carriage return
+    bool hasCR = (lineContentLen > 0 && buffer[pos + lineContentLen - 1] == '\r');
+    size_t displayLen = hasCR ? lineContentLen - 1 : lineContentLen;
+
+    // Extract line content for display (without CR/LF)
+    std::string line(reinterpret_cast<char*>(buffer + pos), displayLen);
+
+    // Track position within this source line (in bytes from pos)
+    size_t lineBytePos = 0;
+
+    // Word wrap if needed
+    while (!line.empty() && static_cast<int>(outLines.size()) < linesPerPage) {
+      int lineWidth = renderer.getTextWidth(cachedFontId, line.c_str());
+
+      if (lineWidth <= viewportWidth) {
+        outLines.push_back(line);
+        lineBytePos = displayLen;  // Consumed entire display content
+        line.clear();
+        break;
+      }
+
+      // Find break point
+      size_t breakPos = line.length();
+      while (breakPos > 0 && renderer.getTextWidth(cachedFontId, line.substr(0, breakPos).c_str()) > viewportWidth) {
+        // Try to break at space
+        size_t spacePos = line.rfind(' ', breakPos - 1);
+        if (spacePos != std::string::npos && spacePos > 0) {
+          breakPos = spacePos;
+        } else {
+          // Break at character boundary for UTF-8
+          breakPos--;
+          // Make sure we don't break in the middle of a UTF-8 sequence
+          while (breakPos > 0 && (line[breakPos] & 0xC0) == 0x80) {
+            breakPos--;
+          }
+        }
+      }
+
+      if (breakPos == 0) {
+        breakPos = 1;
+      }
+
+      outLines.push_back(line.substr(0, breakPos));
+
+      // Skip space at break point
+      size_t skipChars = breakPos;
+      if (breakPos < line.length() && line[breakPos] == ' ') {
+        skipChars++;
+      }
+      lineBytePos += skipChars;
+      line = line.substr(skipChars);
+    }
+
+    // Determine how much of the source buffer we consumed
+    if (line.empty()) {
+      // Fully consumed this source line, move past the newline
+      pos = lineEnd + 1;
+    } else {
+      // Partially consumed - page is full mid-line
+      // Move pos to where we stopped in the line (NOT past the line)
+      pos = pos + lineBytePos;
+      break;
+    }
+  }
+
+  // Ensure we make progress even if calculations go wrong
+  if (pos == 0 && !outLines.empty()) {
+    // Fallback: at minimum, consume something to avoid infinite loop
+    pos = 1;
+  }
+
+  nextOffset = offset + pos;
+
+  // Make sure we don't go past the file
+  if (nextOffset > fileSize) {
+    nextOffset = fileSize;
+  }
+
+  free(buffer);
+
+  return !outLines.empty();
+}
+
+void TxtReaderActivity::renderScreen() {
+  if (!txt) {
+    return;
+  }
+
+  // Initialize reader if not done
+  if (!initialized) {
+    renderer.clearScreen();
+    renderer.drawCenteredText(UI_12_FONT_ID, 300, "Indexing...", true, EpdFontFamily::BOLD);
+    renderer.displayBuffer();
+    initializeReader();
+  }
+
+  if (pageOffsets.empty()) {
+    renderer.clearScreen();
+    renderer.drawCenteredText(UI_12_FONT_ID, 300, "Empty file", true, EpdFontFamily::BOLD);
+    renderer.displayBuffer();
+    return;
+  }
+
+  // Bounds check
+  if (currentPage < 0) currentPage = 0;
+  if (currentPage >= totalPages) currentPage = totalPages - 1;
+
+  // Load current page content
+  size_t offset = pageOffsets[currentPage];
+  size_t nextOffset;
+  currentPageLines.clear();
+  loadPageAtOffset(offset, currentPageLines, nextOffset);
+
+  renderer.clearScreen();
+  renderPage();
+
+  // Save progress
+  saveProgress();
+}
+
+void TxtReaderActivity::renderPage() {
+  int orientedMarginTop, orientedMarginRight, orientedMarginBottom, orientedMarginLeft;
+  renderer.getOrientedViewableTRBL(&orientedMarginTop, &orientedMarginRight, &orientedMarginBottom,
+                                   &orientedMarginLeft);
+  orientedMarginTop += cachedScreenMargin;
+  orientedMarginLeft += cachedScreenMargin;
+  orientedMarginRight += cachedScreenMargin;
+  orientedMarginBottom += statusBarMargin;
+
+  const int lineHeight = renderer.getLineHeight(cachedFontId);
+  const int contentWidth = viewportWidth;
+
+  // Render text lines with alignment
+  auto renderLines = [&]() {
+    int y = orientedMarginTop;
+    for (const auto& line : currentPageLines) {
+      if (!line.empty()) {
+        int x = orientedMarginLeft;
+
+        // Apply text alignment
+        switch (cachedParagraphAlignment) {
+          case CrossPointSettings::LEFT_ALIGN:
+          default:
+            // x already set to left margin
+            break;
+          case CrossPointSettings::CENTER_ALIGN: {
+            int textWidth = renderer.getTextWidth(cachedFontId, line.c_str());
+            x = orientedMarginLeft + (contentWidth - textWidth) / 2;
+            break;
+          }
+          case CrossPointSettings::RIGHT_ALIGN: {
+            int textWidth = renderer.getTextWidth(cachedFontId, line.c_str());
+            x = orientedMarginLeft + contentWidth - textWidth;
+            break;
+          }
+          case CrossPointSettings::JUSTIFIED:
+            // For plain text, justified is treated as left-aligned
+            // (true justification would require word spacing adjustments)
+            break;
+        }
+
+        renderer.drawText(cachedFontId, x, y, line.c_str());
+      }
+      y += lineHeight;
+    }
+  };
+
+  // First pass: BW rendering
+  renderLines();
+  renderStatusBar(orientedMarginRight, orientedMarginBottom, orientedMarginLeft);
+
+  if (pagesUntilFullRefresh <= 1) {
+    renderer.displayBuffer(EInkDisplay::HALF_REFRESH);
+    pagesUntilFullRefresh = SETTINGS.getRefreshFrequency();
+  } else {
+    renderer.displayBuffer();
+    pagesUntilFullRefresh--;
+  }
+
+  // Grayscale rendering pass (for anti-aliased fonts)
+  if (SETTINGS.textAntiAliasing) {
+    // Save BW buffer for restoration after grayscale pass
+    renderer.storeBwBuffer();
+
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_LSB);
+    renderLines();
+    renderer.copyGrayscaleLsbBuffers();
+
+    renderer.clearScreen(0x00);
+    renderer.setRenderMode(GfxRenderer::GRAYSCALE_MSB);
+    renderLines();
+    renderer.copyGrayscaleMsbBuffers();
+
+    renderer.displayGrayBuffer();
+    renderer.setRenderMode(GfxRenderer::BW);
+
+    // Restore BW buffer
+    renderer.restoreBwBuffer();
+  }
+}
+
+void TxtReaderActivity::renderStatusBar(const int orientedMarginRight, const int orientedMarginBottom,
+                                        const int orientedMarginLeft) const {
+  const bool showProgress = SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
+  const bool showBattery = SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::NO_PROGRESS ||
+                           SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
+  const bool showTitle = SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::NO_PROGRESS ||
+                         SETTINGS.statusBar == CrossPointSettings::STATUS_BAR_MODE::FULL;
+
+  const auto screenHeight = renderer.getScreenHeight();
+  const auto textY = screenHeight - orientedMarginBottom - 4;
+  int progressTextWidth = 0;
+
+  if (showProgress) {
+    const int progress = totalPages > 0 ? (currentPage + 1) * 100 / totalPages : 0;
+    const std::string progressStr =
+        std::to_string(currentPage + 1) + "/" + std::to_string(totalPages) + "  " + std::to_string(progress) + "%";
+    progressTextWidth = renderer.getTextWidth(SMALL_FONT_ID, progressStr.c_str());
+    renderer.drawText(SMALL_FONT_ID, renderer.getScreenWidth() - orientedMarginRight - progressTextWidth, textY,
+                      progressStr.c_str());
+  }
+
+  if (showBattery) {
+    ScreenComponents::drawBattery(renderer, orientedMarginLeft, textY);
+  }
+
+  if (showTitle) {
+    const int titleMarginLeft = 50 + 30 + orientedMarginLeft;
+    const int titleMarginRight = progressTextWidth + 30 + orientedMarginRight;
+    const int availableTextWidth = renderer.getScreenWidth() - titleMarginLeft - titleMarginRight;
+
+    std::string title = txt->getTitle();
+    int titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    while (titleWidth > availableTextWidth && title.length() > 11) {
+      title.replace(title.length() - 8, 8, "...");
+      titleWidth = renderer.getTextWidth(SMALL_FONT_ID, title.c_str());
+    }
+
+    renderer.drawText(SMALL_FONT_ID, titleMarginLeft + (availableTextWidth - titleWidth) / 2, textY, title.c_str());
+  }
+}
+
+void TxtReaderActivity::saveProgress() const {
+  FsFile f;
+  if (SdMan.openFileForWrite("TRS", txt->getCachePath() + "/progress.bin", f)) {
+    uint8_t data[4];
+    data[0] = currentPage & 0xFF;
+    data[1] = (currentPage >> 8) & 0xFF;
+    data[2] = 0;
+    data[3] = 0;
+    f.write(data, 4);
+    f.close();
+  }
+}
+
+void TxtReaderActivity::loadProgress() {
+  FsFile f;
+  if (SdMan.openFileForRead("TRS", txt->getCachePath() + "/progress.bin", f)) {
+    uint8_t data[4];
+    if (f.read(data, 4) == 4) {
+      currentPage = data[0] + (data[1] << 8);
+      if (currentPage >= totalPages) {
+        currentPage = totalPages - 1;
+      }
+      if (currentPage < 0) {
+        currentPage = 0;
+      }
+      Serial.printf("[%lu] [TRS] Loaded progress: page %d/%d\n", millis(), currentPage, totalPages);
+    }
+    f.close();
+  }
+}
+
+bool TxtReaderActivity::loadPageIndexCache() {
+  // Cache file format (using serialization module):
+  // - uint32_t: magic "TXTI"
+  // - uint8_t: cache version
+  // - uint32_t: file size (to validate cache)
+  // - int32_t: viewport width
+  // - int32_t: lines per page
+  // - int32_t: font ID (to invalidate cache on font change)
+  // - int32_t: screen margin (to invalidate cache on margin change)
+  // - uint8_t: paragraph alignment (to invalidate cache on alignment change)
+  // - uint32_t: total pages count
+  // - N * uint32_t: page offsets
+
+  std::string cachePath = txt->getCachePath() + "/index.bin";
+  FsFile f;
+  if (!SdMan.openFileForRead("TRS", cachePath, f)) {
+    Serial.printf("[%lu] [TRS] No page index cache found\n", millis());
+    return false;
+  }
+
+  // Read and validate header using serialization module
+  uint32_t magic;
+  serialization::readPod(f, magic);
+  if (magic != CACHE_MAGIC) {
+    Serial.printf("[%lu] [TRS] Cache magic mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  uint8_t version;
+  serialization::readPod(f, version);
+  if (version != CACHE_VERSION) {
+    Serial.printf("[%lu] [TRS] Cache version mismatch (%d != %d), rebuilding\n", millis(), version, CACHE_VERSION);
+    f.close();
+    return false;
+  }
+
+  uint32_t fileSize;
+  serialization::readPod(f, fileSize);
+  if (fileSize != txt->getFileSize()) {
+    Serial.printf("[%lu] [TRS] Cache file size mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  int32_t cachedWidth;
+  serialization::readPod(f, cachedWidth);
+  if (cachedWidth != viewportWidth) {
+    Serial.printf("[%lu] [TRS] Cache viewport width mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  int32_t cachedLines;
+  serialization::readPod(f, cachedLines);
+  if (cachedLines != linesPerPage) {
+    Serial.printf("[%lu] [TRS] Cache lines per page mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  int32_t fontId;
+  serialization::readPod(f, fontId);
+  if (fontId != cachedFontId) {
+    Serial.printf("[%lu] [TRS] Cache font ID mismatch (%d != %d), rebuilding\n", millis(), fontId, cachedFontId);
+    f.close();
+    return false;
+  }
+
+  int32_t margin;
+  serialization::readPod(f, margin);
+  if (margin != cachedScreenMargin) {
+    Serial.printf("[%lu] [TRS] Cache screen margin mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  uint8_t alignment;
+  serialization::readPod(f, alignment);
+  if (alignment != cachedParagraphAlignment) {
+    Serial.printf("[%lu] [TRS] Cache paragraph alignment mismatch, rebuilding\n", millis());
+    f.close();
+    return false;
+  }
+
+  uint32_t numPages;
+  serialization::readPod(f, numPages);
+
+  // Read page offsets
+  pageOffsets.clear();
+  pageOffsets.reserve(numPages);
+
+  for (uint32_t i = 0; i < numPages; i++) {
+    uint32_t offset;
+    serialization::readPod(f, offset);
+    pageOffsets.push_back(offset);
+  }
+
+  f.close();
+  totalPages = pageOffsets.size();
+  Serial.printf("[%lu] [TRS] Loaded page index cache: %d pages\n", millis(), totalPages);
+  return true;
+}
+
+void TxtReaderActivity::savePageIndexCache() const {
+  std::string cachePath = txt->getCachePath() + "/index.bin";
+  FsFile f;
+  if (!SdMan.openFileForWrite("TRS", cachePath, f)) {
+    Serial.printf("[%lu] [TRS] Failed to save page index cache\n", millis());
+    return;
+  }
+
+  // Write header using serialization module
+  serialization::writePod(f, CACHE_MAGIC);
+  serialization::writePod(f, CACHE_VERSION);
+  serialization::writePod(f, static_cast<uint32_t>(txt->getFileSize()));
+  serialization::writePod(f, static_cast<int32_t>(viewportWidth));
+  serialization::writePod(f, static_cast<int32_t>(linesPerPage));
+  serialization::writePod(f, static_cast<int32_t>(cachedFontId));
+  serialization::writePod(f, static_cast<int32_t>(cachedScreenMargin));
+  serialization::writePod(f, cachedParagraphAlignment);
+  serialization::writePod(f, static_cast<uint32_t>(pageOffsets.size()));
+
+  // Write page offsets
+  for (size_t offset : pageOffsets) {
+    serialization::writePod(f, static_cast<uint32_t>(offset));
+  }
+
+  f.close();
+  Serial.printf("[%lu] [TRS] Saved page index cache: %d pages\n", millis(), totalPages);
+}

src/activities/reader/TxtReaderActivity.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <Txt.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+#include <vector>
+
+#include "CrossPointSettings.h"
+#include "activities/ActivityWithSubactivity.h"
+
+class TxtReaderActivity final : public ActivityWithSubactivity {
+  std::unique_ptr<Txt> txt;
+  TaskHandle_t displayTaskHandle = nullptr;
+  SemaphoreHandle_t renderingMutex = nullptr;
+  int currentPage = 0;
+  int totalPages = 1;
+  int pagesUntilFullRefresh = 0;
+  bool updateRequired = false;
+  const std::function<void()> onGoBack;
+  const std::function<void()> onGoHome;
+
+  // Streaming text reader - stores file offsets for each page
+  std::vector<size_t> pageOffsets;  // File offset for start of each page
+  std::vector<std::string> currentPageLines;
+  int linesPerPage = 0;
+  int viewportWidth = 0;
+  bool initialized = false;
+
+  // Cached settings for cache validation (different fonts/margins require re-indexing)
+  int cachedFontId = 0;
+  int cachedScreenMargin = 0;
+  uint8_t cachedParagraphAlignment = CrossPointSettings::LEFT_ALIGN;
+
+  static void taskTrampoline(void* param);
+  [[noreturn]] void displayTaskLoop();
+  void renderScreen();
+  void renderPage();
+  void renderStatusBar(int orientedMarginRight, int orientedMarginBottom, int orientedMarginLeft) const;
+
+  void initializeReader();
+  bool loadPageAtOffset(size_t offset, std::vector<std::string>& outLines, size_t& nextOffset);
+  void buildPageIndex();
+  bool loadPageIndexCache();
+  void savePageIndexCache() const;
+  void saveProgress() const;
+  void loadProgress();
+
+ public:
+  explicit TxtReaderActivity(GfxRenderer& renderer, MappedInputManager& mappedInput, std::unique_ptr<Txt> txt,
+                             const std::function<void()>& onGoBack, const std::function<void()>& onGoHome)
+      : ActivityWithSubactivity("TxtReader", renderer, mappedInput),
+        txt(std::move(txt)),
+        onGoBack(onGoBack),
+        onGoHome(onGoHome) {}
+  void onEnter() override;
+  void onExit() override;
+  void loop() override;
+};

src/main.cpp

@@ -303,6 +303,7 @@ void setup() {
     // Clear app state to avoid getting into a boot loop if the epub doesn't load
     const auto path = APP_STATE.openEpubPath;
     APP_STATE.openEpubPath = "";
+    APP_STATE.lastSleepImage = 0;
     APP_STATE.saveToFile();
     onGoToReader(path);
   }

src/network/CrossPointWebServer.cpp

@@ -72,6 +72,7 @@ void CrossPointWebServer::begin() {
 
   server->on("/api/status", HTTP_GET, [this] { handleStatus(); });
   server->on("/api/files", HTTP_GET, [this] { handleFileListData(); });
+  server->on("/api/folders", HTTP_GET, [this] { handleFolderList(); });
 
   // Upload endpoint with special handling for multipart form data
   server->on("/upload", HTTP_POST, [this] { handleUploadPost(); }, [this] { handleUpload(); });
@@ -82,6 +83,9 @@ void CrossPointWebServer::begin() {
   // Delete file/folder endpoint
   server->on("/delete", HTTP_POST, [this] { handleDelete(); });
 
+  // Move/rename file/folder endpoint
+  server->on("/move", HTTP_POST, [this] { handleMove(); });
+
   server->onNotFound([this] { handleNotFound(); });
   Serial.printf("[%lu] [WEB] [MEM] Free heap after route setup: %d bytes\n", millis(), ESP.getFreeHeap());
 
@@ -555,3 +559,152 @@ void CrossPointWebServer::handleDelete() const {
     server->send(500, "text/plain", "Failed to delete item");
   }
 }
+
+void CrossPointWebServer::handleMove() const {
+  // Get source and destination paths from form data
+  if (!server->hasArg("sourcePath")) {
+    server->send(400, "text/plain", "Missing source path");
+    return;
+  }
+  if (!server->hasArg("destPath")) {
+    server->send(400, "text/plain", "Missing destination path");
+    return;
+  }
+
+  String sourcePath = server->arg("sourcePath");
+  String destPath = server->arg("destPath");
+
+  // Validate source path
+  if (sourcePath.isEmpty() || sourcePath == "/") {
+    server->send(400, "text/plain", "Cannot move root directory");
+    return;
+  }
+
+  // Validate destination path
+  if (destPath.isEmpty()) {
+    server->send(400, "text/plain", "Destination path cannot be empty");
+    return;
+  }
+
+  // Ensure paths start with /
+  if (!sourcePath.startsWith("/")) {
+    sourcePath = "/" + sourcePath;
+  }
+  if (!destPath.startsWith("/")) {
+    destPath = "/" + destPath;
+  }
+
+  // Security check on source: prevent moving protected items
+  const String sourceName = sourcePath.substring(sourcePath.lastIndexOf('/') + 1);
+  if (sourceName.startsWith(".")) {
+    Serial.printf("[%lu] [WEB] Move rejected - hidden/system item: %s\n", millis(), sourcePath.c_str());
+    server->send(403, "text/plain", "Cannot move system files");
+    return;
+  }
+
+  for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) {
+    if (sourceName.equals(HIDDEN_ITEMS[i])) {
+      Serial.printf("[%lu] [WEB] Move rejected - protected item: %s\n", millis(), sourcePath.c_str());
+      server->send(403, "text/plain", "Cannot move protected items");
+      return;
+    }
+  }
+
+  // Check if source exists
+  if (!SdMan.exists(sourcePath.c_str())) {
+    Serial.printf("[%lu] [WEB] Move failed - source not found: %s\n", millis(), sourcePath.c_str());
+    server->send(404, "text/plain", "Source item not found");
+    return;
+  }
+
+  // Check if destination already exists
+  if (SdMan.exists(destPath.c_str())) {
+    Serial.printf("[%lu] [WEB] Move failed - destination already exists: %s\n", millis(), destPath.c_str());
+    server->send(400, "text/plain", "Destination already exists");
+    return;
+  }
+
+  // Ensure destination parent directory exists
+  const int lastSlash = destPath.lastIndexOf('/');
+  if (lastSlash > 0) {
+    const String parentDir = destPath.substring(0, lastSlash);
+    if (!SdMan.exists(parentDir.c_str())) {
+      Serial.printf("[%lu] [WEB] Move failed - destination directory does not exist: %s\n", millis(), parentDir.c_str());
+      server->send(400, "text/plain", "Destination directory does not exist");
+      return;
+    }
+  }
+
+  Serial.printf("[%lu] [WEB] Attempting to move: %s -> %s\n", millis(), sourcePath.c_str(), destPath.c_str());
+
+  // Perform the move using rename
+  if (SdMan.rename(sourcePath.c_str(), destPath.c_str())) {
+    Serial.printf("[%lu] [WEB] Successfully moved: %s -> %s\n", millis(), sourcePath.c_str(), destPath.c_str());
+    server->send(200, "text/plain", "Moved successfully");
+  } else {
+    Serial.printf("[%lu] [WEB] Failed to move: %s -> %s\n", millis(), sourcePath.c_str(), destPath.c_str());
+    server->send(500, "text/plain", "Failed to move item");
+  }
+}
+
+void CrossPointWebServer::handleFolderList() const {
+  Serial.printf("[%lu] [WEB] Building folder list...\n", millis());
+  
+  String jsonResponse = "[";
+  jsonResponse += "\"/\"";
+  
+  collectFoldersRecursively("/", jsonResponse);
+  
+  jsonResponse += "]";
+  
+  Serial.printf("[%lu] [WEB] Served folder list\n", millis());
+  server->send(200, "application/json", jsonResponse);
+}
+
+void CrossPointWebServer::collectFoldersRecursively(const char* path, String& json) const {
+  FsFile dir = SdMan.open(path);
+  if (!dir || !dir.isDirectory()) {
+    if (dir) dir.close();
+    return;
+  }
+  
+  FsFile entry = dir.openNextFile();
+  char name[128];
+  
+  while (entry) {
+    if (entry.isDirectory()) {
+      entry.getName(name, sizeof(name));
+      String folderName = String(name);
+      
+      // Skip hidden folders
+      bool shouldSkip = folderName.startsWith(".");
+      
+      // Check against protected folders
+      if (!shouldSkip) {
+        for (size_t i = 0; i < HIDDEN_ITEMS_COUNT; i++) {
+          if (folderName.equals(HIDDEN_ITEMS[i])) {
+            shouldSkip = true;
+            break;
+          }
+        }
+      }
+      
+      if (!shouldSkip) {
+        String folderPath = String(path);
+        if (!folderPath.endsWith("/")) folderPath += "/";
+        folderPath += folderName;
+        
+        json += ",\"" + folderPath + "\"";
+        
+        // Recurse into subfolder
+        collectFoldersRecursively(folderPath.c_str(), json);
+      }
+    }
+    
+    entry.close();
+    yield();  // Allow other tasks to process
+    entry = dir.openNextFile();
+  }
+  
+  dir.close();
+}

src/network/CrossPointWebServer.h

@@ -40,6 +40,7 @@ class CrossPointWebServer {
 
   // File scanning
   void scanFiles(const char* path, const std::function<void(FileInfo)>& callback) const;
+  void collectFoldersRecursively(const char* path, String& json) const;
   String formatFileSize(size_t bytes) const;
   bool isEpubFile(const String& filename) const;
 
@@ -49,8 +50,10 @@ class CrossPointWebServer {
   void handleStatus() const;
   void handleFileList() const;
   void handleFileListData() const;
+  void handleFolderList() const;
   void handleUpload() const;
   void handleUploadPost() const;
   void handleCreateFolder() const;
   void handleDelete() const;
+  void handleMove() const;
 };

src/network/html/FilesPage.html

@@ -297,6 +297,28 @@
       font-size: 0.9em;
       color: #7f8c8d;
     }
+    #delete-progress-container {
+      margin-top: 15px;
+    }
+    #delete-progress-bar {
+      width: 100%;
+      height: 20px;
+      background-color: #e0e0e0;
+      border-radius: 10px;
+      overflow: hidden;
+    }
+    #delete-progress-fill {
+      height: 100%;
+      background-color: #e74c3c;
+      width: 0%;
+      transition: width 0.3s;
+    }
+    #delete-progress-text {
+      text-align: center;
+      margin-top: 5px;
+      font-size: 0.9em;
+      color: #7f8c8d;
+    }
     .folder-form {
       margin-top: 10px;
     }
@@ -322,6 +344,38 @@
     .folder-btn:hover {
       background-color: #d68910;
     }
+    .rename-input {
+      width: 100%;
+      padding: 10px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      font-size: 1em;
+      margin-bottom: 10px;
+      box-sizing: border-box;
+      font-family: monospace;
+    }
+    .rename-btn-submit {
+      background-color: #3498db;
+      color: white;
+      padding: 10px 20px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 1em;
+      width: 100%;
+    }
+    .rename-btn-submit:hover {
+      background-color: #2980b9;
+    }
+    .folder-select {
+      width: 100%;
+      padding: 10px;
+      border: 1px solid #ddd;
+      border-radius: 4px;
+      font-size: 1em;
+      margin-bottom: 10px;
+      box-sizing: border-box;
+    }
     /* Delete button styles */
     .delete-btn {
       background: none;
@@ -337,9 +391,24 @@
       background-color: #fee;
       color: #e74c3c;
     }
+    .rename-btn {
+      background: none;
+      border: none;
+      cursor: pointer;
+      font-size: 1.1em;
+      padding: 4px 8px;
+      border-radius: 4px;
+      color: #95a5a6;
+      transition: all 0.15s;
+    }
+    .rename-btn:hover {
+      background-color: #e3f2fd;
+      color: #3498db;
+    }
     .actions-col {
-      width: 60px;
+      width: 80px;
       text-align: center;
+      white-space: nowrap;
     }
     /* Failed uploads banner */
     .failed-uploads-banner {
@@ -435,6 +504,28 @@
       font-weight: 600;
       color: #2c3e50;
       word-break: break-all;
+      padding: 10px;
+      background-color: #f8f9fa;
+      border-radius: 4px;
+      margin: 10px 0;
+      border: 1px solid #e0e0e0;
+    }
+    .delete-items-list {
+      max-height: 200px;
+      overflow-y: auto;
+      padding: 10px;
+      background-color: #f8f9fa;
+      border-radius: 4px;
+      margin: 10px 0;
+      border: 1px solid #e0e0e0;
+    }
+    .delete-items-list-item {
+      padding: 8px 5px;
+      border-bottom: 1px solid #e0e0e0;
+      color: #2c3e50;
+    }
+    .delete-items-list-item:last-child {
+      border-bottom: none;
     }
     .delete-btn-confirm {
       background-color: #e74c3c;
@@ -463,6 +554,53 @@
     .delete-btn-cancel:hover {
       background-color: #7f8c8d;
     }
+    /* Checkbox styles */
+    .checkbox-col {
+      width: 40px;
+      text-align: center;
+    }
+    .file-checkbox {
+      width: 18px;
+      height: 18px;
+      cursor: pointer;
+    }
+    .select-all-checkbox {
+      width: 18px;
+      height: 18px;
+      cursor: pointer;
+    }
+    .delete-selected-btn {
+      background-color: #e74c3c;
+      color: white;
+      padding: 10px 20px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 1em;
+    }
+    .delete-selected-btn:hover {
+      background-color: #c0392b;
+    }
+    .delete-selected-btn:disabled {
+      background-color: #95a5a6;
+      cursor: not-allowed;
+    }
+    .move-selected-btn {
+      background-color: #3498db;
+      color: white;
+      padding: 10px 20px;
+      border: none;
+      border-radius: 4px;
+      cursor: pointer;
+      font-size: 1em;
+    }
+    .move-selected-btn:hover {
+      background-color: #2980b9;
+    }
+    .move-selected-btn:disabled {
+      background-color: #95a5a6;
+      cursor: not-allowed;
+    }
     .loader-container {
       display: flex;
       justify-content: center;
@@ -560,6 +698,14 @@
       .actions-col {
         width: 40px;
       }
+      .checkbox-col {
+        width: 30px;
+      }
+      .file-checkbox,
+      .select-all-checkbox {
+        width: 16px;
+        height: 16px;
+      }
       .delete-btn {
         font-size: 1em;
         padding: 2px 4px;
@@ -586,6 +732,8 @@
   <div class="action-buttons">
     <button class="action-btn upload-action-btn" onclick="openUploadModal()">📤 Upload</button>
     <button class="action-btn folder-action-btn" onclick="openFolderModal()">📁 New Folder</button>
+    <button class="move-selected-btn" id="moveSelectedBtn" onclick="openMoveModal()" disabled>📦 Move Selected</button>
+    <button class="delete-selected-btn" id="deleteSelectedBtn" onclick="deleteSelectedFiles()" disabled>🗑️ Delete Selected</button>
   </div>
 </div>
 
@@ -652,19 +800,61 @@
 <div class="modal-overlay" id="deleteModal">
   <div class="modal">
     <button class="modal-close" onclick="closeDeleteModal()">&times;</button>
-    <h3>🗑️ Delete Item</h3>
+    <h3 id="deleteModalTitle">🗑️ Delete Item</h3>
     <div class="folder-form">
       <p class="delete-warning">⚠️ This action cannot be undone!</p>
-      <p class="file-info">Are you sure you want to delete:</p>
-      <p class="delete-item-name" id="deleteItemName"></p>
-      <input type="hidden" id="deleteItemPath">
-      <input type="hidden" id="deleteItemType">
-      <button class="delete-btn-confirm" onclick="confirmDelete()">Delete</button>
+      <div id="deleteModalError" style="display: none; padding: 10px; background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; border-radius: 4px; margin-bottom: 10px;"></div>
+      <p class="file-info" id="deleteModalQuestion">Are you sure you want to delete:</p>
+      <p class="delete-item-name" id="deleteItemName" style="display: none;"></p>
+      <div class="delete-items-list" id="deleteItemsList" style="display: none;"></div>
+      <button class="delete-btn-confirm" onclick="confirmDelete()" id="deleteConfirmBtn">Delete</button>
       <button class="delete-btn-cancel" onclick="closeDeleteModal()">Cancel</button>
     </div>
   </div>
 </div>
 
+<!-- Rename Modal -->
+<div class="modal-overlay" id="renameModal">
+  <div class="modal">
+    <button class="modal-close" onclick="closeRenameModal()">&times;</button>
+    <h3>✏️ Rename Item</h3>
+    <div class="folder-form">
+      <p class="file-info">Enter new name:</p>
+      <div style="display: flex; align-items: center; gap: 5px;">
+        <input type="text" id="renameInput" class="rename-input" placeholder="filename" style="flex: 1; margin-bottom: 0;">
+        <span id="renameExtension" style="font-family: monospace; color: #7f8c8d; font-size: 1em; padding: 10px; background-color: #f8f9fa; border: 1px solid #ddd; border-radius: 4px;"></span>
+      </div>
+      <input type="hidden" id="renameOriginalPath">
+      <input type="hidden" id="renameOriginalExtension">
+      <button class="rename-btn-submit" onclick="confirmRename()" style="margin-top: 10px;">Rename</button>
+      <button class="delete-btn-cancel" onclick="closeRenameModal()">Cancel</button>
+    </div>
+  </div>
+</div>
+
+<!-- Move Selected Modal -->
+<div class="modal-overlay" id="moveModal">
+  <div class="modal">
+    <button class="modal-close" onclick="closeMoveModal()">&times;</button>
+    <h3>📦 Move Selected Items</h3>
+    <div class="folder-form">
+      <p class="file-info">Select destination folder for <strong id="moveItemCount">0</strong> items:</p>
+      <div id="folderListLoading" style="display: none; text-align: center; padding: 20px; color: #7f8c8d;">
+        <div class="loader" style="width: 32px; height: 32px; border-width: 3px; margin: 0 auto 10px;"></div>
+        <div>Loading folders...</div>
+      </div>
+      <div id="folderListError" style="display: none; padding: 10px; background-color: #f8d7da; color: #721c24; border: 1px solid #f5c6cb; border-radius: 4px; margin-bottom: 10px;">
+        Failed to load folder list. Please try again.
+      </div>
+      <select id="folderSelect" class="folder-select">
+        <option value="/">/  (Root)</option>
+      </select>
+      <button class="rename-btn-submit" onclick="confirmMove()" id="moveConfirmBtn">Move Here</button>
+      <button class="delete-btn-cancel" onclick="closeMoveModal()">Cancel</button>
+    </div>
+  </div>
+</div>
+
 <script>
   // get current path from query parameter
   const currentPath = decodeURIComponent(new URLSearchParams(window.location.search).get('path') || '/');
@@ -739,7 +929,7 @@
       fileTable.innerHTML = '<div class="no-files">This folder is empty</div>';
     } else {
       let fileTableContent = '<table class="file-table">';
-      fileTableContent += '<tr><th>Name</th><th>Type</th><th>Size</th><th class="actions-col">Actions</th></tr>';
+      fileTableContent += '<tr><th class="checkbox-col"><input type="checkbox" class="select-all-checkbox" onchange="toggleSelectAll(this)"></th><th>Name</th><th>Type</th><th>Size</th><th class="actions-col">Actions</th></tr>';
 
       const sortedFiles = files.sort((a, b) => {
         // Directories first, then epub files, then other files, alphabetically within each group
@@ -755,12 +945,12 @@
           let folderPath = currentPath;
           if (!folderPath.endsWith("/")) folderPath += "/";
           folderPath += file.name;
-
           fileTableContent += '<tr class="folder-row">';
+          fileTableContent += `<td class="checkbox-col"><input type="checkbox" class="file-checkbox" data-path="${folderPath.replaceAll('"', '&quot;')}" data-name="${escapeHtml(file.name)}" data-type="folder" onchange="updateDeleteButton()"></td>`;
           fileTableContent += `<td><span class="file-icon">📁</span><a href="/files?path=${encodeURIComponent(folderPath)}" class="folder-link">${escapeHtml(file.name)}</a><span class="folder-badge">FOLDER</span></td>`;
           fileTableContent += '<td>Folder</td>';
           fileTableContent += '<td>-</td>';
-          fileTableContent += `<td class="actions-col"><button class="delete-btn" onclick="openDeleteModal('${file.name.replaceAll("'", "\\'")}', '${folderPath.replaceAll("'", "\\'")}', true)" title="Delete folder">🗑️</button></td>`;
+          fileTableContent += `<td class="actions-col"><button class="rename-btn" onclick="openRenameModal('${folderPath.replaceAll("'", "\\'")}')" title="Rename">✏️</button><button class="delete-btn" onclick="openDeleteModal('${file.name.replaceAll("'", "\\'")}', '${folderPath.replaceAll("'", "\\'")}', true)" title="Delete folder">🗑️</button></td>`;
           fileTableContent += '</tr>';
         } else {
           let filePath = currentPath;
@@ -768,12 +958,13 @@
           filePath += file.name;
 
           fileTableContent += `<tr class="${file.isEpub ? 'epub-file' : ''}">`;
+          fileTableContent += `<td class="checkbox-col"><input type="checkbox" class="file-checkbox" data-path="${filePath.replaceAll('"', '&quot;')}" data-name="${escapeHtml(file.name)}" data-type="file" onchange="updateDeleteButton()"></td>`;
           fileTableContent += `<td><span class="file-icon">${file.isEpub ? '📗' : '📄'}</span>${escapeHtml(file.name)}`;
           if (file.isEpub) fileTableContent += '<span class="epub-badge">EPUB</span>';
           fileTableContent += '</td>';
           fileTableContent += `<td>${file.name.split('.').pop().toUpperCase()}</td>`;
           fileTableContent += `<td>${formatFileSize(file.size)}</td>`;
-          fileTableContent += `<td class="actions-col"><button class="delete-btn" onclick="openDeleteModal('${file.name.replaceAll("'", "\\'")}', '${filePath.replaceAll("'", "\\'")}', false)" title="Delete file">🗑️</button></td>`;
+          fileTableContent += `<td class="actions-col"><button class="rename-btn" onclick="openRenameModal('${filePath.replaceAll("'", "\\'")}')" title="Rename">✏️</button><button class="delete-btn" onclick="openDeleteModal('${file.name.replaceAll("'", "\\'")}', '${filePath.replaceAll("'", "\\'")}', false)" title="Delete file">🗑️</button></td>`;
           fileTableContent += '</tr>';
         }
       });
@@ -817,6 +1008,39 @@
 
 let failedUploadsGlobal = [];
 
+// Checkbox management functions
+function toggleSelectAll(checkbox) {
+  const allCheckboxes = document.querySelectorAll('.file-checkbox');
+  allCheckboxes.forEach(cb => {
+    cb.checked = checkbox.checked;
+  });
+  updateDeleteButton();
+}
+
+function updateDeleteButton() {
+  const checkedBoxes = document.querySelectorAll('.file-checkbox:checked');
+  const deleteBtn = document.getElementById('deleteSelectedBtn');
+  const moveBtn = document.getElementById('moveSelectedBtn');
+  const hasSelection = checkedBoxes.length > 0;
+  
+  if (deleteBtn) {
+    deleteBtn.disabled = !hasSelection;
+  }
+  if (moveBtn) {
+    moveBtn.disabled = !hasSelection;
+  }
+  
+  // Update select-all checkbox state
+  const allCheckboxes = document.querySelectorAll('.file-checkbox');
+  const selectAllCheckbox = document.querySelector('.select-all-checkbox');
+  if (selectAllCheckbox && allCheckboxes.length > 0) {
+    const allChecked = Array.from(allCheckboxes).every(cb => cb.checked);
+    const someChecked = Array.from(allCheckboxes).some(cb => cb.checked);
+    selectAllCheckbox.checked = allChecked;
+    selectAllCheckbox.indeterminate = someChecked && !allChecked;
+  }
+}
+
 function uploadFile() {
   const fileInput = document.getElementById('fileInput');
   const files = Array.from(fileInput.files);
@@ -837,6 +1061,42 @@ function uploadFile() {
   let currentIndex = 0;
   const failedFiles = [];
 
+  function uploadSingleFile(file, index) {
+    return new Promise((resolve, reject) => {
+      const formData = new FormData();
+      formData.append('file', file);
+
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', '/upload?path=' + encodeURIComponent(currentPath), true);
+
+      progressFill.style.width = '0%';
+      progressFill.style.backgroundColor = '#4caf50';
+      progressText.textContent = `Uploading ${file.name} (${index + 1}/${files.length})`;
+
+      xhr.upload.onprogress = function (e) {
+        if (e.lengthComputable) {
+          const percent = Math.round((e.loaded / e.total) * 100);
+          progressFill.style.width = percent + '%';
+          progressText.textContent = `Uploading ${file.name} (${index + 1}/${files.length}) — ${percent}%`;
+        }
+      };
+
+      xhr.onload = function () {
+        if (xhr.status === 200) {
+          resolve();
+        } else {
+          reject(new Error(xhr.responseText || 'Upload failed'));
+        }
+      };
+
+      xhr.onerror = function () {
+        reject(new Error('Network error'));
+      };
+
+      xhr.send(formData);
+    });
+  }
+
   function uploadNextFile() {
     if (currentIndex >= files.length) {
       // All files processed - show summary
@@ -845,67 +1105,36 @@ function uploadFile() {
         progressText.textContent = 'All uploads complete!';
         setTimeout(() => {
           closeUploadModal();
-          hydrate(); // Refresh file list instead of reloading
+          hydrate();
         }, 1000);
       } else {
         progressFill.style.backgroundColor = '#e74c3c';
         const failedList = failedFiles.map(f => f.name).join(', ');
         progressText.textContent = `${files.length - failedFiles.length}/${files.length} uploaded. Failed: ${failedList}`;
         
-        // Store failed files globally and show banner
         failedUploadsGlobal = failedFiles;
         
         setTimeout(() => {
           closeUploadModal();
           showFailedUploadsBanner();
-          hydrate(); // Refresh file list to show successfully uploaded files
+          hydrate();
         }, 2000);
       }
       return;
     }
 
     const file = files[currentIndex];
-    const formData = new FormData();
-    formData.append('file', file);
-
-    const xhr = new XMLHttpRequest();
-    // Include path as query parameter since multipart form data doesn't make
-    // form fields available until after file upload completes
-    xhr.open('POST', '/upload?path=' + encodeURIComponent(currentPath), true);
-
-    progressFill.style.width = '0%';
-    progressFill.style.backgroundColor = '#4caf50';
-    progressText.textContent = `Uploading ${file.name} (${currentIndex + 1}/${files.length})`;
-
-    xhr.upload.onprogress = function (e) {
-      if (e.lengthComputable) {
-        const percent = Math.round((e.loaded / e.total) * 100);
-        progressFill.style.width = percent + '%';
-        progressText.textContent =
-          `Uploading ${file.name} (${currentIndex + 1}/${files.length}) — ${percent}%`;
-      }
-    };
-
-    xhr.onload = function () {
-      if (xhr.status === 200) {
-        currentIndex++;
-        uploadNextFile(); // upload next file
-      } else {
-        // Track failure and continue with next file
-        failedFiles.push({ name: file.name, error: xhr.responseText, file: file });
+    
+    uploadSingleFile(file, currentIndex)
+      .then(() => {
         currentIndex++;
         uploadNextFile();
-      }
-    };
-
-    xhr.onerror = function () {
-      // Track network error and continue with next file
-      failedFiles.push({ name: file.name, error: 'network error', file: file });
-      currentIndex++;
-      uploadNextFile();
-    };
-
-    xhr.send(formData);
+      })
+      .catch((error) => {
+        failedFiles.push({ name: file.name, error: error.message, file: file });
+        currentIndex++;
+        uploadNextFile();
+      });
   }
 
   uploadNextFile();
@@ -988,6 +1217,298 @@ function retryAllFailedUploads() {
   validateFile();
 }
 
+function deleteSelectedFiles() {
+  const checkedBoxes = document.querySelectorAll('.file-checkbox:checked');
+  
+  if (checkedBoxes.length === 0) {
+    alert('Please select at least one item to delete!');
+    return;
+  }
+
+  const items = Array.from(checkedBoxes).map(checkbox => ({
+    path: checkbox.dataset.path,
+    name: checkbox.dataset.name,
+    type: checkbox.dataset.type
+  }));
+
+  // Open the delete modal with all selected items
+  openDeleteModalMultiple(items);
+}
+
+// Rename/Move functions
+function openRenameModal(currentPath) {
+  document.getElementById('renameOriginalPath').value = currentPath;
+  
+  // Extract just the filename from the path
+  const lastSlash = currentPath.lastIndexOf('/');
+  const filename = currentPath.substring(lastSlash + 1);
+  
+  // Split filename and extension
+  const lastDot = filename.lastIndexOf('.');
+  const hasExtension = lastDot > 0;
+  const nameWithoutExt = hasExtension ? filename.substring(0, lastDot) : filename;
+  const extension = hasExtension ? filename.substring(lastDot) : '';
+  
+  document.getElementById('renameInput').value = nameWithoutExt;
+  document.getElementById('renameOriginalExtension').value = extension;
+  document.getElementById('renameExtension').textContent = extension || '(no extension)';
+  document.getElementById('renameModal').classList.add('open');
+  
+  // Focus and select all text in the input
+  setTimeout(() => {
+    const input = document.getElementById('renameInput');
+    input.focus();
+    input.select();
+  }, 100);
+}
+
+function closeRenameModal() {
+  document.getElementById('renameModal').classList.remove('open');
+}
+
+function confirmRename() {
+  const originalPath = document.getElementById('renameOriginalPath').value;
+  const newNamePart = document.getElementById('renameInput').value.trim();
+  const extension = document.getElementById('renameOriginalExtension').value;
+
+  if (!newNamePart) {
+    alert('Name cannot be empty!');
+    return;
+  }
+
+  // Validate filename (no slashes or dots allowed in name part)
+  if (newNamePart.includes('/') || newNamePart.includes('\\')) {
+    alert('Name cannot contain slashes. Use "Move Selected" to move files to a different folder.');
+    return;
+  }
+  
+  if (newNamePart.includes('.')) {
+    alert('Name cannot contain dots. The file extension is preserved automatically.');
+    return;
+  }
+  
+  // Reconstruct full filename with original extension
+  const newName = newNamePart + extension;
+
+  // Extract directory from original path and construct new path
+  const lastSlash = originalPath.lastIndexOf('/');
+  const directory = originalPath.substring(0, lastSlash + 1);
+  const newPath = directory + newName;
+
+  if (originalPath === newPath) {
+    closeRenameModal();
+    return;
+  }
+
+  const formData = new FormData();
+  formData.append('sourcePath', originalPath);
+  formData.append('destPath', newPath);
+
+  const xhr = new XMLHttpRequest();
+  xhr.open('POST', '/move', true);
+
+  xhr.onload = function() {
+    if (xhr.status === 200) {
+      closeRenameModal();
+      hydrate();
+    } else {
+      alert('Failed to rename: ' + xhr.responseText);
+    }
+  };
+
+  xhr.onerror = function() {
+    alert('Failed to rename - network error');
+  };
+
+  xhr.send(formData);
+}
+
+// Move selected functions
+function openMoveModal() {
+  const checkedBoxes = document.querySelectorAll('.file-checkbox:checked');
+  
+  if (checkedBoxes.length === 0) {
+    alert('Please select at least one item to move!');
+    return;
+  }
+
+  document.getElementById('moveItemCount').textContent = checkedBoxes.length;
+  
+  // Build folder list
+  buildFolderList();
+  
+  document.getElementById('moveModal').classList.add('open');
+}
+
+function closeMoveModal() {
+  document.getElementById('moveModal').classList.remove('open');
+}
+
+async function buildFolderList() {
+  const select = document.getElementById('folderSelect');
+  const loading = document.getElementById('folderListLoading');
+  const error = document.getElementById('folderListError');
+  const confirmBtn = document.getElementById('moveConfirmBtn');
+  
+  // Show loading, hide error, disable controls
+  loading.style.display = 'block';
+  error.style.display = 'none';
+  select.disabled = true;
+  confirmBtn.disabled = true;
+  select.innerHTML = '<option value="/">/  (Root)</option>';
+  
+  try {
+    const response = await fetch('/api/folders');
+    if (!response.ok) {
+      throw new Error('Failed to load folders');
+    }
+    
+    const folders = await response.json();
+    
+    // Skip first item (root) since we already added it
+    folders.slice(1).forEach(folder => {
+      const option = document.createElement('option');
+      option.value = folder;
+      option.textContent = folder;
+      select.appendChild(option);
+    });
+    
+    // Set current path as selected
+    if (select.querySelector(`option[value="${currentPath}"]`)) {
+      select.value = currentPath;
+    }
+    
+    // Success - hide loading, enable controls
+    loading.style.display = 'none';
+    select.disabled = false;
+    confirmBtn.disabled = false;
+  } catch (e) {
+    console.error('Failed to load folders:', e);
+    // Error - hide loading, show error
+    loading.style.display = 'none';
+    error.style.display = 'block';
+    select.disabled = true;
+    confirmBtn.disabled = true;
+  }
+}
+
+function confirmMove() {
+  const checkedBoxes = document.querySelectorAll('.file-checkbox:checked');
+  const destFolder = document.getElementById('folderSelect').value;
+  
+  if (checkedBoxes.length === 0) {
+    alert('No items selected!');
+    return;
+  }
+
+  const items = Array.from(checkedBoxes).map(checkbox => ({
+    path: checkbox.dataset.path,
+    name: checkbox.dataset.name
+  }));
+
+  closeMoveModal();
+  performMultipleMoves(items, destFolder);
+}
+
+function performMultipleMoves(items, destFolder) {
+  // Create progress overlay
+  const progressOverlay = document.createElement('div');
+  progressOverlay.className = 'modal-overlay open';
+  progressOverlay.innerHTML = `
+    <div class="modal">
+      <h3>📦 Moving items...</h3>
+      <div id="delete-progress-container">
+        <div id="delete-progress-bar"><div id="delete-progress-fill"></div></div>
+        <div id="delete-progress-text"></div>
+      </div>
+      <button id="move-progress-close" class="delete-btn-cancel" style="display: none; margin-top: 15px;">Close</button>
+    </div>
+  `;
+  document.body.appendChild(progressOverlay);
+
+  const progressFill = document.getElementById('delete-progress-fill');
+  const progressText = document.getElementById('delete-progress-text');
+  const closeBtn = document.getElementById('move-progress-close');
+  progressFill.style.backgroundColor = '#3498db';
+
+  let currentIndex = 0;
+  const failedMoves = [];
+
+  function moveSingleItem(item, index) {
+    return new Promise((resolve, reject) => {
+      let destPath = destFolder;
+      if (!destPath.endsWith('/')) destPath += '/';
+      destPath += item.name;
+
+      const formData = new FormData();
+      formData.append('sourcePath', item.path);
+      formData.append('destPath', destPath);
+
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', '/move', true);
+
+      progressText.textContent = `Moving ${item.name} (${index + 1}/${items.length})`;
+
+      xhr.onload = function () {
+        if (xhr.status === 200) {
+          const percent = Math.round(((index + 1) / items.length) * 100);
+          progressFill.style.width = percent + '%';
+          resolve();
+        } else {
+          reject(new Error(xhr.responseText || 'Move failed'));
+        }
+      };
+
+      xhr.onerror = function () {
+        reject(new Error('Network error'));
+      };
+
+      xhr.send(formData);
+    });
+  }
+
+  function moveNextItem() {
+    if (currentIndex >= items.length) {
+      // All items processed
+      if (failedMoves.length === 0) {
+        progressFill.style.backgroundColor = '#4caf50';
+        progressText.textContent = 'All items moved successfully!';
+        setTimeout(() => {
+          document.body.removeChild(progressOverlay);
+          hydrate();
+        }, 1000);
+      } else {
+        progressFill.style.backgroundColor = '#e74c3c';
+        const errorDetails = failedMoves.map(f => `${f.name}: ${f.error}`).join('<br>');
+        progressText.innerHTML = `${items.length - failedMoves.length}/${items.length} moved successfully.<br><br><strong>Failed items:</strong><br>${errorDetails}`;
+        
+        // Show close button for user to dismiss
+        closeBtn.style.display = 'block';
+        closeBtn.onclick = () => {
+          document.body.removeChild(progressOverlay);
+          hydrate();
+        };
+      }
+      return;
+    }
+
+    const item = items[currentIndex];
+    
+    moveSingleItem(item, currentIndex)
+      .then(() => {
+        currentIndex++;
+        moveNextItem();
+      })
+      .catch((error) => {
+        failedMoves.push({ name: item.name, error: error.message });
+        currentIndex++;
+        moveNextItem();
+      });
+  }
+
+  moveNextItem();
+}
+
   function createFolder() {
     const folderName = document.getElementById('folderName').value.trim();
 
@@ -1026,43 +1547,182 @@ function retryAllFailedUploads() {
   }
 
   // Delete functions
+  let itemsToDelete = [];
+
   function openDeleteModal(name, path, isFolder) {
+    // Single item deletion
+    itemsToDelete = [{ name, path, type: isFolder ? 'folder' : 'file' }];
+    
+    document.getElementById('deleteModalTitle').textContent = '🗑️ Delete Item';
+    document.getElementById('deleteModalQuestion').textContent = 'Are you sure you want to delete:';
     document.getElementById('deleteItemName').textContent = (isFolder ? '📁 ' : '📄 ') + name;
-    document.getElementById('deleteItemPath').value = path;
-    document.getElementById('deleteItemType').value = isFolder ? 'folder' : 'file';
+    document.getElementById('deleteItemName').style.display = 'block';
+    document.getElementById('deleteItemsList').style.display = 'none';
+    document.getElementById('deleteModal').classList.add('open');
+  }
+
+  function openDeleteModalMultiple(items) {
+    // Multiple items deletion
+    itemsToDelete = items;
+    
+    document.getElementById('deleteModalTitle').textContent = `🗑️ Delete ${items.length} Items`;
+    document.getElementById('deleteModalQuestion').textContent = `Are you sure you want to delete these ${items.length} items:`;
+    document.getElementById('deleteItemName').style.display = 'none';
+    
+    const listContainer = document.getElementById('deleteItemsList');
+    listContainer.innerHTML = items.map(item => 
+      `<div class="delete-items-list-item">${item.type === 'folder' ? '📁' : '📄'} ${escapeHtml(item.name)}</div>`
+    ).join('');
+    listContainer.style.display = 'block';
+    
     document.getElementById('deleteModal').classList.add('open');
   }
 
   function closeDeleteModal() {
     document.getElementById('deleteModal').classList.remove('open');
+    document.getElementById('deleteModalError').style.display = 'none';
+    document.getElementById('deleteConfirmBtn').disabled = false;
   }
 
   function confirmDelete() {
-    const path = document.getElementById('deleteItemPath').value;
-    const itemType = document.getElementById('deleteItemType').value;
+    const errorDiv = document.getElementById('deleteModalError');
+    const confirmBtn = document.getElementById('deleteConfirmBtn');
+    
+    // Hide any previous error
+    errorDiv.style.display = 'none';
+    
+    if (itemsToDelete.length === 1) {
+      // Single item - simple delete
+      const item = itemsToDelete[0];
+      const formData = new FormData();
+      formData.append('path', item.path);
+      formData.append('type', item.type);
 
-    const formData = new FormData();
-    formData.append('path', path);
-    formData.append('type', itemType);
+      // Disable button during request
+      confirmBtn.disabled = true;
 
-    const xhr = new XMLHttpRequest();
-    xhr.open('POST', '/delete', true);
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', '/delete', true);
 
-    xhr.onload = function() {
-      if (xhr.status === 200) {
-        window.location.reload();
-      } else {
-        alert('Failed to delete: ' + xhr.responseText);
-        closeDeleteModal();
-      }
-    };
+      xhr.onload = function() {
+        if (xhr.status === 200) {
+          closeDeleteModal();
+          hydrate();
+        } else {
+          // Show error in modal
+          errorDiv.textContent = xhr.responseText || 'Failed to delete item';
+          errorDiv.style.display = 'block';
+          confirmBtn.disabled = false;
+        }
+      };
 
-    xhr.onerror = function() {
-      alert('Failed to delete - network error');
+      xhr.onerror = function() {
+        // Show error in modal
+        errorDiv.textContent = 'Failed to delete - network error';
+        errorDiv.style.display = 'block';
+        confirmBtn.disabled = false;
+      };
+
+      xhr.send(formData);
+    } else {
+      // Multiple items - show progress
       closeDeleteModal();
-    };
+      performMultipleDeletes(itemsToDelete);
+    }
+  }
 
-    xhr.send(formData);
+  function performMultipleDeletes(items) {
+    // Create progress overlay
+    const progressOverlay = document.createElement('div');
+    progressOverlay.className = 'modal-overlay open';
+    progressOverlay.innerHTML = `
+      <div class="modal">
+        <h3>🗑️ Deleting items...</h3>
+        <div id="delete-progress-container">
+          <div id="delete-progress-bar"><div id="delete-progress-fill"></div></div>
+          <div id="delete-progress-text"></div>
+        </div>
+        <button id="delete-progress-close" class="delete-btn-cancel" style="display: none; margin-top: 15px;">Close</button>
+      </div>
+    `;
+    document.body.appendChild(progressOverlay);
+
+    const progressFill = document.getElementById('delete-progress-fill');
+    const progressText = document.getElementById('delete-progress-text');
+    const closeBtn = document.getElementById('delete-progress-close');
+
+    let currentIndex = 0;
+    const failedDeletes = [];
+
+    function deleteSingleItem(item, index) {
+      return new Promise((resolve, reject) => {
+        const formData = new FormData();
+        formData.append('path', item.path);
+        formData.append('type', item.type);
+
+        const xhr = new XMLHttpRequest();
+        xhr.open('POST', '/delete', true);
+
+        progressText.textContent = `Deleting ${item.name} (${index + 1}/${items.length})`;
+
+        xhr.onload = function () {
+          if (xhr.status === 200) {
+            const percent = Math.round(((index + 1) / items.length) * 100);
+            progressFill.style.width = percent + '%';
+            resolve();
+          } else {
+            reject(new Error(xhr.responseText || 'Delete failed'));
+          }
+        };
+
+        xhr.onerror = function () {
+          reject(new Error('Network error'));
+        };
+
+        xhr.send(formData);
+      });
+    }
+
+    function deleteNextItem() {
+      if (currentIndex >= items.length) {
+        // All items processed
+        if (failedDeletes.length === 0) {
+          progressFill.style.backgroundColor = '#4caf50';
+          progressText.textContent = 'All items deleted successfully!';
+          setTimeout(() => {
+            document.body.removeChild(progressOverlay);
+            hydrate();
+          }, 1000);
+        } else {
+          progressFill.style.backgroundColor = '#e74c3c';
+          const errorDetails = failedDeletes.map(f => `${f.name}: ${f.error}`).join('<br>');
+          progressText.innerHTML = `${items.length - failedDeletes.length}/${items.length} deleted successfully.<br><br><strong>Failed items:</strong><br>${errorDetails}`;
+          
+          // Show close button for user to dismiss
+          closeBtn.style.display = 'block';
+          closeBtn.onclick = () => {
+            document.body.removeChild(progressOverlay);
+            hydrate();
+          };
+        }
+        return;
+      }
+
+      const item = items[currentIndex];
+      
+      deleteSingleItem(item, currentIndex)
+        .then(() => {
+          currentIndex++;
+          deleteNextItem();
+        })
+        .catch((error) => {
+          failedDeletes.push({ name: item.name, error: error.message });
+          currentIndex++;
+          deleteNextItem();
+        });
+    }
+
+    deleteNextItem();
   }
 
   hydrate();

src/util/StringUtils.cpp

@@ -49,4 +49,23 @@ bool checkFileExtension(const std::string& fileName, const char* extension) {
   return true;
 }
 
+size_t utf8RemoveLastChar(std::string& str) {
+  if (str.empty()) return 0;
+  size_t pos = str.size() - 1;
+  // Walk back to find the start of the last UTF-8 character
+  // UTF-8 continuation bytes start with 10xxxxxx (0x80-0xBF)
+  while (pos > 0 && (static_cast<unsigned char>(str[pos]) & 0xC0) == 0x80) {
+    --pos;
+  }
+  str.resize(pos);
+  return pos;
+}
+
+// Truncate string by removing N UTF-8 characters from the end
+void utf8TruncateChars(std::string& str, const size_t numChars) {
+  for (size_t i = 0; i < numChars && !str.empty(); ++i) {
+    utf8RemoveLastChar(str);
+  }
+}
+
 }  // namespace StringUtils

src/util/StringUtils.h

@@ -16,4 +16,10 @@ std::string sanitizeFilename(const std::string& name, size_t maxLength = 100);
  */
 bool checkFileExtension(const std::string& fileName, const char* extension);
 
+// UTF-8 safe string truncation - removes one character from the end
+// Returns the new size after removing one UTF-8 character
+size_t utf8RemoveLastChar(std::string& str);
+
+// Truncate string by removing N UTF-8 characters from the end
+void utf8TruncateChars(std::string& str, size_t numChars);
 }  // namespace StringUtils