Skip to content

Roadmap

Jump to bottom
Bartłomiej Mucha edited this page Sep 6, 2026 · 1 revision

Roadmap and history

Planned features, the staged build order the project actually followed, and the lessons carried over from the Clip2l prototype that preceded it.

Section numbers here are historical; docs/TODO.md in the library repository is the live list.

New Features (Planned)

Canvas Template Generator

Artists want to work on a larger canvas with visible margin guides so they can safely import layout templates into Procreate before drawing.

The application should generate a PNG template image that shows:

  • The full canvas area (with margins included)
  • Margin zones highlighted in a configurable colour (e.g. pink/magenta)
  • Safe-area boundary lines
  • Slice cut lines at correct vertical intervals

Workflow:

  1. Artist defines a CanvasProfile (see §6) with canvas size, margin sizes, and visual colour.
  2. App generates a template PNG → artist imports it into Procreate as a reference layer.
  3. Artist draws within the safe area on top of the template.

Margin-Aware Import Pipeline

When the artist exports the finished work, the app performs an extended pipeline:

Load source image
  → Crop margins (using stored CanvasProfile margins)
  → Scale to target width
  → [feed into virtual strip as normal]

The margin crop step is deterministic and driven entirely by the saved CanvasProfile — no manual input required at export time.

Future: Web Application

The CLI binary (platemaker) is designed to serve as the backend for a future web interface. A web server (in any language) can:

  • Call platemaker process --workspace project.platemaker.json --json as a subprocess
  • Parse the JSON summary from stdout
  • Stream stderr progress to the browser via WebSocket

This makes the web frontend entirely independent of the C++ codebase. iPad / mobile access is achieved through the browser — no native iOS app required, no Apple Developer Program fee.

Development Roadmap

Stage 1 — Core Library (no UI, no CLI)

  • Set up CMake project with vcpkg manifest (vcpkg.json) and CMakePresets.json
  • Two build presets from day one: windows-msvc and linux-gcc
  • Integrate libvips, nlohmann/json
  • Implement ImageIO with PNG/JPEG/WebP support and per-file error handling
  • Implement PixelBuffer abstraction (RAII wrapper for VipsImage*)
  • Implement Scaler (Lanczos3, aspect-preserving, random access)
  • Implement ScaledStrip (streaming, minimum-RAM policy, sourceMap tracking, all three LastSlicePolicy values)
  • Implement MarginCropper
  • Implement WorkspaceSerializer (read + write + version field + processedFiles)
  • Implement cancellation token (std::atomic<bool>)
  • [-] Unit tests for all Core components (mock ImageIO — no real files required)

Stage 2 — CLI (platemaker)

  • platemaker workspace create command
  • platemaker process command (standard pipeline)
  • platemaker process with margin-aware pipeline
  • --start-index flag
  • --format flag with JPEG options passthrough
  • Incremental processing (SHA-256 check, dirty propagation)
  • --json output mode
  • [-] Drop-in replacement for the Clip2l prototype (deferred — scope unclear)

Stage 3 — Template Generator

  • platemaker template with margins, defined profile name as option
  • Implement TemplateGenerator in Core
  • Verify template PNG imports correctly into Procreate

Stage 4 — Qt GUI (separate repository — platemaker-qt)

See the platemaker-qt repository for the GUI roadmap.

Stage 5 — Polish & Future

  • Lightbox / full-page strip preview
  • Batch processing of multiple chapters
  • Web backend integration testing (subprocess JSON protocol)
  • Additional CanvasProfile presets (manga, American, European formats)

Lessons from the Clip2l Prototype

Key decisions and edge cases discovered during Clip2l development that Platemaker should carry forward:

Sequence mode is the right default. The prototype offered both per-file and sequence modes. In practice sequence mode is always the correct choice for Webtoon output — it should be the only mode in Platemaker.

File ordering is critical and non-obvious. The prototype supports three sort strategies (name, modified date, created date) plus manual reordering and reverse. All three sort modes should be preserved in Platemaker. Manual drag-and-drop reordering with up/down buttons is essential — filename-based sorting is unreliable across different export tools.

Thumbnail loading must be non-blocking. The prototype learned this the hard way with large directories. Loading thumbnails in a background thread while keeping the UI responsive is mandatory.

JPEG output parameters matter for file size. The prototype exposes quality, subsampling, optimize, and progressive flags — these are meaningful for artists publishing online where file size affects upload speed. All four should be preserved in Platemaker's JPEG output profile.

Cancel is not trivial. The prototype has a cancel stub that warns the user it is unimplemented. In Platemaker, cancellation must be properly implemented from day one via a cancellation token. Partial output (slices written before cancel) should be kept, not deleted.

Per-file error resilience. The prototype logs errors per file and continues. This is the correct behaviour — a single corrupt file should not abort a 50-file batch. Skipped files must be reported in the final summary.

Start index / output numbering. The prototype exposes start_postfix for CLI. This is useful when a chapter is processed in multiple runs (e.g. first half and second half separately). The --start-index flag should be preserved.

End of specification. Update this document whenever a significant architectural decision is made or a planned feature changes scope.

See also: Home · Workspace · Project · Render · Preview · Canvas-Profiles · Processing-Steps · Components · CLI · Platform · Roadmap · Diagrams

libplatemaker

Foundations

Reference

Clone this wiki locally