fix: add missing keyboard metrics to Lyra3CoversTheme (#1101 )

Fix for keyboard. Issue #1100
chore: Bump version to 1.1.1
2026-02-23 18:00:17 +11:00 · 2026-02-23 18:00:17 +11:00 · 2026-02-22 13:11:37 +11:00 · 2026-02-22 13:00:08 +11:00 · 2026-02-22 13:00:01 +11:00 · 2026-02-22 12:59:49 +11:00
365 changed files with 188474 additions and 274658 deletions
@@ -1,10 +1,55 @@
-name: CI
-'on':
+name: CI (build)
+
+on:
  push:
    branches: [master]
  pull_request:

+permissions:
+  contents: read
+
 jobs:
+  clang-format:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
+      - name: Install clang-format-21
+        run: |
+          wget https://apt.llvm.org/llvm.sh
+          chmod +x llvm.sh
+          sudo ./llvm.sh 21
+          sudo apt-get update
+          sudo apt-get install -y clang-format-21
+
+      - name: Run clang-format
+        run: |
+          PATH="/usr/lib/llvm-21/bin:$PATH" ./bin/clang-format-fix
+          git diff --exit-code || (echo "Please run 'bin/clang-format-fix' to fix formatting issues" && exit 1)
+
+  cppcheck:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+
+      - name: Run cppcheck
+        run: pio check --fail-on-defect low --fail-on-defect medium --fail-on-defect high
+
  build:
    runs-on: ubuntu-latest
    steps:
@@ -19,19 +64,46 @@ jobs:
      - name: Install PlatformIO Core
        run: pip install --upgrade platformio

-      - name: Install clang-format-21
-        run: |
-          wget https://apt.llvm.org/llvm.sh
-          chmod +x llvm.sh
-          sudo ./llvm.sh 21
-          sudo apt-get update
-          sudo apt-get install -y clang-format-21
-
-      - name: Run cppcheck
-        run: pio check --fail-on-defect low --fail-on-defect medium --fail-on-defect high
-
-      - name: Run clang-format
-        run: PATH="/usr/lib/llvm-21/bin:$PATH" ./bin/clang-format-fix && git diff --exit-code || (echo "Please run 'bin/clang-format-fix' to fix formatting issues" && exit 1)
-
      - name: Build CrossPoint
-        run: pio run
+        run: |
+          set -euo pipefail
+          pio run | tee pio.log
+
+      - name: Extract firmware stats
+
+        run: |
+          set -euo pipefail
+          ram_line="$(grep -E "RAM:\\s" -m1 pio.log || true)"
+          flash_line="$(grep -E "Flash:\\s" -m1 pio.log || true)"
+          echo "ram_line=${ram_line}" >> "$GITHUB_OUTPUT"
+          echo "flash_line=${flash_line}" >> "$GITHUB_OUTPUT"
+          {
+            echo "## Firmware build stats"
+            if [ -n "$ram_line" ]; then echo "- ${ram_line}"; else echo "- RAM: not found"; fi
+            if [ -n "$flash_line" ]; then echo "- ${flash_line}"; else echo "- Flash: not found"; fi
+          } >> "$GITHUB_STEP_SUMMARY"
+
+      - name: Upload firmware.bin artifact
+        uses: actions/upload-artifact@v6
+        with:
+          name: firmware.bin
+          path: .pio/build/default/firmware.bin
+          if-no-files-found: error
+
+  # This job is used as the PR required actions check, allows for changes to other steps in the future without breaking
+  # PR requirements.
+  test-status:
+    name: Test Status
+    needs:
+      - build
+      - clang-format
+      - cppcheck
+    if: always()
+    runs-on: ubuntu-latest
+    steps:
+      - name: Fail because needed jobs failed
+        # Fail if any job failed or was cancelled (skipped jobs are ok)
+        if: ${{ contains(needs.*.result, 'failure') || contains(needs.*.result, 'cancelled') }}
+        run: exit 1
+      - name: Success
+        run: exit 0
@@ -1,6 +1,7 @@
 name: "PR Formatting"

 on:
+  pull_request:
  pull_request_target:
    types:
      - opened
@@ -0,0 +1,48 @@
+name: Compile Release Candidate
+
+on:
+  workflow_dispatch:
+
+jobs:
+  build-release-candidate:
+    if: startsWith(github.ref_name, 'release/')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          submodules: recursive
+
+      - uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cache/pip
+            ~/.platformio/.cache
+          key: ${{ runner.os }}-pio
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: '3.14'
+
+      - name: Install PlatformIO Core
+        run: pip install --upgrade platformio
+
+      - name: Extract env
+        run: |
+          echo "SHORT_SHA=${GITHUB_SHA::7}" >> $GITHUB_ENV
+          echo "BRANCH_SUFFIX=${GITHUB_REF_NAME#release/}" >> $GITHUB_ENV
+
+      - name: Build CrossPoint Release Candidate
+        env:
+          CROSSPOINT_RC_HASH: ${{ env.SHORT_SHA }}
+        run: pio run -e gh_release_rc
+
+      - name: Upload Artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: CrossPoint-RC-${{ env.BRANCH_SUFFIX }}
+          path: |
+            .pio/build/gh_release_rc/bootloader.bin
+            .pio/build/gh_release_rc/firmware.bin
+            .pio/build/gh_release_rc/firmware.elf
+            .pio/build/gh_release_rc/firmware.map
+            .pio/build/gh_release_rc/partitions.bin
@@ -3,6 +3,7 @@
 .DS_Store
 .vscode
 lib/EpdFont/fontsrc
+lib/I18n/I18nStrings.cpp
 *.generated.h
 .vs
 build
@@ -0,0 +1,38 @@
+# Project Governance & Community Principles
+
+CrossPoint Reader is a community-driven, open-source project. Our goal is to provide a high-quality, open-source
+firmware alternative for the Xteink X4 hardware. To keep this project productive and welcoming as we grow, we ask all
+contributors to follow these principles.
+
+### 1. The "Human First" Rule
+Technical discussions can get heated, but they should never be personal.
+- **Assume good intent:** We are all volunteers working on this in our free time. If a comment seems abrasive, assume
+  it’s a language barrier or a misunderstanding before taking offense.
+- **Focus on the code, not the person:** Critique the implementation, the performance, or the UX. Never the intelligence
+  or character of the contributor.
+- **Inflammatory language:** Personal attacks, trolling, or exclusionary language (based on race, gender, background,
+  etc.) are not welcome here and will be moderated.
+
+### 2. A "Do-ocracy" with Guidance
+CrossPoint thrives because people step up to build what they want to see.
+- If you want a feature, the best way to get it is to start an
+  [Idea Discussion](https://github.com/crosspoint-reader/crosspoint-reader/discussions/categories/ideas) or open a PR.
+- If you want to report a bug, check for duplicates and create an
+  [Issue](https://github.com/crosspoint-reader/crosspoint-reader/issues).
+- While we encourage experimentation, the maintainers reserve the right to guide the project’s technical direction to
+  ensure stability on the ESP32-C3’s constrained hardware.
+- For more guidance on the scope of the project, see the [SCOPE.md](SCOPE.md) document.
+
+### 3. Transparent Communication
+To keep the project healthy, we keep our "work" in the open.
+- **Public by Default:** All technical decisions and project management discussions happen in GitHub Issues, Pull
+  Requests, or the public Discussions tab.
+- **Clarity in Writing:** Because we have a global community with different levels of English proficiency, please be as
+  explicit and clear as possible in your PR descriptions and bug reports.
+
+### 4. Moderation & Safety
+The maintainers are responsible for keeping the community a safe place to contribute.
+- We reserve the right to hide comments, lock threads, or block users who repeatedly violate these principles or engage
+  in harassment.
+- **Reporting:** If you feel you are being harassed or see behavior that is damaging the community, please reach out
+  privately to @daveallie.
@@ -45,11 +45,13 @@ Multi-language support: Read EPUBs in various languages, including English, Span

 See [the user guide](./USER_GUIDE.md) for instructions on operating CrossPoint. 

+For more details about the scope of the project, see the [SCOPE.md](SCOPE.md) document.
+
 ## Installing

 ### Web (latest firmware)

-1. Connect your Xteink X4 to your computer via USB-C
+1. Connect your Xteink X4 to your computer via USB-C and wake/unlock the device
 2. Go to https://xteink.dve.al/ and click "Flash CrossPoint firmware"

 To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
@@ -58,7 +60,7 @@ back to the other partition using the "Swap boot partition" button here https://
 ### Web (specific firmware version)

 1. Connect your Xteink X4 to your computer via USB-C
-2. Download the `firmware.bin` file from the release of your choice via the [releases page](https://github.com/daveallie/crosspoint-reader/releases)
+2. Download the `firmware.bin` file from the release of your choice via the [releases page](https://github.com/crosspoint-reader/crosspoint-reader/releases)
 3. Go to https://xteink.dve.al/ and flash the firmware file using the "OTA fast flash controls" section

 To revert back to the official firmware, you can flash the latest official firmware from https://xteink.dve.al/, or swap
@@ -82,7 +84,7 @@ See [Development](#development) below.
 CrossPoint uses PlatformIO for building and flashing the firmware. To get started, clone the repository:

 ```
-git clone --recursive https://github.com/daveallie/crosspoint-reader
+git clone --recursive https://github.com/crosspoint-reader/crosspoint-reader

 # Or, if you've already cloned without --recursive:
 git submodule update --init --recursive
@@ -95,6 +97,25 @@ Connect your Xteink X4 to your computer via USB-C and run the following command.
 ```sh
 pio run --target upload
 ```
+### Debugging
+
+After flashing the new features, it’s recommended to capture detailed logs from the serial port.
+
+First, make sure all required Python packages are installed:
+
+```python
+python3 -m pip install pyserial colorama matplotlib
+```
+after that run the script:
+```sh
+# For Linux
+# This was tested on Debian and should work on most Linux systems.
+python3 scripts/debugging_monitor.py
+
+# For macOS
+python3 scripts/debugging_monitor.py /dev/cu.usbmodem2101
+```
+Minor adjustments may be required for Windows.

 ## Internals

@@ -133,9 +154,12 @@ For more details on the internal file structures, see the [file formats document

 Contributions are very welcome!

-If you're looking for a way to help out, take a look at the [ideas discussion board](https://github.com/daveallie/crosspoint-reader/discussions/categories/ideas).
+If you're looking for a way to help out, take a look at the [ideas discussion board](https://github.com/crosspoint-reader/crosspoint-reader/discussions/categories/ideas).
 If there's something there you'd like to work on, leave a comment so that we can avoid duplicated effort.

+Everyone here is a volunteer, so please be respectful and patient. For more details on our goverance and community 
+principles, please see [GOVERNANCE.md](GOVERNANCE.md).
+
 ### To submit a contribution:

 1. Fork the repo
@@ -0,0 +1,50 @@
+# Project Vision & Scope: CrossPoint Reader
+
+The goal of CrossPoint Reader is to create an efficient, open-source reading experience for the Xteink X4. We believe a
+dedicated e-reader should do one thing exceptionally well: **facilitate focused reading.**
+
+## 1. Core Mission
+
+To provide a lightweight, high-performance firmware that maximizes the potential of the X4, prioritizing legibility and
+usability over "swiss-army-knife" functionality.
+
+## 2. Scope
+
+### In-Scope
+
+*These are features that directly improve the primary purpose of the device.*
+
+* **User Experience:** E.g. User-friendly interfaces, and interactions, both inside the reader and navigating the
+  firmware. This includes things like button mapping, book loading, and book navigation like bookmarks.
+* **Document Rendering:** E.g. Support for rendering documents (primarily EPUB) and improvements to the rendering
+  engine.
+* **Format Optimization:** E.g. Efficiently parsing EPUB (CSS/Images) and other documents within the device's
+  capabilities.
+* **Typography & Legibility:** E.g. Custom font support, hyphenation engines, and adjustable line spacing.
+* **E-Ink Driver Refinement:** E.g. Reducing full-screen flashes (ghosting management) and improving general rendering.
+* **Library Management:** E.g. Simple, intuitive ways to organize and navigate a collection of books.
+* **Local Transfer:** E.g. Simple, "pull" based book loading via a basic web-server or public and widely-used standards.
+* **Language Support:** E.g. Support for multiple languages both in the reader and in the interfaces.
+* **Reference Tools:** E.g. Local dictionary lookup. Providing quick, offline definitions to enhance comprehension 
+  without breaking focus.
+
+### Out-of-Scope
+
+*These items are rejected because they compromise the device's stability or mission.*
+
+* **Interactive Apps:** No Notepads, Calculators, or Games. This is a reader, not a PDA.
+* **Active Connectivity:** No RSS readers, News aggregators, or Web browsers. Background Wi-Fi tasks drain the battery
+  and complicate the single-core CPU's execution.
+* **Media Playback:** No Audio players or Audio-books.
+* **Complex Annotation:** No typed out notes. These features are better suited for devices with better input
+  capabilities and more powerful chips.
+
+## 3. Idea Evaluation
+
+While I appreciate the desire to add new and exciting features to CrossPoint Reader, CrossPoint Reader is designed to be
+a lightweight, reliable, and performant e-reader. Things which distract or compromise the device's core mission will not
+be accepted. As a guiding question, consider if your idea improve the "core reading experience" for the average user,
+and, critically, not distract from that reading experience.
+
+> **Note to Contributors:** If you are unsure if your idea fits the scope, please open a **Discussion** before you start
+> coding!
@@ -13,14 +13,17 @@ Welcome to the **CrossPoint** firmware. This guide outlines the hardware control
    - [3.2 Book Selection](#32-book-selection)
    - [3.3 Reading Mode](#33-reading-mode)
    - [3.4 File Upload Screen](#34-file-upload-screen)
+    - [3.4.1 Calibre Wireless Transfers](#341-calibre-wireless-transfers)
    - [3.5 Settings](#35-settings)
    - [3.6 Sleep Screen](#36-sleep-screen)
  - [4. Reading Mode](#4-reading-mode)
    - [Page Turning](#page-turning)
    - [Chapter Navigation](#chapter-navigation)
    - [System Navigation](#system-navigation)
+    - [Supported Languages](#supported-languages)
  - [5. Chapter Selection Screen](#5-chapter-selection-screen)
  - [6. Current Limitations \& Roadmap](#6-current-limitations--roadmap)
+  - [7. Troubleshooting Issues \& Escaping Bootloop](#7-troubleshooting-issues--escaping-bootloop)


 ## 1. Hardware Overview
@@ -102,6 +105,7 @@ The Settings screen allows you to configure the device's behavior. There are a f
  - "Custom" - Custom images from the SD card; see [Sleep Screen](#36-sleep-screen) below for more information
  - "Cover" - The book cover image (Note: this is experimental and may not work as expected)
  - "None" - A blank screen
+  - "Cover + Custom" - The book cover image, fallbacks to "Custom" behavior
 - **Sleep Screen Cover Mode**: How to display the book cover when "Cover" sleep screen is selected:
  - "Fit" (default) - Scale the image down to fit centered on the screen, padding with white borders as necessary
  - "Crop" - Scale the image down and crop as necessary to try to to fill the screen (Note: this is experimental and may not work as expected)
@@ -112,7 +116,10 @@ The Settings screen allows you to configure the device's behavior. There are a f
 - **Status Bar**: Configure the status bar displayed while reading:
  - "None" - No status bar
  - "No Progress" - Show status bar without reading progress
-  - "Full" - Show status bar with reading progress
+  - "Full w/ Percentage" - Show status bar with book progress (as percentage)
+  - "Full w/ Book Bar" - Show status bar with book progress (as bar)
+  - "Book Bar Only" - Show book progress (as bar)
+  - "Full w/ Chapter Bar" - Show status bar with chapter progress (as bar)
 - **Hide Battery %**: Configure where to suppress the battery pecentage display in the status bar; the battery icon will still be shown:
  - "Never" - Always show battery percentage (default)
  - "In Reader" - Show battery percentage everywhere except in reading mode
@@ -148,6 +155,9 @@ The Settings screen allows you to configure the device's behavior. There are a f
 - **Reader Paragraph Alignment**: Set the alignment of paragraphs; options are "Justified" (default), "Left", "Center", or "Right".
 - **Time to Sleep**: Set the duration of inactivity before the device automatically goes to sleep.
 - **Refresh Frequency**: Set how often the screen does a full refresh while reading to reduce ghosting.
+- **Sunlight Fading Fix**: Configure whether to enable a software-fix for the issue where white X4 models may fade when used in direct sunlight
+  - "OFF" (default) - Disable the fix
+  - "ON" - Enable the fix
 - **OPDS Browser**: Configure OPDS server settings for browsing and downloading books. Set the server URL (for Calibre Content Server, add `/opds` to the end), and optionally configure username and password for servers requiring authentication. Note: Only HTTP Basic authentication is supported. If using Calibre Content Server with authentication enabled, you must set it to use Basic authentication instead of the default Digest authentication.
 - **Check for updates**: Check for firmware updates over WiFi.

@@ -201,7 +211,7 @@ CrossPoint renders text using the following Unicode character blocks, enabling s
 *   **Latin Script (Basic, Supplement, Extended-A):** Covers English, German, French, Spanish, Portuguese, Italian, Dutch, Swedish, Norwegian, Danish, Finnish, Polish, Czech, Hungarian, Romanian, Slovak, Slovenian, Turkish, and others.
 *   **Cyrillic Script (Standard and Extended):** Covers Russian, Ukrainian, Belarusian, Bulgarian, Serbian, Macedonian, Kazakh, Kyrgyz, Mongolian, and others.

-What is not supported: Chinese, Japanese, Korean, Vietnamese, Hebrew, Arabic and Farsi.
+What is not supported: Chinese, Japanese, Korean, Vietnamese, Hebrew, Arabic, Greek and Farsi.

 ---

@@ -220,3 +230,18 @@ Accessible by pressing **Confirm** while inside a book.
 Please note that this firmware is currently in active development. The following features are **not yet supported** but are planned for future updates:

 * **Images:** Embedded images in e-books will not render.
+* **Cover Images:** Large cover images embedded into EPUB require several seconds (~10s for ~2000 pixel tall image) to convert for sleep screen and home screen thumbnail. Consider optimizing the EPUB with e.g. https://github.com/bigbag/epub-to-xtc-converter to speed this up.
+
+---
+
+## 7. Troubleshooting Issues & Escaping Bootloop
+
+If an issue or crash is encountered while using Crosspoint, feel free to raise an issue ticket and attach the serial monitor logs. The logs can be obtained by connecting the device to a computer and starting a serial monitor. Either [Serial Monitor](https://www.serialmonitor.org/) or the following command can be used:
+
+```
+pio device monitor
+```
+
+If the device is stuck in a bootloop, press and release the Reset button. Then, press and hold on to the configured Back button and the Power Button to boot to the Home Screen.
+
+There can be issues with broken cache or config. In this case, delete the `.crosspoint` directory on your SD card (or consider deleting only `settings.bin`, `state.bin`, or `epub_*` cache directories in the `.crosspoint/` folder).
@@ -1,10 +1,18 @@
-#!/bin/bash
+#!/usr/bin/env bash
+
+# Check if clang-format is availible
+command -v clang-format >/dev/null 2>&1 || {
+    printf "'clang-format' not found in current environment\n"
+    printf "install 'clang', 'clang-tools', or 'clang-format' depending on your distro/os and tooling requirements\n"
+    exit 1
+}

 GIT_LS_FILES_FLAGS=""
 if [[ "$1" == "-g" ]]; then
  GIT_LS_FILES_FLAGS="--modified"
 fi

+
 # --- Main Logic ---

 # Format all files (or only modified files if -g is passed)
@@ -13,8 +21,10 @@ fi
 # --modified: files tracked by git that have been modified (staged or unstaged)
 # --exclude-standard: ignores files in .gitignore
 # Additionally exclude files in 'lib/EpdFont/builtinFonts/' as they are script-generated.
+# Also exclude files in 'lib/Epub/Epub/hyphenation/generated/' as they are script-generated.
 git ls-files  --exclude-standard ${GIT_LS_FILES_FLAGS} \
    | grep -E '\.(c|cpp|h|hpp)$' \
-    | grep -v -E '^lib/CrossPointFont/builtinFonts/' \
-    | grep -v -E '^lib/CrossPointFont/Group5' \
+    | grep -v -E '^lib/EpdFont/builtinFonts/' \
+    | grep -v -E '^lib/Epub/Epub/hyphenation/generated/' \
+    | grep -v -E '^lib/uzlib/' \
    | xargs -r clang-format -style=file -i
@@ -45,22 +45,9 @@ byte arrays, and emits headers under
 `SerializedHyphenationPatterns` descriptor so the reader can keep the automaton
 in flash.

-To refresh the firmware assets after updating the `.bin` files, run:
+A convenient script `update_hyphenation.sh` is used to update all languages.
+To use it, run:

-```
-./scripts/generate_hyphenation_trie.py \
-    --input lib/Epub/Epub/hyphenation/tries/en.bin \
-    --output lib/Epub/Epub/hyphenation/generated/hyph-en.trie.h
-
-./scripts/generate_hyphenation_trie.py \
-    --input lib/Epub/Epub/hyphenation/tries/fr.bin \
-    --output lib/Epub/Epub/hyphenation/generated/hyph-fr.trie.h
-
-./scripts/generate_hyphenation_trie.py \
-    --input lib/Epub/Epub/hyphenation/tries/de.bin \
-    --output lib/Epub/Epub/hyphenation/generated/hyph-de.trie.h
-
-./scripts/generate_hyphenation_trie.py \
-    --input lib/Epub/Epub/hyphenation/tries/ru.bin \
-    --output lib/Epub/Epub/hyphenation/generated/hyph-ru.trie.h
+```sh
+./scripts/update_hypenation.sh
 ```
@@ -0,0 +1,237 @@
+# Internationalization (I18N)
+
+This guide explains the multi-language support system in CrossPoint Reader.
+
+## Supported Languages
+
+- English
+- French
+- German
+- Portuguese
+- Spanish
+- Swedish
+- Czech
+- Russian
+
+---
+
+
+## For Developers
+
+### Translation System Architecture
+
+The I18N system uses **per-language YAML files** to maintain translations and a Python script to generate C++ code:
+
+```
+lib/I18n/
+├── translations/                # One YAML file per language
+│   ├── english.yaml
+│   ├── spanish.yaml
+│   ├── french.yaml
+│   └── ...
+├── I18n.h
+├── I18n.cpp
+├── I18nKeys.h                   # Enums (auto-generated)
+├── I18nStrings.h                # String array declarations (auto-generated)
+└── I18nStrings.cpp              # String array definitions (auto-generated)
+
+scripts/
+└── gen_i18n.py                  # Code generator script
+```
+
+**Key principle:** All translations are managed in the YAML files under `lib/I18n/translations/`. The Python script generates the necessary C++ code automatically.
+
+---
+
+### YAML File Format
+
+Each language has its own file in `lib/I18n/translations/` (e.g. `spanish.yaml`).
+
+A file looks like this:
+
+```yaml
+_language_name: "Español"
+_language_code: "SPANISH"
+_order: "1"
+
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "BOOTING"
+STR_BROWSE_FILES: "Buscar archivos"
+```
+
+**Metadata keys** (prefixed with `_`):
+- `_language_name` — Native display name shown to the user (e.g. "Français")
+- `_language_code` — C++ enum name (e.g. "FRENCH"). Must be a valid C++ identifier.
+- `_order` — Controls the position in the Language enum (English is always 0)
+
+**Rules:**
+- Use UTF-8 encoding
+- Every line must follow the format: `KEY: "value"`
+- Keys must be valid C++ identifiers (uppercase, strats with STR_)
+- Keys must be unique within a file
+- String values must be quoted
+- Use `\n` for newlines, `\\` for literal backslashes, `\"` for literal quotes inside values
+
+---
+
+### Adding New Strings
+
+To add a new translatable string:
+
+#### 1. Edit the English YAML file
+
+Add the key to `lib/I18n/translations/english.yaml`:
+
+```yaml
+STR_MY_NEW_STRING: "My New String"
+```
+
+Then add translations in each language file. If a key is missing from a
+language file, the generator will automatically use the English text as a
+fallback (and print a warning).
+
+#### 2. Run the generator script
+
+```bash
+python3 scripts/gen_i18n.py lib/I18n/translations lib/I18n/
+```
+
+This automatically:
+- Fills missing translations from English
+- Updates the `StrId` enum in `I18nKeys.h`
+- Regenerates all language arrays in `I18nStrings.cpp`
+
+#### 3. Use in code
+
+```cpp
+#include <I18n.h>
+
+// Using the tr() macro (recommended)
+renderer.drawText(font, x, y, tr(STR_MY_NEW_STRING));
+
+// Using I18N.get() directly
+const char* text = I18N.get(StrId::STR_MY_NEW_STRING);
+```
+
+**That's it!** No manual array synchronization needed.
+
+---
+
+### Adding a New Language
+
+To add support for a new language (e.g., Italian):
+
+#### 1. Create a new YAML file
+
+Create `lib/I18n/translations/italian.yaml`:
+
+```yaml
+_language_name: "Italiano"
+_language_code: "ITALIAN"
+_order: "7"
+
+STR_CROSSPOINT: "CrossPoint"
+STR_BOOTING: "AVVIO"
+```
+
+You only need to include the strings you have translations for. Missing
+keys will fall back to English automatically.
+
+#### 2. Run the generator
+
+```bash
+python3 scripts/gen_i18n.py lib/I18n/translations lib/I18n/
+```
+
+This automatically updates all necessary code.
+
+---
+
+### Modifying Existing Translations
+
+Simply edit the relevant YAML file and regenerate:
+
+```bash
+python3 scripts/gen_i18n.py lib/I18n/translations lib/I18n/
+```
+
+---
+
+### UTF-8 Encoding
+
+The YAML files use UTF-8 encoding. Special characters are automatically converted to C++ UTF-8 hex sequences by the generator.
+
+---
+
+### I18N API Reference
+
+```cpp
+// === Convenience Macros (Recommended) ===
+
+// tr(id) - Get translated string without StrId:: prefix
+const char* text = tr(STR_SETTINGS_TITLE);
+renderer.drawText(font, x, y, tr(STR_BROWSE_FILES));
+Serial.printf("Status: %s\n", tr(STR_CONNECTED));
+
+// I18N - Shorthand for I18n::getInstance()
+I18N.setLanguage(Language::SPANISH);
+Language lang = I18N.getLanguage();
+
+// === Full API ===
+
+// Get the singleton instance
+I18n& instance = I18n::getInstance();
+
+// Get translated string (three equivalent ways)
+const char* text = tr(STR_SETTINGS_TITLE);              // Macro (recommended)
+const char* text = I18N.get(StrId::STR_SETTINGS_TITLE);   // Direct call
+const char* text = I18N[StrId::STR_SETTINGS_TITLE];       // Operator overload
+
+// Set language
+I18N.setLanguage(Language::SPANISH);
+
+// Get current language
+Language lang = I18N.getLanguage();
+
+// Save language setting to file
+I18N.saveSettings();
+
+// Load language setting from file
+I18N.loadSettings();
+
+// Get character set for font subsetting (static method)
+const char* chars = I18n::getCharacterSet(Language::FRENCH);
+```
+
+---
+
+## File Storage
+
+Language settings are stored in:
+```
+/.crosspoint/language.bin
+```
+
+This file contains:
+- Version byte
+- Current language selection (1 byte)
+
+---
+
+## Translation Workflow
+
+### For Developers (Adding Features)
+
+1. Add new strings to `lib/I18n/translations/english.yaml`
+2. Run `python3 scripts/gen_i18n.py lib/I18n/translations lib/I18n/`
+3. Use the new `StrId` in your code
+4. Request translations from translators
+
+### For Translators
+
+1. Open the YAML file for your language in `lib/I18n/translations/`
+2. Add or update translations using the format `STR_KEY: "translated text"`
+3. Keep translations concise (E-ink space constraints)
+4. Make sure the file is in UTF-8 encoding
+5. Run `python3 scripts/gen_i18n.py lib/I18n/translations lib/I18n/` to verify
+6. Test on device or submit for review
@@ -0,0 +1,36 @@
+# Translators
+
+Below is a list of users and languages CrossPoint may support in the future. 
+Note because a language is below does not mean there is official support for the language at this time.
+
+## Contributing
+
+If you'd like to add your name to this list, please open a PR adding yourself and your Github link. Thank you!
+
+## French
+- [Spigaw](https://github.com/Spigaw)
+- [CaptainFrito](https://github.com/CaptainFrito)
+
+## German
+- [DavidOrtmann](https://github.com/DavidOrtmann)
+
+## Czech
+- [brbla](https://github.com/brbla)
+
+## Portuguese (Brazil)
+- [yagofarias](https://github.com/yagofarias)
+
+## Italian
+- [fragolinux](https://github.com/fragolinux)
+
+## Russian
+- [madebyKir](https://github.com/madebyKir)
+- [mrtnvgr](https://github.com/mrtnvgr)
+
+## Spanish
+- [yeyeto2788](https://github.com/yeyeto2788)
+- [Skrzakk](https://github.com/Skrzakk)
+- [pablohc](https://github.com/pablohc)
+
+## Swedish
+- [dawiik](https://github.com/dawiik)
@@ -1,14 +1,14 @@
 # Web Server Guide

-This guide explains how to connect your CrossPoint Reader to WiFi and use the built-in web server to upload EPUB files from your computer or phone.
+This guide explains how to connect your CrossPoint Reader to WiFi and use the built-in web server to upload files from your computer or phone.

 ## Overview

 CrossPoint Reader includes a built-in web server that allows you to:

- Upload EPUB files wirelessly from any device on the same WiFi network
+- Upload files wirelessly from any device on the same WiFi network
 - Browse and manage files on your device's SD card
- Create folders to organize your ebooks
+- Create folders to organize your library
 - Delete files and folders

 ## Prerequisites
@@ -129,34 +129,31 @@ Click **File Manager** to access file management features.
 #### Browsing Files

 - The file manager displays all files and folders on your SD card
- **Folders** are highlighted in yellow with a 📁 icon
- **EPUB files** are highlighted in green with a 📗 icon
+- **Folders** are highlighted in yellow and indicated with a 📁 icon
+- **EPUB Files** are highlighted in green and indicated with a 📗 icon
+- **All Other Files** are not highlighted and indicated with a 📄 icon
 - Click on a folder name to navigate into it
 - Use the breadcrumb navigation at the top to go back to parent folders

 <img src="./images/wifi/webserver_files.png" width="600">

-#### Uploading EPUB Files
+#### Uploading Files

-1. Click the **+ Add** button in the top-right corner
-2. Select **Upload eBook** from the dropdown menu
-3. Click **Choose File** and select an `.epub` file from your device
-4. Click **Upload**
-5. A progress bar will show the upload status
-6. The page will automatically refresh when the upload is complete
-
-**Note:** Only `.epub` files are accepted. Other file types will be rejected.
+1. Click the **📤 Upload** button in the top-right corner
+2. Click **Choose File** and select a file from your device
+3. Click **Upload**
+4. A progress bar will show the upload status
+5. The page will automatically refresh when the upload is complete

 <img src="./images/wifi/webserver_upload.png" width="600">

 #### Creating Folders

-1. Click the **+ Add** button in the top-right corner
-2. Select **New Folder** from the dropdown menu
-3. Enter a folder name (letters, numbers, underscores, and hyphens only)
-4. Click **Create Folder**
+1. Click the **📁 New Folder** button in the top-right corner
+2. Enter a folder name (must not contain characters \" * : < > ? / \\ | and must not be . or ..)
+3. Click **Create Folder**

-This is useful for organizing your ebooks by genre, author, or series.
+This is useful for organizing your library by genre, author, series or file type.

 #### Deleting Files and Folders

@@ -168,11 +165,25 @@ This is useful for organizing your ebooks by genre, author, or series.

 **Note:** Folders must be empty before they can be deleted.

+#### Moving Files
+
+1. Click the **📂** (folder) icon next to any file
+2. Enter a folder name or select one from the dropdown
+3. Click **Move** to relocate the file
+
+**Note:** Typing in a nonexistent folder name will result in the following error: "Failed to move: Destination not found"
+
+#### Renaming Files
+
+1. Click the **✏️** (pencil) icon next to any file
+2. Enter a file name (must not contain characters \" * : < > ? / \\ | and must not be . or ..)
+3. Click **Rename** to permanently rename the file
+
 ---

 ## Command Line File Management

-For power users, you can manage files directly from your terminal using `curl` while the device is in File Upload mode a detailed documentation can be found [here](./webserver-endpoints.md). 
+For power users, you can manage files directly from your terminal using `curl` while the device is in File Upload mode. Detailed documentation can be found [here](./webserver-endpoints.md). 

 ## Security Notes

@@ -189,7 +200,6 @@ For power users, you can manage files directly from your terminal using `curl` w
 - **Supported WiFi:** 2.4GHz networks (802.11 b/g/n)
 - **Web Server Port:** 80 (HTTP)
 - **Maximum Upload Size:** Limited by available SD card space
- **Supported File Format:** `.epub` only
 - **Browser Compatibility:** All modern browsers (Chrome, Firefox, Safari, Edge)

 ---
@@ -198,7 +208,7 @@ For power users, you can manage files directly from your terminal using `curl` w

 1. **Organize with folders** - Create folders before uploading to keep your library organized
 2. **Check signal strength** - Stronger signals (`|||` or `||||`) provide faster, more reliable uploads
-3. **Upload multiple files** - You can upload files one at a time; the page refreshes after each upload
+3. **Upload multiple files** - You can select and upload multiple files at once; the manager will queue them and refresh when the batch is finished
 4. **Use descriptive names** - Name your folders clearly (e.g., "SciFi", "Mystery", "Non-Fiction")
 5. **Keep credentials saved** - Save your WiFi password for quick reconnection in the future
 6. **Exit when done** - Press **Back** to exit the WiFi screen and save battery
@@ -1,147 +0,0 @@
-#include "CrossPointFont.h"
-
-#include <Utf8.h>
-
-#include <algorithm>
-#include <cmath>
-
-#define FONT_SCALE 2
-
-namespace {
-// Number of set bits from 0->15
-uint8_t bitCount[] = {
-    0,  // 0b0000,
-    1,  // 0b0001,
-    1,  // 0b0010,
-    2,  // 0b0011,
-    1,  // 0b0100,
-    2,  // 0b0101,
-    2,  // 0b0110,
-    3,  // 0b0111,
-    1,  // 0b1000,
-    2,  // 0b1001,
-    2,  // 0b1010,
-    3,  // 0b1011,
-    2,  // 0b1100,
-    3,  // 0b1101,
-    3,  // 0b1110,
-    4,  // 0b1111,
-};
-}  // namespace
-
-void CrossPointFont::getTextBounds(const char* string, const Style style, const int startX, const int startY, int* minX,
-                                   int* minY, int* maxX, int* maxY) const {
-  *minX = startX;
-  *minY = startY;
-  *maxX = startX;
-  *maxY = startY;
-
-  if (*string == '\0') {
-    return;
-  }
-
-  int cursorX = startX;
-  const int cursorY = startY;
-  uint32_t cp;
-  while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&string)))) {
-    const CrossPointFontGlyph* glyph = getGlyph(cp, style);
-
-    if (!glyph) {
-      glyph = getGlyph(REPLACEMENT_GLYPH, style);
-    }
-
-    if (!glyph) {
-      // TODO: Better handle this?
-      continue;
-    }
-
-    *minX = std::min(*minX, cursorX + glyph->xOffset / FONT_SCALE);
-    *maxX = std::max(*maxX, cursorX + (glyph->xOffset + glyph->width) / FONT_SCALE);
-    *minY = std::min(*minY, cursorY + (glyph->yOffset - glyph->height) / FONT_SCALE);
-    *maxY = std::max(*maxY, cursorY + glyph->yOffset / FONT_SCALE);
-    cursorX += glyph->xAdvance / FONT_SCALE;
-  }
-}
-
-void CrossPointFont::getTextDimensions(const char* string, const Style style, int* w, int* h) const {
-  int minX = 0, minY = 0, maxX = 0, maxY = 0;
-
-  getTextBounds(string, style, 0, 0, &minX, &minY, &maxX, &maxY);
-
-  *w = maxX - minX;
-  *h = maxY - minY;
-}
-
-uint8_t CrossPointFont::styleGroup(const Style style) const {
-  if (style == REGULAR) return 0;
-
-  if (data.header.styles == 0b0001) {
-    // Only have regular font, show regular
-    return 0;
-  }
-  if (data.header.styles == 0b0011) {
-    // Only have bold and regular font
-    // Show bold if style is bold or bold_italic
-    return style == BOLD || style == BOLD_ITALIC ? 1 : 0;
-  }
-  if (data.header.styles == 0b0101) {
-    // Only have italic and regular font
-    // Show italic if style is italic or bold_italic
-    return style == ITALIC || style == BOLD_ITALIC ? 1 : 0;
-  }
-  if (data.header.styles == 0b1001) {
-    // Only have bold_italic and regular font
-    // Show bold_italic if style is any non-regular
-    return style == BOLD_ITALIC || style == BOLD || style == ITALIC ? 1 : 0;
-  }
-  if (data.header.styles == 0b0111) {
-    // Have all but bold_italic
-    // Show bold if style is bold_italic, otherwise show the requested style
-    return style == BOLD_ITALIC ? 1 : style;
-  }
-  if (data.header.styles == 0b1011) {
-    // Have all but italic
-    // Show bold_italic if style is italic, otherwise show the requested style
-    return style == ITALIC ? 2 : style;
-  }
-  if (data.header.styles == 0b1101) {
-    // Have all but bold
-    // Show bold_italic if style is bold, otherwise show the requested style
-    return style == BOLD ? 2 : style;
-  }
-  if (data.header.styles == 0b1111) {
-    return style;
-  }
-
-  return 0;
-}
-
-const CrossPointFontGlyph* CrossPointFont::getGlyph(const uint32_t cp, const Style style) const {
-  const CrossPointFontUnicodeInterval* intervals = data.intervals;
-  const int count = data.header.intervalCount;
-
-  if (count == 0) return nullptr;
-
-  // Binary search for O(log n) lookup instead of O(n)
-  // Critical for Korean fonts with many unicode intervals
-  int left = 0;
-  int right = count - 1;
-
-  while (left <= right) {
-    const int mid = left + (right - left) / 2;
-    const CrossPointFontUnicodeInterval* interval = &intervals[mid];
-
-    if (cp < interval->first) {
-      right = mid - 1;
-    } else if (cp > interval->last) {
-      left = mid + 1;
-    } else {
-      // Found: cp >= interval->first && cp <= interval->last
-      const uint32_t index =
-          interval->offset + (cp - interval->first) * bitCount[data.header.styles] + styleGroup(style);
-      return &data.glyphs[index];
-    }
-  }
-
-  return nullptr;
-}
@@ -1,31 +0,0 @@
-#pragma once
-
-#include <cstdint>
-
-#include "CrossPointFontFormat.h"
-#include "Group5/Group5.h"
-
-class CrossPointFont {
- public:
-  enum Style : uint8_t { REGULAR = 0, BOLD = 1, ITALIC = 2, BOLD_ITALIC = 3 };
-
-  CrossPointFontData data;
-  explicit CrossPointFont(void* rawData) {
-    data.header = *static_cast<CrossPointFontHeader*>(rawData);
-    data.intervals = (CrossPointFontUnicodeInterval*)(static_cast<uint8_t*>(rawData) + sizeof(CrossPointFontHeader));
-    data.glyphs = (CrossPointFontGlyph*)((uint8_t*)data.intervals +
-                                         sizeof(CrossPointFontUnicodeInterval) * data.header.intervalCount);
-    data.bitmap = (uint8_t*)data.glyphs + sizeof(CrossPointFontGlyph) * data.header.glyphCount;
-  }
-
-  ~CrossPointFont() = default;
-  void getTextDimensions(const char* string, Style style, int* w, int* h) const;
-  const CrossPointFontGlyph* getGlyph(uint32_t cp, Style style) const;
-
- private:
-  void getTextBounds(const char* string, Style style, int startX, int startY, int* minX, int* minY, int* maxX,
-                     int* maxY) const;
-  uint8_t styleGroup(Style style) const;
-};
-
-// TODO: CrossPointFontSmall
@@ -1,57 +0,0 @@
-#pragma once
-
-// 16-bit marker at the start of a CrossPoint font file
-// (CrossPoint Font Format)
-#define CPF_FONT_MARKER 0xCFF1
-#define CPF_FONT_MARKER_SMALL 0xCFF2
-
-// Font info per large character (glyph)
-typedef struct {
-  uint32_t bitmapOffset;  /// Offset to compressed bitmap data for this glyph
-  uint16_t width;         /// bitmap width in pixels
-  uint16_t height;        /// bitmap height in pixels
-  uint16_t xAdvance;      /// total width in pixels (bitmap + padding)
-  int16_t xOffset;        /// left padding to upper left corner
-  int16_t yOffset;        /// top padding to upper left corner
-} CrossPointFontGlyph;
-
-// Font info per small character (glyph)
-typedef struct {
-  uint32_t bitmapOffset;  /// Offset to compressed bitmap data for this glyph
-  uint8_t width;          /// bitmap width in pixels
-  uint8_t height;         /// bitmap height in pixels
-  uint8_t xAdvance;       /// total width in pixels (bitmap + padding)
-  int8_t xOffset;         /// left padding to upper left corner
-  int16_t yOffset;        /// top padding to upper left corner
-} CrossPointFontSmallGlyph;
-
-/// Glyph interval structure
-typedef struct {
-  uint32_t first;   /// The first unicode code point of the interval
-  uint32_t last;    /// The last unicode code point of the interval
-  uint32_t offset;  /// Index of the first code point into the glyph array
-} CrossPointFontUnicodeInterval;
-
-typedef struct {
-  uint16_t u16Marker;      /// CPF_FONT_MARKER / CPF_FONT_MARKER_SMALL
-  uint16_t height;         /// Newline distance (y axis)
-  uint16_t ascender;       /// Maximal height of a glyph above the base line
-  uint8_t styles;          /// Regular = 0x01, Bold = 0x02, Italic = 0x04, BoldItalic = 0x08, can be OR'd together
-  uint16_t intervalCount;  /// Number of unicode intervals.
-  uint32_t glyphCount;     /// Number of total glyphs across all styles
-} CrossPointFontHeader;
-
-/// Data stored for FONT AS A WHOLE
-typedef struct {
-  CrossPointFontHeader header;
-  CrossPointFontUnicodeInterval* intervals;  /// Valid unicode intervals for this font
-  CrossPointFontGlyph* glyphs;               /// Glyph array
-  uint8_t* bitmap;                           /// Glyph bitmaps, concatenated
-} CrossPointFontData;
-
-typedef struct {
-  CrossPointFontHeader header;
-  CrossPointFontUnicodeInterval* intervals;  /// Valid unicode intervals for this font
-  CrossPointFontSmallGlyph* glyphs;          /// Glyph array
-  uint8_t* bitmap;                           /// Glyph bitmaps, concatenated
-} CrossPointFontDataSmall;
@@ -1,51 +0,0 @@
-#include "g5enc.inl"
-#include "g5dec.inl"
-//
-// Group5 1-bit image compression library
-// Written by Larry Bank (bitbank@pobox.com)
-// Decoder C++ wrapper functions
-//
-// SPDX-FileCopyrightText: 2024 BitBank Software, Inc.
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-int G5DECODER::init(int iWidth, int iHeight, uint8_t *pData, int iDataSize)
-{
-    return g5_decode_init(&_g5dec, iWidth, iHeight, pData, iDataSize);
-} /* init() */
-
-int G5DECODER::decodeLine(uint8_t *pOut)
-{
-    return g5_decode_line(&_g5dec, pOut);
-} /* decodeLine() */
-
-//
-// Encoder C++ wrapper functions
-//
-int G5ENCODER::init(int iWidth, int iHeight, uint8_t *pOut, int iOutSize)
-{
-    return g5_encode_init(&_g5enc, iWidth, iHeight, pOut, iOutSize);
-} /* init() */
-
-int G5ENCODER::encodeLine(uint8_t *pPixels)
-{
-    return g5_encode_encodeLine(&_g5enc, pPixels);
-} /* encodeLine() */
-
-int G5ENCODER::size()
-{
-    return g5_encode_getOutSize(&_g5enc);
-} /* size() */
-
@@ -1,171 +0,0 @@
-#ifndef __GROUP5__
-#define __GROUP5__
-#include <stdlib.h>
-#include <string.h>
-#include <stdint.h>
-#include <stdio.h>
-#ifdef __AVR__
-#include <avr/pgmspace.h>
-#endif
-//
-// Group5 1-bit image compression library
-// Written by Larry Bank (bitbank@pobox.com)
-//
-// SPDX-FileCopyrightText: 2024 BitBank Software, Inc.
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-// The name "Group5" is derived from the CCITT Group4 standard
-// This code is based on a lot of the good ideas from CCITT T.6
-// for FAX image compression, but modified to work in a very
-// constrained environment. The Huffman tables for horizontal
-// mode have been replaced with a simple 2-bit flag followed by
-// short or long counts of a fixed length. The short codes are
-// always 3 bits (run lengths 0-7) and the long codes are the
-// number of bits needed to encode the width of the image.
-// For example, if a 320 pixel wide image is being compressed,
-// the longest horizontal run needed is 320, which requires 9
-// bits to encode. The 2 prefix bits have the following meaning:
-// 00 = short, short (3+3 bits)
-// 01 = short, long (3+N bits)
-// 10 = long, short (N+3 bits)
-// 11 = long, long (N+N bits)
-// The rest of the code works identically to Group4 2D FAX
-//
-// Caution - this is the maximum number of color changes per line
-// The default value is set low to work embedded systems with little RAM
-// for font compression, this is plenty since each line of a character should have
-// a maximum of 7 color changes
-// You can define this in your compiler macros to override the default vlaue
-//
-#ifndef MAX_IMAGE_FLIPS
-#ifdef __AVR__
-#define MAX_IMAGE_FLIPS 32
-#else
-#define MAX_IMAGE_FLIPS 512
-#endif // __AVR__
-#endif
-// Horizontal prefix bits
-enum {
-    HORIZ_SHORT_SHORT=0,
-    HORIZ_SHORT_LONG,
-    HORIZ_LONG_SHORT,
-    HORIZ_LONG_LONG
-};
-
-// Return code for encoder and decoder
-enum {
-    G5_SUCCESS = 0,
-    G5_INVALID_PARAMETER,
-    G5_DECODE_ERROR,
-    G5_UNSUPPORTED_FEATURE,
-    G5_ENCODE_COMPLETE,
-    G5_DECODE_COMPLETE,
-    G5_NOT_INITIALIZED,
-    G5_DATA_OVERFLOW,
-    G5_MAX_FLIPS_EXCEEDED
-};
-//
-// Decoder state
-//
-typedef struct g5_dec_image_tag
-{
-    int iWidth, iHeight; // image size
-    int iError;
-    int y; // last y value drawn
-    int iVLCSize;
-    int iHLen; // length of 'long' horizontal codes for this image
-    int iPitch; // width in bytes of output buffer
-    uint32_t u32Accum; // fractional scaling accumulator
-    uint32_t ulBitOff, ulBits; // vlc decode variables
-    uint8_t *pSrc, *pBuf; // starting & current buffer pointer
-    int16_t *pCur, *pRef; // current state of current vs reference flips
-    int16_t CurFlips[MAX_IMAGE_FLIPS];
-    int16_t RefFlips[MAX_IMAGE_FLIPS];
-} G5DECIMAGE;
-
-// Due to unaligned memory causing an exception, we have to do these macros the slow way
-#ifdef __AVR__
-// assume PROGMEM as the source of data
-inline uint32_t TIFFMOTOLONG(uint8_t *p)
-{
-  uint32_t u32 = pgm_read_dword(p);
-  return __builtin_bswap32(u32);
-}
-#else
-#define TIFFMOTOLONG(p) (((uint32_t)(*p)<<24UL) + ((uint32_t)(*(p+1))<<16UL) + ((uint32_t)(*(p+2))<<8UL) + (uint32_t)(*(p+3)))
-#endif // __AVR__
-
-#define TOP_BIT 0x80000000
-#define MAX_VALUE 0xffffffff
-// Must be a 32-bit target processor
-#define REGISTER_WIDTH 32
-#define BIGUINT uint32_t
-
-//
-// G5 Encoder
-//
-
-typedef struct g5_buffered_bits
-{
-unsigned char *pBuf; // buffer pointer
-uint32_t ulBits; // buffered bits
-uint32_t ulBitOff; // current bit offset
-uint32_t ulDataSize; // available data
-} G5_BUFFERED_BITS;
-
-//
-// Encoder state
-//
-typedef struct g5_enc_image_tag
-{
-    int iWidth, iHeight; // image size
-    int iError;
-    int y; // last y encoded
-    int iOutSize;
-    int iDataSize; // generated output size
-    uint8_t *pOutBuf;
-    int16_t *pCur, *pRef; // pointers to swap current and reference lines
-    G5_BUFFERED_BITS bb;
-    int16_t CurFlips[MAX_IMAGE_FLIPS];
-    int16_t RefFlips[MAX_IMAGE_FLIPS];
-} G5ENCIMAGE;
-
-#ifdef __cplusplus
-//
-// The G5 classes wrap portable C code which does the actual work
-//
-class G5ENCODER
-{
-  public:
-    int init(int iWidth, int iHeight, uint8_t *pOut, int iOutSize);
-    int encodeLine(uint8_t *pPixels);
-    int size();
-
-  private:
-    G5ENCIMAGE _g5enc;
-};
-class G5DECODER
-{
-  public:
-    int init(int iWidth, int iHeight, uint8_t *pData, int iDataSize);
-    int decodeLine(uint8_t *pOut);
-
-  private:
-    G5DECIMAGE _g5dec;
-};
-#endif // __cplusplus
-
-#endif // __GROUP5__
@@ -1,346 +0,0 @@
-//
-// Group5
-// A 1-bpp image decoder
-//
-// Written by Larry Bank (bitbank@pobox.com)
-//
-// SPDX-FileCopyrightText: 2024 BitBank Software, Inc.
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-#include "Group5.h"
-
-/*
- The code tree that follows has: bit_length, decode routine
- These codes are for Group 4 (MMR) decoding
-
- 01 = vertneg1, 11h = vert1, 20h = horiz, 30h = pass, 12h = vert2
- 02 = vertneg2, 13h = vert3, 03 = vertneg3, 90h = trash
-*/
-
-static const uint8_t code_table[128]  =
-        {0x90, 0, 0x40, 0,       /* trash, uncompr mode - codes 0 and 1 */
-         3, 7,                   /* V(-3) pos = 2 */
-         0x13, 7,                /* V(3)  pos = 3 */
-         2, 6, 2, 6,             /* V(-2) pos = 4,5 */
-         0x12, 6, 0x12, 6,       /* V(2)  pos = 6,7 */
-         0x30, 4, 0x30, 4, 0x30, 4, 0x30, 4,    /* pass  pos = 8->F */
-         0x30, 4, 0x30, 4, 0x30, 4, 0x30, 4,
-         0x20, 3, 0x20, 3, 0x20, 3, 0x20, 3,    /* horiz pos = 10->1F */
-         0x20, 3, 0x20, 3, 0x20, 3, 0x20, 3,
-         0x20, 3, 0x20, 3, 0x20, 3, 0x20, 3,
-         0x20, 3, 0x20, 3, 0x20, 3, 0x20, 3,
-/* V(-1) pos = 20->2F */
-         1, 3, 1, 3, 1, 3, 1, 3,
-         1, 3, 1, 3, 1, 3, 1, 3,
-         1, 3, 1, 3, 1, 3, 1, 3,
-         1, 3, 1, 3, 1, 3, 1, 3,
-         0x11, 3, 0x11, 3, 0x11, 3, 0x11, 3,   /* V(1)   pos = 30->3F */
-         0x11, 3, 0x11, 3, 0x11, 3, 0x11, 3,
-         0x11, 3, 0x11, 3, 0x11, 3, 0x11, 3,
-         0x11, 3, 0x11, 3, 0x11, 3, 0x11, 3};
-
-static int g5_decode_init(G5DECIMAGE *pImage, int iWidth, int iHeight, uint8_t *pData, int iDataSize)
-{
-    if (pImage == NULL || iWidth < 1 || iHeight < 1 || pData == NULL || iDataSize < 1)
-        return G5_INVALID_PARAMETER;
-    
-    pImage->iVLCSize = iDataSize;
-    pImage->pSrc = pData;
-    pImage->ulBitOff = 0;
-    pImage->y = 0;
-    pImage->ulBits = TIFFMOTOLONG(pData); // preload the first 32 bits of data
-    pImage->iWidth = iWidth;
-    pImage->iHeight = iHeight;
-    return G5_SUCCESS;
-
-} /* g5_decode_init() */
-
-static void G5DrawLine(G5DECIMAGE *pPage, int16_t *pCurFlips, uint8_t *pOut)
-{
-    int x, len, run;
-    uint8_t lBit, rBit, *p;
-    int iStart = 0, xright = pPage->iWidth;
-    uint8_t *pDest;
-
-    iStart = 0;
-    
-    pDest = pOut;
-    len = (xright+7)>>3; // number of bytes to generate
-    for (x=0; x<len; x++) {
-        pOut[x] = 0xff; // start with white and only draw the black runs
-    }
-    x = 0;
-    while (x < xright) { // while the scaled x is within the window bounds
-        x = *pCurFlips++; // black starting point
-        run = *pCurFlips++ - x; // get the black run
-        x -= iStart;
-        if (x >= xright || run == 0)
-             break;
-        if ((x + run) > 0) { /* If the run is visible, draw it */
-             if (x < 0) {
-                run += x; /* draw only visible part of run */
-                x = 0;
-             }
-            if ((x + run) > xright) { /* Don't let it go off right edge */
-                run = xright - x;
-            }
-            /* Draw this run */
-            lBit = 0xff << (8 - (x & 7));
-            rBit = 0xff >> ((x + run) & 7);
-            len = ((x+run)>>3) - (x >> 3);
-            p = &pDest[x >> 3];
-            if (len == 0) {
-                lBit |= rBit;
-                *p &= lBit;
-            } else {
-                *p++ &= lBit;
-                while (len > 1) {
-                   *p++ = 0;
-                   len--;
-                }
-                *p = rBit;
-            }
-        } // visible run
-    } /* while drawing line */
-} /* G5DrawLine() */
-//
-// Initialize internal structures to decode the image
-//
-static void Decode_Begin(G5DECIMAGE *pPage)
-{
-    int i, xsize;
-    int16_t *CurFlips, *RefFlips;
-    
-    xsize = pPage->iWidth;
-    
-    RefFlips = pPage->RefFlips;
-    CurFlips = pPage->CurFlips;
-    
-    /* Seed the current and reference line with XSIZE for V(0) codes */
-     for (i=0; i<MAX_IMAGE_FLIPS-2; i++) {
-         RefFlips[i] = xsize;
-         CurFlips[i] = xsize;
-     }
-    /* Prefill both current and reference lines with 7fff to prevent it from
-       walking off the end if the data gets bunged and the current X is > XSIZE
-       3-16-94 */
-     CurFlips[i] = RefFlips[i] = 0x7fff;
-     CurFlips[i+1] = RefFlips[i+1] = 0x7fff;
-    
-    pPage->pCur = CurFlips;
-    pPage->pRef = RefFlips;
-    pPage->pBuf = pPage->pSrc;
-    pPage->ulBits = TIFFMOTOLONG(pPage->pSrc); // load 32 bits to start
-    pPage->ulBitOff = 0;
-    // Calculate the number of bits needed for a long horizontal code
-#ifdef __AVR__
-    pPage->iHLen = 16 - __builtin_clz(pPage->iWidth);
-#else
-    pPage->iHLen = 32 - __builtin_clz(pPage->iWidth);
-#endif
-} /* Decode_Begin() */
-//
-// Decode a single line of G5 data (private function)
-//
-static int DecodeLine(G5DECIMAGE *pPage)
-{
-    signed int a0, a0_p, b1;
-    int16_t *pCur, *pRef, *RefFlips, *CurFlips;
-    int xsize, tot_run=0, tot_run1 = 0;
-    int32_t sCode;
-    uint32_t lBits;
-    uint32_t ulBits, ulBitOff;
-    uint8_t *pBuf/*, *pBufEnd*/;
-    uint32_t u32HMask, u32HLen; // horizontal code mask and length
-
-    pCur = CurFlips = pPage->pCur;
-    pRef = RefFlips = pPage->pRef;
-    ulBits = pPage->ulBits;
-    ulBitOff = pPage->ulBitOff;
-    pBuf = pPage->pBuf;
-    // pBufEnd = &pPage->pSrc[pPage->iVLCSize];
-    u32HLen = pPage->iHLen;
-    u32HMask = (1 << u32HLen) - 1;
-    a0 = -1;
-    xsize = pPage->iWidth;
-    
-    while (a0 < xsize) {  /* Decode this line */
-        if (ulBitOff > (REGISTER_WIDTH-8)) { // need at least 7 unused bits
-            pBuf += (ulBitOff >> 3);
-            ulBitOff &= 7;
-            ulBits = TIFFMOTOLONG(pBuf);
-        }
-        if ((int32_t)(ulBits << ulBitOff) < 0) { /* V(0) code is the most frequent case (1 bit) */
-            a0 = *pRef++;
-            ulBitOff++; // length = 1 bit
-            *pCur++ = a0;
-        } else { /* Slower method for the less frequence codes */
-            lBits = (ulBits >> ((REGISTER_WIDTH - 8) - ulBitOff)) & 0xfe; /* Only the first 7 bits are useful */
-            sCode = code_table[lBits]; /* Get the code type as an 8-bit value */
-            ulBitOff += code_table[lBits+1]; /* Get the code length */
-            switch (sCode) {
-                case 1: /* V(-1) */
-                case 2: /* V(-2) */
-                case 3: /* V(-3) */
-                    a0 = *pRef - sCode;  /* A0 = B1 - x */
-                    *pCur++ = a0;
-                    if (pRef == RefFlips) {
-                        pRef += 2;
-                    }
-                    pRef--;
-                    while (a0 >= *pRef) {
-                        pRef += 2;
-                    }
-                    break;
-
-                case 0x11: /* V(1) */
-                case 0x12: /* V(2) */
-                case 0x13: /* V(3) */
-                    a0 = *pRef++;   /* A0 = B1 */
-                    b1 = a0;
-                    a0 += sCode & 7;      /* A0 = B1 + x */
-                    if (b1 != xsize && a0 < xsize) {
-                        while (a0 >= *pRef) {
-                            pRef += 2;
-                        }
-                    }
-                    if (a0 > xsize) {
-                        a0 = xsize;
-                    }
-                    *pCur++ = a0;
-                    break;
-
-                case 0x20: /* Horizontal codes */
-                    if (ulBitOff > (REGISTER_WIDTH-16)) { // need at least 16 unused bits
-                        pBuf += (ulBitOff >> 3);
-                        ulBitOff &= 7;
-                        ulBits = TIFFMOTOLONG(pBuf);
-                    }
-                    a0_p = a0;
-                    if (a0 < 0) {
-                        a0_p = 0;
-                    }
-                    lBits = (ulBits >> ((REGISTER_WIDTH - 2) - ulBitOff)) & 0x3; // get 2-bit prefix for code type
-                    // There are 4 possible horizontal cases: short/short, short/long, long/short, long/long
-                    // These are encoded in a 2-bit prefix code, followed by 3 bits for short or N bits for long code
-                    // N is the log base 2 of the image width (e.g. 320 pixels requires 9 bits)
-                    ulBitOff += 2;
-                    switch (lBits) {
-                        case HORIZ_SHORT_SHORT:
-                            tot_run = (ulBits >> ((REGISTER_WIDTH - 3) - ulBitOff)) & 0x7; // get 3-bit short length
-                            ulBitOff += 3;
-                            tot_run1 = (ulBits >> ((REGISTER_WIDTH - 3) - ulBitOff)) & 0x7; // get 3-bit short length
-                            ulBitOff += 3;
-                            break;
-                        case HORIZ_SHORT_LONG:
-                            tot_run = (ulBits >> ((REGISTER_WIDTH - 3) - ulBitOff)) & 0x7; // get 3-bit short length
-                            ulBitOff += 3;
-                            tot_run1 = (ulBits >> ((REGISTER_WIDTH - u32HLen) - ulBitOff)) & u32HMask; // get long length
-                            ulBitOff += u32HLen;
-                            break;
-                        case HORIZ_LONG_SHORT:
-                            tot_run = (ulBits >> ((REGISTER_WIDTH - u32HLen) - ulBitOff)) & u32HMask; // get long length
-                            ulBitOff += u32HLen;
-                            tot_run1 = (ulBits >> ((REGISTER_WIDTH - 3) - ulBitOff)) & 0x7; // get 3-bit short length
-                            ulBitOff += 3;
-                            break;
-                        case HORIZ_LONG_LONG:
-                            tot_run = (ulBits >> ((REGISTER_WIDTH - u32HLen) - ulBitOff)) & u32HMask; // get long length
-                            ulBitOff += u32HLen;
-                            if (ulBitOff > (REGISTER_WIDTH-16)) { // need at least 16 unused bits
-                                pBuf += (ulBitOff >> 3);
-                                ulBitOff &= 7;
-                                ulBits = TIFFMOTOLONG(pBuf);
-                            }
-                            tot_run1 = (ulBits >> ((REGISTER_WIDTH - u32HLen) - ulBitOff)) & u32HMask; // get long length
-                            ulBitOff += u32HLen;
-                            break;
-                    } // switch on lBits
-                    a0 = a0_p + tot_run;
-                    *pCur++ = a0;
-                    a0 += tot_run1;
-                    if (a0 < xsize) {
-                        while (a0 >= *pRef) {
-                            pRef += 2;
-                        }
-                    }
-                    *pCur++ = a0;
-                    break;
-
-                case 0x30: /* Pass code */
-                    pRef++;         /* A0 = B2, iRef+=2 */
-                    a0 = *pRef++;
-                break;
-                     
-                default: /* ERROR */
-                   pPage->iError = G5_DECODE_ERROR;
-                   goto pilreadg5z;
-             } /* switch */
-          } /* Slow climb */
-       }
-    /*--- Convert flips data into run lengths ---*/
-    *pCur++ = xsize;  /* Terminate the line properly */
-    *pCur++ = xsize;
-pilreadg5z:
-    // Save the current VLC decoder state
-    pPage->ulBits = ulBits;
-    pPage->ulBitOff = ulBitOff;
-    pPage->pBuf = pBuf;
-    return pPage->iError;
-} /* DecodeLine() */
-//
-// Decompress the VLC data
-//
-static int g5_decode_line(G5DECIMAGE *pPage, uint8_t *pOut)
-{
-    int rc;
-    uint8_t *pBufEnd;
-    int16_t *t1;
-    
-    if (pPage == NULL || pOut == NULL)
-        return G5_INVALID_PARAMETER;
-    if (pPage->y >= pPage->iHeight)
-        return G5_DECODE_COMPLETE;
-    
-    pPage->iError = G5_SUCCESS;
-    
-    if (pPage->y == 0) { // first time through
-        Decode_Begin(pPage);
-    }
-    pBufEnd = &pPage->pSrc[pPage->iVLCSize];
-    
-   if (pPage->pBuf >= pBufEnd) { // read past the end, error
-       pPage->iError = G5_DECODE_ERROR;
-       return G5_DECODE_ERROR;
-   }
-   rc = DecodeLine(pPage);
-   if (rc == G5_SUCCESS) {
-       // Draw the current line
-       G5DrawLine(pPage, pPage->pCur, pOut);
-       /*--- Swap current and reference lines ---*/
-       t1 = pPage->pRef;
-       pPage->pRef = pPage->pCur;
-       pPage->pCur = t1;
-       pPage->y++;
-       if (pPage->y >= pPage->iHeight) {
-           pPage->iError = G5_DECODE_COMPLETE;
-       }
-   } else {
-       pPage->iError = rc;
-   }
-    return pPage->iError;
-} /* Decode() */
@@ -1,315 +0,0 @@
-//
-// G5 Encoder
-// A 1-bpp image encoding library
-//
-// Written by Larry Bank (bitbank@pobox.com)
-//
-// SPDX-FileCopyrightText: 2024 BitBank Software, Inc.
-// SPDX-License-Identifier: GPL-3.0-or-later
-//
-// This program is free software: you can redistribute it and/or modify
-// it under the terms of the GNU General Public License as published by
-// the Free Software Foundation, either version 3 of the License, or
-// (at your option) any later version.
-//
-// This program is distributed in the hope that it will be useful,
-// but WITHOUT ANY WARRANTY; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-// GNU General Public License for more details.
-//
-// You should have received a copy of the GNU General Public License
-// along with this program.  If not, see <http://www.gnu.org/licenses/>.
-//
-
-#include "Group5.h"
-
-/* Number of consecutive 1 bits in a byte from MSB to LSB */
-static uint8_t bitcount[256] =
-        {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 0-15 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 16-31 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 32-47 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 48-63 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 64-79 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 80-95 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 96-111 */
-         0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,  /* 112-127 */
-         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  /* 128-143 */
-         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  /* 144-159 */
-         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  /* 160-175 */
-         1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,  /* 176-191 */
-         2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  /* 192-207 */
-         2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,  /* 208-223 */
-         3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,  /* 224-239 */
-         4,4,4,4,4,4,4,4,5,5,5,5,6,6,7,8}; /* 240-255 */
-
-/* Table of vertical codes for G5 encoding */
-/* code followed by length, starting with v(-3) */
-static const uint8_t vtable[14] =
-        {3,7,     /* V(-3) = 0000011 */
-         3,6,     /* V(-2) = 000011  */
-         3,3,     /* V(-1) = 011     */
-         1,1,     /* V(0)  = 1       */
-         2,3,     /* V(1)  = 010     */
-         2,6,     /* V(2)  = 000010  */
-         2,7};    /* V(3)  = 0000010 */
-
-
-static void G5ENCInsertCode(G5_BUFFERED_BITS *bb, BIGUINT ulCode, int iLen)
-{
-    if ((bb->ulBitOff + iLen) > REGISTER_WIDTH) { // need to write data
-        bb->ulBits |= (ulCode >> (bb->ulBitOff + iLen - REGISTER_WIDTH)); // partial bits on first word
-        *(BIGUINT *)bb->pBuf = __builtin_bswap32(bb->ulBits);
-        bb->pBuf += sizeof(BIGUINT);
-        bb->ulBits = ulCode << ((REGISTER_WIDTH*2) - (bb->ulBitOff + iLen));
-        bb->ulBitOff += iLen - REGISTER_WIDTH;
-    } else {
-        bb->ulBits |= (ulCode << (REGISTER_WIDTH - bb->ulBitOff - iLen));
-        bb->ulBitOff += iLen;
-    }
-} /* G5ENCInsertCode() */
-//
-// Flush any buffered bits to the output
-//
-static void G5ENCFlushBits(G5_BUFFERED_BITS *bb)
-{
-    while (bb->ulBitOff >= 8)
-    {
-        *bb->pBuf++ = (unsigned char) (bb->ulBits >> (REGISTER_WIDTH - 8));
-        bb->ulBits <<= 8;
-        bb->ulBitOff -= 8;
-    }
-    if (bb->ulBitOff) { // partial byte?
-        *bb->pBuf++ = (unsigned char) (bb->ulBits >> (REGISTER_WIDTH - 8));
-    }
-    bb->ulBitOff = 0;
-    bb->ulBits = 0;
-} /* G5ENCFlushBits() */
-//
-// Initialize the compressor
-// This must be called before adding data to the output
-//
-static int g5_encode_init(G5ENCIMAGE *pImage, int iWidth, int iHeight, uint8_t *pOut, int iOutSize)
-{
-    int iError = G5_SUCCESS;
-    
-    if (pImage == NULL || iHeight <= 0)
-        return G5_INVALID_PARAMETER;
-    pImage->iWidth = iWidth; // image size
-    pImage->iHeight = iHeight;
-    pImage->pCur = pImage->CurFlips;
-    pImage->pRef = pImage->RefFlips;
-    pImage->pOutBuf = pOut; // optional output buffer
-    pImage->iOutSize = iOutSize; // output buffer pre-allocated size
-    pImage->iDataSize = 0; // no data yet
-    pImage->y = 0;
-    for (int i=0; i<MAX_IMAGE_FLIPS; i++) {
-        pImage->RefFlips[i] = iWidth;
-        pImage->CurFlips[i] = iWidth;
-    }
-    pImage->bb.pBuf = pImage->pOutBuf;
-    pImage->bb.ulBits = 0;
-    pImage->bb.ulBitOff = 0;
-    pImage->iError = iError;
-    return iError;
-} /* g5_encode_init() */
-//
-// Internal function to convert uncompressed 1-bit per pixel data
-// into the run-end data needed to feed the G5 encoder
-//
-static int G5ENCEncodeLine(unsigned char *buf, int xsize, int16_t *pDest)
-{
-int iCount, xborder;
-uint8_t i, c;
-int8_t cBits;
-int iLen;
-int16_t x;
-int16_t *pLimit = pDest + (MAX_IMAGE_FLIPS-4);
-
-   xborder = xsize;
-   iCount = (xsize + 7) >> 3; /* Number of bytes per line */
-   cBits = 8;
-   iLen = 0; /* Current run length */
-   x = 0;
-
-   c = *buf++;  /* Get the first byte to start */
-   iCount--;
-   while (iCount >=0) {
-      if (pDest >= pLimit) return G5_MAX_FLIPS_EXCEEDED;
-      i = bitcount[c]; /* Get the number of consecutive bits */
-      iLen += i; /* Add this length to total run length */
-      c <<= i;
-      cBits -= i; /* Minus the number in a byte */
-      if (cBits <= 0)
-         {
-         iLen += cBits; /* Adjust length */
-         cBits = 8;
-         c = *buf++;  /* Get another data byte */
-         iCount--;
-         continue; /* Keep doing white until color change */
-         }
-      c = ~c; /* flip color to count black pixels */
-   /* Store the white run length */
-      xborder -= iLen;
-      if (xborder < 0)
-         {
-         iLen += xborder; /* Make sure run length is not past end */
-         break;
-         }
-      x += iLen;
-      *pDest++ = x;
-      iLen = 0;
-doblack:
-      i = bitcount[c]; /* Get consecutive bits */
-      iLen += i; /* Add to total run length */
-      c <<= i;
-      cBits -= i;
-      if (cBits <= 0)
-         {
-         iLen += cBits; /* Adjust length */
-         cBits = 8;
-         c = *buf++;  /* Get another data byte */
-         c = ~c;   /* Flip color to find black */
-         iCount--;
-         if (iCount < 0)
-            break;
-         goto doblack;
-         }
-   /* Store the black run length */
-      c = ~c;       /* Flip color again to find white pixels */
-      xborder -= iLen;
-      if (xborder < 0)
-         {
-         iLen += xborder; /* Make sure run length is not past end */
-         break;
-         }
-      x += iLen;
-      *pDest++ = x;
-      iLen = 0;
-      } /* while */
-
-   if (pDest >= pLimit) return G5_MAX_FLIPS_EXCEEDED;
-   *pDest++ = xsize;
-   *pDest++ = xsize; // Store a few more XSIZE to end the line
-   *pDest++ = xsize; // so that the compressor doesn't go past
-   *pDest++ = xsize; // the end of the line
-   return G5_SUCCESS;
-} /* G5ENCEncodeLine() */
-//
-// Compress a line of pixels and add it to the output
-// the input format is expected to be MSB (most significant bit) first
-// for example, pixel 0 is in byte 0 at bit 7 (0x80)
-// Returns G5ENC_SUCCESS for each line if all is well and G5ENC_IMAGE_COMPLETE
-// for the last line
-//
-static int g5_encode_encodeLine(G5ENCIMAGE *pImage, uint8_t *pPixels)
-{
-int16_t a0, a0_c, b2, a1;
-int dx, run1, run2;
-int xsize, iErr, iHighWater;
-int iCur, iRef, iLen;
-int iHLen; // number of bits for long horizontal codes
-int16_t *CurFlips, *RefFlips;
-G5_BUFFERED_BITS bb;
-
-    if (pImage == NULL || pPixels == NULL)
-        return G5_INVALID_PARAMETER;
-    iHighWater = pImage->iOutSize - 32;
-    iHLen = 32 - __builtin_clz(pImage->iWidth);
-    memcpy(&bb, &pImage->bb, sizeof(G5_BUFFERED_BITS)); // keep local copy
-    CurFlips = pImage->pCur;
-    RefFlips = pImage->pRef;
-    xsize = pImage->iWidth; /* For performance reasons */
-
-    // Convert the incoming line of pixels into run-end data
-    iErr = G5ENCEncodeLine(pPixels, pImage->iWidth, CurFlips);
-    if (iErr != G5_SUCCESS) return iErr; // exceeded the maximum number of color changes
-    /* Encode this line as G5 */
-    a0 = a0_c = 0;
-    iCur = iRef = 0;
-    while (a0 < xsize) {
-        b2 = RefFlips[iRef+1];
-        a1 = CurFlips[iCur];
-        if (b2 < a1) { /* Is b2 to the left of a1? */
-            /* yes, do pass mode */
-            a0 = b2;
-            iRef += 2;
-            G5ENCInsertCode(&bb, 1, 4); /* Pass code = 0001 */
-        } else { /* Try vertical and horizontal mode */
-            dx = RefFlips[iRef] - a1;  /* b1 - a1 */
-            if (dx > 3 || dx < -3) { /* Horizontal mode */
-                G5ENCInsertCode(&bb, 1, 3); /* Horizontal code = 001 */
-                run1 = CurFlips[iCur] - a0;
-                run2 = CurFlips[iCur+1] - CurFlips[iCur];
-                if (run1 < 8) {
-                    if (run2 < 8) { // short, short
-                        G5ENCInsertCode(&bb, HORIZ_SHORT_SHORT, 2); /* short, short = 00 */
-                        G5ENCInsertCode(&bb, run1, 3);
-                        G5ENCInsertCode(&bb, run2, 3);
-                    } else { // short, long
-                        G5ENCInsertCode(&bb, HORIZ_SHORT_LONG, 2); /* short, long = 01 */
-                        G5ENCInsertCode(&bb, run1, 3);
-                        G5ENCInsertCode(&bb, run2, iHLen);
-                    }
-                } else { // first run is long
-                    if (run2 < 8) { // long, short
-                        G5ENCInsertCode(&bb, HORIZ_LONG_SHORT, 2); /* long, short = 10 */
-                        G5ENCInsertCode(&bb, run1, iHLen);
-                        G5ENCInsertCode(&bb, run2, 3);
-                    } else { // long, long
-                        G5ENCInsertCode(&bb, HORIZ_LONG_LONG, 2); /* long, long = 11 */
-                        G5ENCInsertCode(&bb, run1, iHLen);
-                        G5ENCInsertCode(&bb, run2, iHLen);
-                    }
-                }
-               a0 = CurFlips[iCur+1]; /* a0 = a2 */
-               if (a0 != xsize) {
-                  iCur += 2; /* Skip two color flips */
-                   while (RefFlips[iRef] != xsize && RefFlips[iRef] <= a0) {
-                       iRef += 2;
-                   }
-                }
-            } else { /* Vertical mode */
-               dx = (dx + 3) * 2; /* Convert to index table */
-                G5ENCInsertCode(&bb, vtable[dx], vtable[dx+1]);
-                a0 = a1;
-                a0_c = 1-a0_c;
-                if (a0 != xsize) {
-                    if (iRef != 0) {
-                        iRef -= 2;
-                    }
-                    iRef++; /* Skip a color change in cur and ref */
-                    iCur++;
-                    while (RefFlips[iRef] <= a0 && RefFlips[iRef] != xsize) {
-                        iRef += 2;
-                    }
-                }
-            } /* vertical mode */
-        } /* horiz/vert mode */
-    } /* while x < xsize */
-    iLen = (int)(bb.pBuf-pImage->pOutBuf);
-    if (iLen >= iHighWater) { // not enough space
-           pImage->iError = iErr = G5_DATA_OVERFLOW; // we don't have a better error
-           return iErr;
-    }
-    if (pImage->y == pImage->iHeight-1) { // last line of image
-        G5ENCFlushBits(&bb); // output the final buffered bits
-        // wrap up final output
-        pImage->iDataSize = 1 + (int)(bb.pBuf-pImage->pOutBuf);
-        iErr = G5_ENCODE_COMPLETE;
-    }
-    pImage->pCur = RefFlips; // swap current and reference lines
-    pImage->pRef = CurFlips;
-    pImage->y++;
-    memcpy(&pImage->bb, &bb, sizeof(bb));
-    return iErr;
-} /* g5_encode_encodeLine() */
-//
-// Returns the number of bytes of G5 created by the encoder
-//
-static int g5_encode_getOutSize(G5ENCIMAGE *pImage)
-{
-    int iSize = 0;
-    if (pImage != NULL)
-        iSize = pImage->iDataSize;
-    return iSize;
-} /* g5_encode_getOutSize() */
@@ -1,17 +0,0 @@
-#pragma once
-
-#include <builtinFonts/bookerly_12.h>
-#include <builtinFonts/bookerly_14.h>
-#include <builtinFonts/bookerly_16.h>
-#include <builtinFonts/bookerly_18.h>
-#include <builtinFonts/notosans_8.h>
-#include <builtinFonts/notosans_12.h>
-#include <builtinFonts/notosans_14.h>
-#include <builtinFonts/notosans_16.h>
-#include <builtinFonts/notosans_18.h>
-#include <builtinFonts/opendyslexic_8.h>
-#include <builtinFonts/opendyslexic_10.h>
-#include <builtinFonts/opendyslexic_12.h>
-#include <builtinFonts/opendyslexic_14.h>
-#include <builtinFonts/ubuntu_10.h>
-#include <builtinFonts/ubuntu_12.h>
@@ -1,25 +0,0 @@
-#!/bin/bash
-
-set -e
-
-cd "$(dirname "$0")"
-
-echo "// The contents of this file are generated by ./lib/CrossPointFont/builtinFonts/build-font-ids.sh"
-echo "#pragma once"
-echo ""
-
-echo "#define BOOKERLY_12_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./bookerly_12.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define BOOKERLY_14_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./bookerly_14.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define BOOKERLY_16_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./bookerly_16.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define BOOKERLY_18_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./bookerly_18.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define NOTOSANS_12_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./notosans_12.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define NOTOSANS_14_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./notosans_14.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define NOTOSANS_16_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./notosans_16.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define NOTOSANS_18_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./notosans_18.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define OPENDYSLEXIC_8_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./opendyslexic_8.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define OPENDYSLEXIC_10_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./opendyslexic_10.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define OPENDYSLEXIC_12_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./opendyslexic_12.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define OPENDYSLEXIC_14_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./opendyslexic_14.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define UI_10_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./ubuntu_10.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define UI_12_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./ubuntu_12.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
-echo "#define SMALL_FONT_ID ($(ruby -rdigest -e 'puts Digest::SHA256.hexdigest(File.read("./notosans_8.h")).to_i(16) % (2 ** 32) - (2 ** 31)'))"
@@ -1,42 +0,0 @@
-#!/bin/bash
-
-set -e
-
-cd "$(dirname "$0")"
-
-BOOKERLY_FONT_SIZES=(12 14 16 18)
-NOTOSANS_FONT_SIZES=(12 14 16 18)
-OPENDYSLEXIC_FONT_SIZES=(8 10 12 14)
-
-for size in ${BOOKERLY_FONT_SIZES[@]}; do
-  font_name="bookerly_${size}"
-  font_path_prefix="./source/Bookerly/Bookerly-"
-  output_path="./${font_name}.h"
-  ../fontconvert/fontconvert "${font_path_prefix}Regular.ttf" -b "${font_path_prefix}Bold.ttf" -i "${font_path_prefix}Italic.ttf" -bi "${font_path_prefix}BoldItalic.ttf" -o $output_path -p $size
-done
-
-for size in ${NOTOSANS_FONT_SIZES[@]}; do
-  font_name="notosans_${size}"
-  font_path_prefix="./source/NotoSans/NotoSans-"
-  output_path="./${font_name}.h"
-  ../fontconvert/fontconvert "${font_path_prefix}Regular.ttf" -b "${font_path_prefix}Bold.ttf" -i "${font_path_prefix}Italic.ttf" -bi "${font_path_prefix}BoldItalic.ttf" -o $output_path -p $size
-done
-
-for size in ${OPENDYSLEXIC_FONT_SIZES[@]}; do
-  font_name="opendyslexic_${size}"
-  font_path_prefix="./source/OpenDyslexic/OpenDyslexic-"
-  output_path="./${font_name}.h"
-  ../fontconvert/fontconvert "${font_path_prefix}Regular.otf" -b "${font_path_prefix}Bold.otf" -i "${font_path_prefix}Italic.otf" -bi "${font_path_prefix}BoldItalic.otf" -o $output_path -p $size
-done
-
-UI_FONT_SIZES=(10 12)
-UI_FONT_STYLES=("Regular" "Bold")
-
-for size in ${UI_FONT_SIZES[@]}; do
-  font_name="ubuntu_${size}"
-  font_path_prefix="./source/Ubuntu/Ubuntu-"
-  output_path="./${font_name}.h"
-  ../fontconvert/fontconvert "${font_path_prefix}Regular.ttf" -b "${font_path_prefix}Bold.ttf" -o $output_path -p $size
-done
-
-../fontconvert/fontconvert ./source/NotoSans/NotoSans-Regular.ttf -o ./notosans_8.h -p 8
@@ -1 +0,0 @@
-fontconvert
@@ -1,12 +0,0 @@
-all: fontconvert
-
-CC     = gcc
-CFLAGS = -Wall -I/usr/local/include/freetype2 -I/usr/include/freetype2 -I/usr/include -I/opt/homebrew/include/freetype2
-LIBS   = -L/opt/homebrew/lib -lfreetype
-
-fontconvert: main.c ../Group5/Group5.h
-	$(CC) $(CFLAGS) main.c $(LIBS) -o fontconvert
-	strip fontconvert
-
-clean:
-	rm -f fontconvert
@@ -1,553 +0,0 @@
-//
-// TrueType to CrossPoint font converter
-// Copyright (c) 2024 BitBank Software, inc.
-// Written by Larry Bank, adapted by Dave Allie for CrossPoint
-// August 31, 2024
-// The CrossPoint font format is a losslessly compressed bitmap font of a single point size with multiple variants
-// This was built entirely on the back of Larry Bank's bb_font format.
-// The data is compressed with a compression scheme based on CCITT T.6
-// The font structure includes overall size, per-character glyph info and then the
-// compressed image data at the end.
-// The font file format is designed to allow both dynamic loading of font data from
-// external memory/disk or compiling the data as const into a progarm.
-//
-// Example usage:
-// ./fontconvert <regular.ttf> [-b <bold.ttf>] [-i <italic.ttf>] [-bi <bold-italic.ttf>] -p <pt size> -o <out.cpf>
-// ./fontconvert <regular.ttf> [-b <bold.ttf>] [-i <italic.ttf>] [-bi <bold-italic.ttf>] -p <pt size> -o <out.h>
-//
-// This code requires the freetype library
-// found here: www.freetype.org
-//
-
-#ifndef ARDUINO
-
-#include <ctype.h>
-#include <ft2build.h>
-#include <stdint.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#include "../CrossPointFontFormat.h"
-
-#include FT_GLYPH_H
-#include FT_MODULE_H
-#include FT_TRUETYPE_DRIVER_H
-#include "../Group5/g5enc.inl"  // Group5 image compression library
-G5ENCIMAGE g5enc;               // Group5 encoder state
-
-#define DPI 150              // Approximate resolution of common displays
-#define OUTBUF_SIZE 1048576  // 1MB
-#define MAX_INTERVALS 65536
-#define FONT_SCALE_FACTOR 2
-// TODO: Re-enable small font
-// Disabled small font generation to get this working, but want to re-enable
-#define SMALL_FONT_ENABLED 0
-
-uint32_t raw_intervals[][2] = {
-    /* Basic Latin */
-    // ASCII letters, digits, punctuation, control characters
-    {0x0000, 0x007F},
-    /* Latin-1 Supplement */
-    // Accented characters for Western European languages
-    {0x0080, 0x00FF},
-    /* Latin Extended-A */
-    // Eastern European and Baltic languages
-    {0x0100, 0x017F},
-    /* General Punctuation (core subset) */
-    // Smart quotes, en dash, em dash, ellipsis, NO-BREAK SPACE
-    {0x2000, 0x206F},
-    /* Basic Symbols From "Latin-1 + Misc" */
-    // dashes, quotes, prime marks
-    {0x2010, 0x203A},
-    // misc punctuation
-    {0x2040, 0x205F},
-    // common currency symbols
-    {0x20A0, 0x20CF},
-    /* Combining Diacritical Marks (minimal subset) */
-    // Needed for proper rendering of many extended Latin languages
-    {0x0300, 0x036F},
-    /* Greek & Coptic */
-    // Used in science, maths, philosophy, some academic texts
-    // {0x0370, 0x03FF},
-    /* Cyrillic */
-    // Russian, Ukrainian, Bulgarian, etc.
-    {0x0400, 0x04FF},
-    /* Math Symbols (common subset) */
-    // Superscripts and Subscripts
-    {0x2070, 0x209F},
-    // General math operators
-    {0x2200, 0x22FF},
-    // Arrows
-    {0x2190, 0x21FF},
-    /* CJK */
-    // Core Unified Ideographs
-    // {0x4E00, 0x9FFF},
-    // Extension A
-    // {0x3400, 0x4DBF},
-    // Extension B
-    // {0x20000, 0x2A6DF},
-    // Extension C–F
-    // {0x2A700, 0x2EBEF},
-    // Extension G
-    // {0x30000, 0x3134F},
-    // Hiragana
-    // {0x3040, 0x309F},
-    // Katakana
-    // {0x30A0, 0x30FF},
-    // Katakana Phonetic Extensions
-    // {0x31F0, 0x31FF},
-    // Halfwidth Katakana
-    // {0xFF60, 0xFF9F},
-    // Hangul Syllables
-    // {0xAC00, 0xD7AF},
-    // Hangul Jamo
-    // {0x1100, 0x11FF},
-    // Hangul Compatibility Jamo
-    // {0x3130, 0x318F},
-    // Hangul Jamo Extended-A
-    // {0xA960, 0xA97F},
-    // Hangul Jamo Extended-B
-    // {0xD7B0, 0xD7FF},
-    // CJK Radicals Supplement
-    // {0x2E80, 0x2EFF},
-    // Kangxi Radicals
-    // {0x2F00, 0x2FDF},
-    // CJK Symbols and Punctuation
-    // {0x3000, 0x303F},
-    // CJK Compatibility Forms
-    // {0xFE30, 0xFE4F},
-    // CJK Compatibility Ideographs
-    // {0xF900, 0xFAFF},
-    /* Specials */
-    // Replacement Character
-    {0xFFFD, 0xFFFD},
-};
-
-//
-// Comparison function for qsort
-//
-int compareIntervals(const void* a, const void* b) {
-  const uint32_t* ia = (uint32_t*)a;
-  const uint32_t* ib = (uint32_t*)b;
-  if (ia[0] < ib[0]) return -1;
-  if (ia[0] > ib[0]) return 1;
-  return 0;
-}
-
-//
-// Sort and merge adjacent intervals
-// Returns the number of intervals after merging
-//
-int sortAndMergeIntervals(uint32_t intervals[][2], const int count) {
-  int merged_count = 0;
-
-  // Sort intervals by start value
-  qsort(intervals, count, sizeof(uint32_t) * 2, compareIntervals);
-
-  // Merge overlapping/adjacent intervals
-  for (int i = 0; i < count; i++) {
-    if (merged_count > 0 && intervals[i][0] <= intervals[merged_count - 1][1] + 1) {
-      // Merge with previous interval
-      if (intervals[i][1] > intervals[merged_count - 1][1]) {
-        intervals[merged_count - 1][1] = intervals[i][1];
-      }
-    } else {
-      // Add as new interval
-      if (merged_count != i) {
-        intervals[merged_count][0] = intervals[i][0];
-        intervals[merged_count][1] = intervals[i][1];
-      }
-      merged_count++;
-    }
-  }
-
-  return merged_count;
-}
-
-//
-// Create the comments and const array boilerplate for the hex data bytes
-//
-void StartHexFile(FILE* f, int iLen, const char* fname, int size) {
-  int i, j;
-  char szTemp[256];
-  fprintf(f, "#pragma once\n\n");
-  fprintf(f, "//\n// Created with fontconvert, written by Larry Bank, updated for CrossPoint by Dave Allie\n");
-  fprintf(f, "// Point size: %d (scaled %dx)\n", size, FONT_SCALE_FACTOR);
-  fprintf(f, "// compressed font data size = %d bytes\n//\n", iLen);
-
-  strcpy(szTemp, fname);
-  i = strlen(szTemp);
-  if (szTemp[i - 2] == '.') szTemp[i - 2] = 0;  // get the leaf name for the data
-  j = i;
-  // go backwards to get rid trim off just the leaf name
-  while (j > 0 && szTemp[j] != '/') {
-    j--;
-  }
-  if (szTemp[j] == '/') j++;
-  fprintf(f, "static const uint8_t %s[] = {\n", &szTemp[j]);
-} /* StartHexFile() */
-
-//
-// Add N bytes of hex data to the output
-// The data will be arranged in rows of 16 bytes each
-//
-void AddHexBytes(FILE* f, void* pData, int iLen, int bLast) {
-  static int iCount = 0;  // number of bytes processed so far
-  int i;
-  uint8_t* s = (uint8_t*)pData;
-  for (i = 0; i < iLen; i++) {  // process the given data
-    fprintf(f, "0x%02x", *s++);
-    iCount++;
-    if (i < iLen - 1 || !bLast) fprintf(f, ",");
-    if ((iCount & 15) == 0) fprintf(f, "\n");  // next row of 16
-  }
-  if (bLast) {
-    fprintf(f, "};\n");
-  }
-} /* AddHexBytes() */
-
-int loadCodePoint(FT_Face face, uint32_t code_point, CrossPointFontGlyph* pGlyphs, uint8_t* pBitmap,
-                  uint32_t* glyph_index, uint32_t* iOffset) {
-  uint8_t* s;
-  int iPitch, err;
-  FT_Glyph glyph;
-
-  // MONO renderer provides clean image with perfect crop
-  // (no wasted pixels) via bitmap struct.
-  if ((err = FT_Load_Char(face, code_point, FT_LOAD_TARGET_MONO))) {
-    printf("Error %d loading char U+%04X\n", err, code_point);
-    (*glyph_index)++;
-    return 0;
-  }
-
-  if ((err = FT_Render_Glyph(face->glyph, FT_RENDER_MODE_MONO))) {
-    printf("Error %d rendering char U+%04X\n", err, code_point);
-    (*glyph_index)++;
-    return 0;
-  }
-
-  if ((err = FT_Get_Glyph(face->glyph, &glyph))) {
-    printf("Error %d getting glyph U+%04X\n", err, code_point);
-    (*glyph_index)++;
-    return 0;
-  }
-
-  FT_Bitmap* bitmap = &face->glyph->bitmap;
-  FT_BitmapGlyphRec* g = (FT_BitmapGlyphRec*)glyph;
-
-  // TODO: Restore small font
-  if (0 /* bSmallFont */) {
-#if SMALL_FONT_ENABLED == 1
-    printf("Stubbed\n");
-    return 1;
-#else
-    printf("Small font has been disabled\n");
-    return 1;
-#endif
-  } else {
-    pGlyphs[*glyph_index].bitmapOffset = *iOffset;
-    pGlyphs[*glyph_index].width = bitmap->width;
-    pGlyphs[*glyph_index].height = bitmap->rows;
-    pGlyphs[*glyph_index].xAdvance = (face->glyph->advance.x >> 6);
-    pGlyphs[*glyph_index].xOffset = g->left;
-    pGlyphs[*glyph_index].yOffset = g->top;
-  }
-  s = bitmap->buffer;
-  iPitch = bitmap->pitch;
-
-  g5_encode_init(&g5enc, bitmap->width, bitmap->rows, &pBitmap[*iOffset], OUTBUF_SIZE - *iOffset);
-  for (int y = 0; y < bitmap->rows; y++) {
-    g5_encode_encodeLine(&g5enc, &s[y * iPitch]);
-  }  // for y
-  int iLen = g5_encode_getOutSize(&g5enc);
-  *iOffset += iLen;
-
-  FT_Done_Glyph(glyph);
-  (*glyph_index)++;
-  return 0;
-}
-
-int main(int argc, char* argv[]) {
-  int i, err, size = 0;
-  uint32_t iLen, iOffset = 0;
-  FILE* fOut;
-  // TrueType library structures
-  FT_Library library;
-  char* regularFaceFile;
-  char* boldFaceFile = NULL;
-  char* italicFaceFile = NULL;
-  char* boldItalicFaceFile = NULL;
-  const char* outputFile = NULL;
-  FT_Face faceRegular;
-  FT_Face faceBold;
-  FT_Face faceItalic;
-  FT_Face faceBoldItalic;
-
-  int bSmallFont = 0;  // indicates if we're creating a normal or small font file
-  CrossPointFontUnicodeInterval* pIntervals;
-  CrossPointFontGlyph* pGlyphs;
-#if SMALL_FONT_ENABLED == 1
-  CrossPointFontSmallGlyph* pSmallGlyphs;
-#endif
-  uint8_t* pBitmap;
-  CrossPointFontHeader epdFontHeader;
-
-  int bHFile;  // flag indicating if the output will be a .H file of hex data
-
-  // Process intervals
-  uint32_t intervals[MAX_INTERVALS][2];
-  int intervalCount = sizeof(raw_intervals) / sizeof(raw_intervals[0]);
-  uint32_t totalGlyphs = 0;
-
-  if (argc < 6 || argc % 2 == 1) {
-    printf(
-        "Usage: %s <regular.ttf> [-b <bold.ttf>] [-i <italic.ttf>] [-bi <bold-italic.ttf>] -p point_size -o <out.cpf "
-        "or out.h>\n",
-        argv[0]);
-    return 1;
-  }
-
-  regularFaceFile = argv[1];
-  for (int i = 2; i < argc; i += 2) {
-    if (strcmp(argv[i], "-b") == 0) {
-      // Bold font
-      boldFaceFile = argv[i + 1];
-    } else if (strcmp(argv[i], "-i") == 0) {
-      // Italic font
-      italicFaceFile = argv[i + 1];
-    } else if (strcmp(argv[i], "-bi") == 0) {
-      // Bold-Italic font
-      boldItalicFaceFile = argv[i + 1];
-    } else if (strcmp(argv[i], "-p") == 0) {
-      // Point size
-      size = atoi(argv[i + 1]);
-    } else if (strcmp(argv[i], "-o") == 0) {
-      // Output file
-      outputFile = argv[i + 1];
-      // output an H file?
-      bHFile = outputFile[strlen(outputFile) - 1] == 'H' || outputFile[strlen(outputFile) - 1] == 'h';
-    } else {
-      printf("Unknown argument: %s\n", argv[i]);
-      return 1;
-    }
-  }
-
-  if (!outputFile) {
-    printf("No output file specified\n");
-    return 1;
-  }
-
-  if (size <= 0) {
-    printf("Invalid point size: %d\n", size);
-    return 1;
-  }
-
-  size = size * FONT_SCALE_FACTOR;
-  bSmallFont = (size < 60) && SMALL_FONT_ENABLED == 1;  // Glyph info can fit in signed 8-bit values
-  int fontVariants = 1;                                 // Always at least one variant we treat as regular
-  if (boldFaceFile) fontVariants += 1;
-  if (italicFaceFile) fontVariants += 1;
-  if (boldItalicFaceFile) fontVariants += 1;
-
-  // Copy and sort/merge intervals
-  if (intervalCount > MAX_INTERVALS) {
-    printf("Error: too many intervals (max %d)\n", MAX_INTERVALS);
-    return 1;
-  }
-  for (i = 0; i < intervalCount; i++) {
-    intervals[i][0] = raw_intervals[i][0];
-    intervals[i][1] = raw_intervals[i][1];
-  }
-  intervalCount = sortAndMergeIntervals(intervals, intervalCount);
-
-  // Calculate total number of glyphs
-  for (i = 0; i < intervalCount; i++) {
-    totalGlyphs += intervals[i][1] - intervals[i][0] + 1;
-  }
-  totalGlyphs *= fontVariants;
-
-  printf("Processed intervals: %d, total glyphs: %u\n", intervalCount, totalGlyphs);
-
-  // Allocate memory for intervals
-  pIntervals = (CrossPointFontUnicodeInterval*)malloc(intervalCount * sizeof(CrossPointFontUnicodeInterval));
-  if (!pIntervals) {
-    printf("Error allocating memory for interval data\n");
-    return 1;
-  }
-
-  // Allocate memory for glyphs
-  if (bSmallFont) {
-#if SMALL_FONT_ENABLED == 1
-    pSmallGlyphs = (CrossPointFontSmallGlyph*)malloc(totalGlyphs * sizeof(CrossPointFontSmallGlyph));
-    if (!pSmallGlyphs) {
-      printf("Error allocating memory for glyph data\n");
-      return 1;
-    }
-#else
-    printf("Small font has been disabled\n");
-    return 1;
-#endif
-  } else {
-    pGlyphs = (CrossPointFontGlyph*)malloc(totalGlyphs * sizeof(CrossPointFontGlyph));
-    if (!pGlyphs) {
-      printf("Error allocating memory for glyph data\n");
-      return 1;
-    }
-  }
-  pBitmap = (uint8_t*)malloc(OUTBUF_SIZE);  // Enough to hold the output
-  if (!pBitmap) {
-    printf("Error allocating memory for bitmap data\n");
-    return 1;
-  }
-
-  // Init FreeType lib, load font
-  if ((err = FT_Init_FreeType(&library))) {
-    printf("FreeType init error: %d", err);
-    return err;
-  }
-
-  // Use TrueType engine version 35, without subpixel rendering.
-  // This improves clarity of fonts since this library does not
-  // support rendering multiple levels of gray in a glyph.
-  // See https://github.com/adafruit/Adafruit-GFX-Library/issues/103
-  FT_UInt interpreter_version = TT_INTERPRETER_VERSION_35;
-  FT_Property_Set(library, "truetype", "interpreter-version", &interpreter_version);
-
-  if ((err = FT_New_Face(library, regularFaceFile, 0, &faceRegular))) {
-    printf("Font load error: %d\n", err);
-    FT_Done_FreeType(library);
-    return err;
-  }
-
-  if (italicFaceFile && (err = FT_New_Face(library, italicFaceFile, 0, &faceItalic))) {
-    printf("Font load error: %d\n", err);
-    FT_Done_FreeType(library);
-    return err;
-  }
-
-  if (boldFaceFile && (err = FT_New_Face(library, boldFaceFile, 0, &faceBold))) {
-    printf("Font load error: %d\n", err);
-    FT_Done_FreeType(library);
-    return err;
-  }
-
-  if (boldItalicFaceFile && (err = FT_New_Face(library, boldItalicFaceFile, 0, &faceBoldItalic))) {
-    printf("Font load error: %d\n", err);
-    FT_Done_FreeType(library);
-    return err;
-  }
-
-  // Shift the size left by 6 because the library uses '26dot6' fixed-point format
-  FT_Set_Char_Size(faceRegular, size << 6, 0, DPI, 0);
-  if (boldFaceFile) FT_Set_Char_Size(faceBold, size << 6, 0, DPI, 0);
-  if (italicFaceFile) FT_Set_Char_Size(faceItalic, size << 6, 0, DPI, 0);
-  if (boldItalicFaceFile) FT_Set_Char_Size(faceBoldItalic, size << 6, 0, DPI, 0);
-
-  // Build intervals with offsets and process glyphs
-  uint32_t glyph_index = 0;
-  for (int iInterval = 0; iInterval < intervalCount; iInterval++) {
-    const uint32_t intervalStart = intervals[iInterval][0];
-    const uint32_t intervalEnd = intervals[iInterval][1];
-
-    // Store interval with offset
-    pIntervals[iInterval].first = intervalStart;
-    pIntervals[iInterval].last = intervalEnd;
-    pIntervals[iInterval].offset = glyph_index;
-
-    // Process each glyph in this interval
-    // Load the codepoint for each style variant
-    for (uint32_t codePoint = intervalStart; codePoint <= intervalEnd; codePoint++) {
-      loadCodePoint(faceRegular, codePoint, pGlyphs, pBitmap, &glyph_index, &iOffset);
-      if (boldFaceFile) loadCodePoint(faceBold, codePoint, pGlyphs, pBitmap, &glyph_index, &iOffset);
-      if (italicFaceFile) loadCodePoint(faceItalic, codePoint, pGlyphs, pBitmap, &glyph_index, &iOffset);
-      if (boldItalicFaceFile) loadCodePoint(faceBoldItalic, codePoint, pGlyphs, pBitmap, &glyph_index, &iOffset);
-    }  // for each code point in interval
-  }  // for each interval
-
-  // Try to create the output file
-  fOut = fopen(outputFile, "w+b");
-  if (!fOut) {
-    printf("Error creating output file: %s\n", outputFile);
-    return 1;
-  }
-
-  epdFontHeader.height = faceRegular->size->metrics.height >> 6;
-  epdFontHeader.ascender = faceRegular->size->metrics.ascender >> 6;
-  epdFontHeader.styles = 0b0001;
-  if (boldFaceFile) epdFontHeader.styles |= 0b0010;
-  if (italicFaceFile) epdFontHeader.styles |= 0b0100;
-  if (boldItalicFaceFile) epdFontHeader.styles |= 0b1000;
-  epdFontHeader.intervalCount = intervalCount;
-  epdFontHeader.glyphCount = totalGlyphs;
-
-  // Write the file header
-  if (bSmallFont) {
-#if SMALL_FONT_ENABLED == 1
-    epdFontHeader.u16Marker = CPF_FONT_MARKER_SMALL;
-    if (faceRegular->size->metrics.height == 0) {
-      // No face height info, assume fixed width and get from a glyph.
-      epdFontHeader.height = pSmallGlyphs[0].height;
-    }
-
-    iLen = sizeof(CrossPointFontHeader) + intervalCount * sizeof(CrossPointFontUnicodeInterval) +
-           totalGlyphs * sizeof(CrossPointFontSmallGlyph) + iOffset;
-    if (bHFile) {  // create an H file of hex values
-      StartHexFile(fOut, iLen, outputFile, size);
-      AddHexBytes(fOut, &epdFontHeader, sizeof(CrossPointFontHeader), 0);
-      // Write the intervals
-      AddHexBytes(fOut, pIntervals, sizeof(CrossPointFontUnicodeInterval) * intervalCount, 0);
-      // Write the glyph table
-      AddHexBytes(fOut, pSmallGlyphs, sizeof(CrossPointFontSmallGlyph) * totalGlyphs, 0);
-      // Write the compressed bitmap data
-      AddHexBytes(fOut, pBitmap, iOffset, 1);
-    } else {
-      fwrite(&epdFontHeader, 1, sizeof(CrossPointFontHeader), fOut);
-      // Write the intervals
-      fwrite(pIntervals, 1, intervalCount * sizeof(CrossPointFontUnicodeInterval), fOut);
-      // Write the glyph table
-      fwrite(pSmallGlyphs, 1, totalGlyphs * sizeof(CrossPointFontSmallGlyph), fOut);
-      // Write the compressed bitmap data
-      fwrite(pBitmap, 1, iOffset, fOut);
-    }
-#else
-    printf("Small font has been disabled\n");
-    return 1;
-#endif
-  } else {
-    epdFontHeader.u16Marker = CPF_FONT_MARKER;
-    if (faceRegular->size->metrics.height == 0) {
-      // No face height info, assume fixed width and get from a glyph.
-      epdFontHeader.height = pGlyphs[0].height;
-    }
-
-    iLen = sizeof(CrossPointFontHeader) + intervalCount * sizeof(CrossPointFontUnicodeInterval) +
-           totalGlyphs * sizeof(CrossPointFontGlyph) + iOffset;
-    if (bHFile) {  // create an H file of hex values
-      StartHexFile(fOut, iLen, outputFile, size);
-      AddHexBytes(fOut, &epdFontHeader, sizeof(CrossPointFontHeader), 0);
-      // Write the intervals
-      AddHexBytes(fOut, pIntervals, sizeof(CrossPointFontUnicodeInterval) * intervalCount, 0);
-      // Write the glyph table
-      AddHexBytes(fOut, pGlyphs, sizeof(CrossPointFontGlyph) * totalGlyphs, 0);
-      // Write the compressed bitmap data
-      AddHexBytes(fOut, pBitmap, iOffset, 1);
-    } else {
-      fwrite(&epdFontHeader, 1, sizeof(CrossPointFontHeader), fOut);
-      // Write the intervals
-      fwrite(pIntervals, 1, intervalCount * sizeof(CrossPointFontUnicodeInterval), fOut);
-      // Write the glyph table
-      fwrite(pGlyphs, 1, totalGlyphs * sizeof(CrossPointFontGlyph), fOut);
-      // Write the compressed bitmap data
-      fwrite(pBitmap, 1, iOffset, fOut);
-    }
-  }  // large fonts
-  fflush(fOut);
-  fclose(fOut);  // done!
-  FT_Done_FreeType(library);
-  printf("Success!\nFont file size: %d bytes (%d glyphs)\n", iLen, totalGlyphs);
-
-  return 0;
-} /* main() */
-
-#endif
@@ -0,0 +1,100 @@
+#include "EpdFont.h"
+
+#include <Utf8.h>
+
+#include <algorithm>
+
+void EpdFont::getTextBounds(const char* string, const int startX, const int startY, int* minX, int* minY, int* maxX,
+                            int* maxY) const {
+  *minX = startX;
+  *minY = startY;
+  *maxX = startX;
+  *maxY = startY;
+
+  if (*string == '\0') {
+    return;
+  }
+
+  int cursorX = startX;
+  const int cursorY = startY;
+  int lastBaseX = startX;
+  int lastBaseAdvance = 0;
+  int lastBaseTop = 0;
+  bool hasBaseGlyph = false;
+  constexpr int MIN_COMBINING_GAP_PX = 1;
+  uint32_t cp;
+  while ((cp = utf8NextCodepoint(reinterpret_cast<const uint8_t**>(&string)))) {
+    const EpdGlyph* glyph = getGlyph(cp);
+
+    if (!glyph) {
+      glyph = getGlyph(REPLACEMENT_GLYPH);
+    }
+
+    if (!glyph) {
+      // TODO: Better handle this?
+      continue;
+    }
+
+    const bool isCombining = utf8IsCombiningMark(cp);
+    int raiseBy = 0;
+    if (isCombining && hasBaseGlyph) {
+      const int currentGap = glyph->top - glyph->height - lastBaseTop;
+      if (currentGap < MIN_COMBINING_GAP_PX) {
+        raiseBy = MIN_COMBINING_GAP_PX - currentGap;
+      }
+    }
+
+    const int glyphBaseX = (isCombining && hasBaseGlyph) ? (lastBaseX + lastBaseAdvance / 2) : cursorX;
+    const int glyphBaseY = cursorY - raiseBy;
+
+    *minX = std::min(*minX, glyphBaseX + glyph->left);
+    *maxX = std::max(*maxX, glyphBaseX + glyph->left + glyph->width);
+    *minY = std::min(*minY, glyphBaseY + glyph->top - glyph->height);
+    *maxY = std::max(*maxY, glyphBaseY + glyph->top);
+
+    if (!isCombining) {
+      lastBaseX = cursorX;
+      lastBaseAdvance = glyph->advanceX;
+      lastBaseTop = glyph->top;
+      hasBaseGlyph = true;
+      cursorX += glyph->advanceX;
+    }
+  }
+}
+
+void EpdFont::getTextDimensions(const char* string, int* w, int* h) const {
+  int minX = 0, minY = 0, maxX = 0, maxY = 0;
+
+  getTextBounds(string, 0, 0, &minX, &minY, &maxX, &maxY);
+
+  *w = maxX - minX;
+  *h = maxY - minY;
+}
+
+const EpdGlyph* EpdFont::getGlyph(const uint32_t cp) const {
+  const EpdUnicodeInterval* intervals = data->intervals;
+  const int count = data->intervalCount;
+
+  if (count == 0) return nullptr;
+
+  // Binary search for O(log n) lookup instead of O(n)
+  // Critical for Korean fonts with many unicode intervals
+  int left = 0;
+  int right = count - 1;
+
+  while (left <= right) {
+    const int mid = left + (right - left) / 2;
+    const EpdUnicodeInterval* interval = &intervals[mid];
+
+    if (cp < interval->first) {
+      right = mid - 1;
+    } else if (cp > interval->last) {
+      left = mid + 1;
+    } else {
+      // Found: cp >= interval->first && cp <= interval->last
+      return &data->glyph[interval->offset + (cp - interval->first)];
+    }
+  }
+
+  return nullptr;
+}
@@ -0,0 +1,14 @@
+#pragma once
+#include "EpdFontData.h"
+
+class EpdFont {
+  void getTextBounds(const char* string, int startX, int startY, int* minX, int* minY, int* maxX, int* maxY) const;
+
+ public:
+  const EpdFontData* data;
+  explicit EpdFont(const EpdFontData* data) : data(data) {}
+  ~EpdFont() = default;
+  void getTextDimensions(const char* string, int* w, int* h) const;
+
+  const EpdGlyph* getGlyph(uint32_t cp) const;
+};
@@ -0,0 +1,46 @@
+// From
+// https://github.com/vroland/epdiy/blob/c61e9e923ce2418150d54f88cea5d196cdc40c54/src/epd_internals.h
+
+#pragma once
+#include <cstdint>
+
+/// Font data stored PER GLYPH
+typedef struct {
+  uint8_t width;        ///< Bitmap dimensions in pixels
+  uint8_t height;       ///< Bitmap dimensions in pixels
+  uint8_t advanceX;     ///< Distance to advance cursor (x axis)
+  int16_t left;         ///< X dist from cursor pos to UL corner
+  int16_t top;          ///< Y dist from cursor pos to UL corner
+  uint16_t dataLength;  ///< Size of the font data.
+  uint32_t dataOffset;  ///< Pointer into EpdFont->bitmap (or within-group offset for compressed fonts)
+} EpdGlyph;
+
+/// Compressed font group: a DEFLATE-compressed block of glyph bitmaps
+typedef struct {
+  uint32_t compressedOffset;  ///< Byte offset into compressed data array
+  uint32_t compressedSize;    ///< Compressed DEFLATE stream size
+  uint32_t uncompressedSize;  ///< Decompressed size
+  uint16_t glyphCount;        ///< Number of glyphs in this group
+  uint16_t firstGlyphIndex;   ///< First glyph index in the global glyph array
+} EpdFontGroup;
+
+/// Glyph interval structure
+typedef struct {
+  uint32_t first;   ///< The first unicode code point of the interval
+  uint32_t last;    ///< The last unicode code point of the interval
+  uint32_t offset;  ///< Index of the first code point into the glyph array
+} EpdUnicodeInterval;
+
+/// Data stored for FONT AS A WHOLE
+typedef struct {
+  const uint8_t* bitmap;                ///< Glyph bitmaps, concatenated
+  const EpdGlyph* glyph;                ///< Glyph array
+  const EpdUnicodeInterval* intervals;  ///< Valid unicode intervals for this font
+  uint32_t intervalCount;               ///< Number of unicode intervals.
+  uint8_t advanceY;                     ///< Newline distance (y axis)
+  int ascender;                         ///< Maximal height of a glyph above the base line
+  int descender;                        ///< Maximal height of a glyph below the base line
+  bool is2Bit;
+  const EpdFontGroup* groups;  ///< NULL for uncompressed fonts
+  uint16_t groupCount;         ///< 0 for uncompressed fonts
+} EpdFontData;
@@ -0,0 +1,29 @@
+#include "EpdFontFamily.h"
+
+const EpdFont* EpdFontFamily::getFont(const Style style) const {
+  // Extract font style bits (ignore UNDERLINE bit for font selection)
+  const bool hasBold = (style & BOLD) != 0;
+  const bool hasItalic = (style & ITALIC) != 0;
+
+  if (hasBold && hasItalic) {
+    if (boldItalic) return boldItalic;
+    if (bold) return bold;
+    if (italic) return italic;
+  } else if (hasBold && bold) {
+    return bold;
+  } else if (hasItalic && italic) {
+    return italic;
+  }
+
+  return regular;
+}
+
+void EpdFontFamily::getTextDimensions(const char* string, int* w, int* h, const Style style) const {
+  getFont(style)->getTextDimensions(string, w, h);
+}
+
+const EpdFontData* EpdFontFamily::getData(const Style style) const { return getFont(style)->data; }
+
+const EpdGlyph* EpdFontFamily::getGlyph(const uint32_t cp, const Style style) const {
+  return getFont(style)->getGlyph(cp);
+};
@@ -0,0 +1,23 @@
+#pragma once
+#include "EpdFont.h"
+
+class EpdFontFamily {
+ public:
+  enum Style : uint8_t { REGULAR = 0, BOLD = 1, ITALIC = 2, BOLD_ITALIC = 3, UNDERLINE = 4 };
+
+  explicit EpdFontFamily(const EpdFont* regular, const EpdFont* bold = nullptr, const EpdFont* italic = nullptr,
+                         const EpdFont* boldItalic = nullptr)
+      : regular(regular), bold(bold), italic(italic), boldItalic(boldItalic) {}
+  ~EpdFontFamily() = default;
+  void getTextDimensions(const char* string, int* w, int* h, Style style = REGULAR) const;
+  const EpdFontData* getData(Style style = REGULAR) const;
+  const EpdGlyph* getGlyph(uint32_t cp, Style style = REGULAR) const;
+
+ private:
+  const EpdFont* regular;
+  const EpdFont* bold;
+  const EpdFont* italic;
+  const EpdFont* boldItalic;
+
+  const EpdFont* getFont(Style style) const;
+};
@@ -0,0 +1,147 @@
+#include "FontDecompressor.h"
+
+#include <Logging.h>
+#include <uzlib.h>
+
+#include <cstdlib>
+#include <cstring>
+
+bool FontDecompressor::init() {
+  clearCache();
+  memset(&decomp, 0, sizeof(decomp));
+  return true;
+}
+
+void FontDecompressor::freeAllEntries() {
+  for (auto& entry : cache) {
+    if (entry.data) {
+      free(entry.data);
+      entry.data = nullptr;
+    }
+    entry.valid = false;
+  }
+}
+
+void FontDecompressor::deinit() { freeAllEntries(); }
+
+void FontDecompressor::clearCache() {
+  freeAllEntries();
+  accessCounter = 0;
+}
+
+uint16_t FontDecompressor::getGroupIndex(const EpdFontData* fontData, uint16_t glyphIndex) {
+  for (uint16_t i = 0; i < fontData->groupCount; i++) {
+    uint16_t first = fontData->groups[i].firstGlyphIndex;
+    if (glyphIndex >= first && glyphIndex < first + fontData->groups[i].glyphCount) {
+      return i;
+    }
+  }
+  return fontData->groupCount;  // sentinel = not found
+}
+
+FontDecompressor::CacheEntry* FontDecompressor::findInCache(const EpdFontData* fontData, uint16_t groupIndex) {
+  for (auto& entry : cache) {
+    if (entry.valid && entry.font == fontData && entry.groupIndex == groupIndex) {
+      return &entry;
+    }
+  }
+  return nullptr;
+}
+
+FontDecompressor::CacheEntry* FontDecompressor::findEvictionCandidate() {
+  // Find an invalid slot first
+  for (auto& entry : cache) {
+    if (!entry.valid) {
+      return &entry;
+    }
+  }
+  // Otherwise evict LRU
+  CacheEntry* lru = &cache[0];
+  for (auto& entry : cache) {
+    if (entry.lastUsed < lru->lastUsed) {
+      lru = &entry;
+    }
+  }
+  return lru;
+}
+
+bool FontDecompressor::decompressGroup(const EpdFontData* fontData, uint16_t groupIndex, CacheEntry* entry) {
+  const EpdFontGroup& group = fontData->groups[groupIndex];
+
+  // Free old buffer if reusing a slot
+  if (entry->data) {
+    free(entry->data);
+    entry->data = nullptr;
+  }
+  entry->valid = false;
+
+  // Allocate output buffer
+  auto* outBuf = static_cast<uint8_t*>(malloc(group.uncompressedSize));
+  if (!outBuf) {
+    LOG_ERR("FDC", "Failed to allocate %u bytes for group %u", group.uncompressedSize, groupIndex);
+    return false;
+  }
+
+  // Decompress using uzlib
+  const uint8_t* inputBuf = &fontData->bitmap[group.compressedOffset];
+
+  uzlib_uncompress_init(&decomp, NULL, 0);
+  decomp.source = inputBuf;
+  decomp.source_limit = inputBuf + group.compressedSize;
+  decomp.dest_start = outBuf;
+  decomp.dest = outBuf;
+  decomp.dest_limit = outBuf + group.uncompressedSize;
+
+  int res = uzlib_uncompress(&decomp);
+
+  if (res < 0 || decomp.dest != decomp.dest_limit) {
+    LOG_ERR("FDC", "Decompression failed for group %u (status %d)", groupIndex, res);
+    free(outBuf);
+    return false;
+  }
+
+  entry->font = fontData;
+  entry->groupIndex = groupIndex;
+  entry->data = outBuf;
+  entry->dataSize = group.uncompressedSize;
+  entry->valid = true;
+  return true;
+}
+
+const uint8_t* FontDecompressor::getBitmap(const EpdFontData* fontData, const EpdGlyph* glyph, uint16_t glyphIndex) {
+  if (!fontData->groups || fontData->groupCount == 0) {
+    return &fontData->bitmap[glyph->dataOffset];
+  }
+
+  uint16_t groupIndex = getGroupIndex(fontData, glyphIndex);
+  if (groupIndex >= fontData->groupCount) {
+    LOG_ERR("FDC", "Glyph %u not found in any group", glyphIndex);
+    return nullptr;
+  }
+
+  // Check cache
+  CacheEntry* entry = findInCache(fontData, groupIndex);
+  if (entry) {
+    entry->lastUsed = ++accessCounter;
+    if (glyph->dataOffset + glyph->dataLength > entry->dataSize) {
+      LOG_ERR("FDC", "dataOffset %u + dataLength %u out of bounds for group %u (size %u)", glyph->dataOffset,
+              glyph->dataLength, groupIndex, entry->dataSize);
+      return nullptr;
+    }
+    return &entry->data[glyph->dataOffset];
+  }
+
+  // Cache miss - decompress
+  entry = findEvictionCandidate();
+  if (!decompressGroup(fontData, groupIndex, entry)) {
+    return nullptr;
+  }
+
+  entry->lastUsed = ++accessCounter;
+  if (glyph->dataOffset + glyph->dataLength > entry->dataSize) {
+    LOG_ERR("FDC", "dataOffset %u + dataLength %u out of bounds for group %u (size %u)", glyph->dataOffset,
+            glyph->dataLength, groupIndex, entry->dataSize);
+    return nullptr;
+  }
+  return &entry->data[glyph->dataOffset];
+}
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <uzlib.h>
+
+#include <cstdint>
+
+#include "EpdFontData.h"
+
+class FontDecompressor {
+ public:
+  bool init();
+  void deinit();
+
+  // Returns pointer to decompressed bitmap data for the given glyph.
+  // Valid until LRU eviction (safe for the duration of one glyph render).
+  const uint8_t* getBitmap(const EpdFontData* fontData, const EpdGlyph* glyph, uint16_t glyphIndex);
+
+  // Evict all cached decompressed groups (call between pages for within-page-only caching).
+  void clearCache();
+
+ private:
+  static constexpr uint8_t CACHE_SLOTS = 4;
+
+  struct CacheEntry {
+    const EpdFontData* font = nullptr;
+    uint16_t groupIndex = 0;
+    uint8_t* data = nullptr;
+    uint32_t dataSize = 0;
+    uint32_t lastUsed = 0;
+    bool valid = false;
+  };
+
+  struct uzlib_uncomp decomp = {};
+  CacheEntry cache[CACHE_SLOTS] = {};
+  uint32_t accessCounter = 0;
+
+  void freeAllEntries();
+  uint16_t getGroupIndex(const EpdFontData* fontData, uint16_t glyphIndex);
+  CacheEntry* findInCache(const EpdFontData* fontData, uint16_t groupIndex);
+  CacheEntry* findEvictionCandidate();
+  bool decompressGroup(const EpdFontData* fontData, uint16_t groupIndex, CacheEntry* entry);
+};
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <builtinFonts/bookerly_12_bold.h>
+#include <builtinFonts/bookerly_12_bolditalic.h>
+#include <builtinFonts/bookerly_12_italic.h>
+#include <builtinFonts/bookerly_12_regular.h>
+#include <builtinFonts/bookerly_14_bold.h>
+#include <builtinFonts/bookerly_14_bolditalic.h>
+#include <builtinFonts/bookerly_14_italic.h>
+#include <builtinFonts/bookerly_14_regular.h>
+#include <builtinFonts/bookerly_16_bold.h>
+#include <builtinFonts/bookerly_16_bolditalic.h>
+#include <builtinFonts/bookerly_16_italic.h>
+#include <builtinFonts/bookerly_16_regular.h>
+#include <builtinFonts/bookerly_18_bold.h>
+#include <builtinFonts/bookerly_18_bolditalic.h>
+#include <builtinFonts/bookerly_18_italic.h>
+#include <builtinFonts/bookerly_18_regular.h>
+#include <builtinFonts/notosans_8_regular.h>
+#include <builtinFonts/notosans_12_bold.h>
+#include <builtinFonts/notosans_12_bolditalic.h>
+#include <builtinFonts/notosans_12_italic.h>
+#include <builtinFonts/notosans_12_regular.h>
+#include <builtinFonts/notosans_14_bold.h>
+#include <builtinFonts/notosans_14_bolditalic.h>
+#include <builtinFonts/notosans_14_italic.h>
+#include <builtinFonts/notosans_14_regular.h>
+#include <builtinFonts/notosans_16_bold.h>
+#include <builtinFonts/notosans_16_bolditalic.h>
+#include <builtinFonts/notosans_16_italic.h>
+#include <builtinFonts/notosans_16_regular.h>
+#include <builtinFonts/notosans_18_bold.h>
+#include <builtinFonts/notosans_18_bolditalic.h>
+#include <builtinFonts/notosans_18_italic.h>
+#include <builtinFonts/notosans_18_regular.h>
+#include <builtinFonts/opendyslexic_10_bold.h>
+#include <builtinFonts/opendyslexic_10_bolditalic.h>
+#include <builtinFonts/opendyslexic_10_italic.h>
+#include <builtinFonts/opendyslexic_10_regular.h>
+#include <builtinFonts/opendyslexic_12_bold.h>
+#include <builtinFonts/opendyslexic_12_bolditalic.h>
+#include <builtinFonts/opendyslexic_12_italic.h>
+#include <builtinFonts/opendyslexic_12_regular.h>
+#include <builtinFonts/opendyslexic_14_bold.h>
+#include <builtinFonts/opendyslexic_14_bolditalic.h>
+#include <builtinFonts/opendyslexic_14_italic.h>
+#include <builtinFonts/opendyslexic_14_regular.h>
+#include <builtinFonts/opendyslexic_8_bold.h>
+#include <builtinFonts/opendyslexic_8_bolditalic.h>
+#include <builtinFonts/opendyslexic_8_italic.h>
+#include <builtinFonts/opendyslexic_8_regular.h>
+#include <builtinFonts/ubuntu_10_bold.h>
+#include <builtinFonts/ubuntu_10_regular.h>
+#include <builtinFonts/ubuntu_12_bold.h>
+#include <builtinFonts/ubuntu_12_regular.h>
--- a/Show More
+++ b/Show More