Early alpha · rebuilt with AI coding agents

The comic editor that refused to die.

TBO was a small GPL comic editor written in C and GTK 3, left unmaintained in 2013. In 2026 it came back as TBO 2 — a modern Python + PyQt6 rewrite that still reads and writes the original .tbo documents.

It opens, edits and exports real documents today. It is also unfinished, and it is early enough that a single afternoon of work makes a visible difference.

Help us finish it View the source

Python 3.11–3.12
PyQt6 6.6+
GPL-3.0-or-later
Windows · macOS · Linux

See it work

From a blank page to a panel with a character

Thirty seconds, recorded unedited from the Linux build in the releases — not a mockup and not a design concept. The same build runs on Windows and macOS.

Screen recording of TBO 2 on Linux: a blank page is opened, a cartoon character is picked from the asset library and lands on the canvas inside a selection box, a speech bubble is added from the Bubbles tab, the words are typed into it, and the bubble is dragged up next to the character's head. — An empty page, then four steps: pick a character from the **asset library**, drop it on the page, add a **speech bubble**, type into it and drag it into place.

It reads the real format

The .tbo files from 2013 open as they are. TBO 2 writes the same unversioned v1 format back — chosen for compatibility with the historical application, not replaced by a new one.

The library is just files

Characters, props and bubbles are SVG files in folders. Drop your own under ~/.local/share/tbo/doodle/ in the same layout and they are merged into the matching categories — no conversion, no plugin API.

Export, not screenshots

Pages go out as PNG, a multi-page PDF and SVG, rendered by the same code that draws the canvas — so a panel stays vector and crisp instead of being flattened at screen resolution.

Call for contributors

This is a very early build, and that is the opportunity

TBO 2 is nowhere near feature parity with the original. Pages, panels, text, images, undo/redo and export work; a great deal around them does not yet. The roadmap marks each phase with verifiable exit criteria, and several of them are open.

You do not need to be a Qt expert. The project is developed with AI coding agents, the whole workflow is written down, and each task below is small enough to finish and verify in one sitting.

Testing

Visual regression tests with reference images; make the Qt integration tests run headless under Xvfb so they stop being local-only.

Documentation

Write docs/file-format-v1.md from the observed behaviour of the legacy reader, and a manual behaviour checklist for TBO 1.0.

Model and canvas

Keep identifiers stable between domain objects and their QGraphicsItem counterparts — a small change with wide effects.

Fixtures

Add .tbo files that exercise Unicode, long paths, external images, transforms, several pages and missing resources.

Tooling

Adopt an automatic formatter and a shared EditorConfig so diffs stay about the change and not about whitespace.

Packaging

A Flatpak build that works again, and a release job that publishes artifacts instead of letting CI artifacts expire.

The rules are short: keep each change small, add a test or explain how you verified it by hand, treat the document model as the source of truth, and never mix formatting, refactoring and behaviour in one pull request.

Read the roadmap Find something to fix Ask a question

What already works

A real editor, not a mock-up

Everything below runs in the alpha. It is not the whole picture, but it is a foundation worth building on.

Create, open, save `.tbo`

Reads and writes the legacy v1 format with a safe parser, size limits and atomic saves.

Pages and panels

Add, delete, reorder and navigate pages and panels. All reversible.

Text objects

Add, move, clone and delete text with font, size, colour, bold, italic and underline.

Raster images

Import PNG or JPEG into panels. Missing resources render as dashed placeholders instead of crashing.

SVG artwork

Drop doodles, speech bubbles and character parts straight onto a panel.

Undo and redo

Every mutation goes through a QUndoStack command, so the history is complete.

Export PNG · PDF · SVG

A single renderer draws both the canvas and the exported file — what you see is what you get.

Asset library

Searchable doodles, bubbles and accessories, plus a buildable character from heads, eyes, mouths and ears.

Presentation mode

Full-screen reading with keyboard navigation.

Find text

Search every text object in the document and jump to the match.

Session recovery

.bak backups and a periodic .autosave — your original is never overwritten silently.

Themes and HiDPI

System, dark and light themes, remembered between runs, with high-DPI scaling.

Downloads

Take it for a spin

Four builds, one per platform. All of them are unsigned and clearly marked as an early version — please treat them that way.

Platform	File	How to run it
Windows 10/11 (x64)	`TBO-2.0.0.dev0-Windows-x64-portable.zip`	Extract anywhere and run `TBO.exe`. Portable: no installer, no Python needed.
macOS (Intel)	`tbo-macos.zip`	Unzip to get `TBO.app`. It is not signed or notarized, so on first launch use right-click → Open.
Linux — any distribution	`TBO-2.0.0.dev0-x86_64.AppImage`	`chmod +x` it, then run it. Needs FUSE; without it, add `--appimage-extract-and-run`.
Debian / Ubuntu	`tbo_2.0.0.dev0-1_all.deb`	`sudo apt install ./tbo_2.0.0.dev0-1_all.deb`. Uses the distribution's `python3-pyqt6` rather than bundling Qt.

Go to the releases Or run it from source

Check before you run

Verify the binaries yourself

A download page that says "trust us" is worth very little. Everything needed to check these files independently is public: the source, the build workflow, the checksums, and a scan report for each artifact.

Artifact	VirusTotal	Report
Linux AppImage	0 / 64	open
Linux `.deb`	0 / 61	open
macOS	0 / 73	open
Windows portable	0 / 66	open

All four scored zero detections when built on 2026-10-14. Read that as what it is: VirusTotal aggregates third-party engines and produces no verdicts of its own, the scores drift as engines update, and several Windows-only engines cannot process an AppImage or a .deb at all.

See the scan screenshots Read the build workflow

Download the artifact.
Hash it: sha256sum <file>.
Compare it against SHA256SUMS in the release.
Open virustotal.com/gui/file/<that hash> to see the report for those exact bytes.

How to contribute

Bring your AI agent

TBO was revived with OpenCode + DeepSeek, and the same workflow is open to you. Clone the repository, point your agent at the roadmap, run the tests, open a pull request. The full instructions live in the contribution guide.

Clone it, with the submodule

git clone --recurse-submodules https://github.com/wachin/TBO.git
cd TBO

Set up an environment

python3 -m venv .venv
source .venv/bin/activate      # Windows: .venv\Scripts\activate
pip install -e ".[dev]"

Check that it runs before you change anything
```
./tbo.sh data/tut.tbo
pytest tests/unit -q
```
Hand your agent the first prompt

This is the prompt that started the project. It tells the agent to explore before touching anything, propose a plan, and wait for approval.

first-prompt.txt

You are working on TBO, a comic editor originally written in C and GTK 3
(unmaintained since 2013). The legacy source code lives in the `legacy/`
directory at the repository root.

Your task is to port this program to Python and PyQt6 as TBO 2. Before
modifying anything, do the following in order:

1. EXPLORE — Read the legacy code under `legacy/src/` and the historical
   documentation. Do NOT modify or create any files yet. Summarize:
   - what the application does (its features and data model);
   - the structure of the legacy `.tbo` format;
   - the main architectural pieces (model, canvas, tools, save/load, export);
   - which behaviors must be preserved for compatibility.

2. PLAN — Propose a ROADMAP.md for the modernization to PyQt6, with phases
   and exit criteria, following these principles:
   - Reimplement, do not transliterate.
   - The document model must be independent of Qt widgets (plain dataclasses).
   - Every document change must be an undoable command (QUndoStack).
   - Read/write the legacy .tbo v1 format with a safe parser: size limits,
     strict validation, contextual errors, and atomic saves.
   - The legacy code stays in `legacy/` as a reference oracle.

3. After I approve the plan, start with the first phase: a small, installable,
   testable Python skeleton.

Throughout the work:
- Re-check the current state of the repository before modifying files.
- Run the test suite after meaningful changes and keep it green.
- Use clear conventional commit messages, one logical change per commit.
- Ask me when a decision affects compatibility, licensing, or the file format
  instead of guessing.

The prompt is not a magic trick. What makes it work is the third step: it forces the agent to read the legacy code and agree on a plan before writing a line, which is what keeps a long session from drifting.

Already using OpenCode? There are notes on running it on Linux and Termux with free DeepSeek access in AGENTS/.

Where the project is

The road to 2.0

The roadmap is organised in phases, and each phase ends with exit criteria rather than a date. The next one starts when the previous one is verifiably done.

0Preserve and specifyKeep the historical release, gather fixtures, document the observed format.
1Reproducible Python skeletonPackaging, entry point, test and lint tooling, CI on both supported Pythons.
2Model and .tbo compatibilitySafe parser, atomic writer, round-trip tests, fuzzing.
3Canvas and renderingScene and view, transforms, zoom, and one renderer shared by screen and export.
4Editing and undo/redoEvery mutation as a command, with the full editing surface covered.
5Desktop experienceThemes, settings, recovery, HiDPI, accessibility basics.
6Packaging and TBO 2.0Installers for the three platforms and a stable release.
7Beyond 2.0Self-contained format, layers, guides, templates, a CLI.

This list is deliberately not annotated with progress: a status copied into a web page goes stale within a week. The live checklist, with every exit criterion, is ROADMAP.md (in Spanish).