zoetrope README

The project's README from github.com/furkankly/zoetrope. As one markdown file: README.md.

zoetrope

Watch a Claude Code session as a live flow graph, in your terminal or your browser.

crates.io docs.rs downloads build status minimum supported Rust version

zoetrope.furkankly.dev · the whole app in your browser, the same binary compiled to WASM

A session drawn as a flow graph: a main agent above the subagents it spawned, over a timeline of tool activity

Claude Code writes a JSONL transcript for every session under ~/.claude/projects/. zoetrope reads it and draws the session as a graph in your terminal: the main agent, the subagents and workflows it spawns, and the tools each one runs, updating live as it goes. Point it at a finished run and it replays, paced by the session's own timestamps. Point it at a running one and it follows along. It's read-only, and nothing leaves your machine.

Built on ratatui and rataflow.

zoetrope replaying a Claude Code session as a flow graph

Installation

Homebrew — macOS and Linux:

brew install furkankly/tap/zoetrope

Cargo — needs a Rust toolchain:

cargo install zoetrope

Prebuilt binaries — no toolchain needed. Every release carries archives for macOS (Apple Silicon and Intel), Linux (musl, arm64 and x86_64) and Windows (x86_64). Unpack one and put zoe on your PATH.

Whichever route you take, the command is zoe. Or build from source:

git clone https://github.com/furkankly/zoetrope
cd zoetrope
cargo build --release
./target/release/zoe

No install at all: try it in your browser. Drop a transcript on the page and get the same graph.

Usage

zoe                          # follow the current project's live session
zoe <dir>                    # follow another project's session
zoe <file.jsonl>             # replay a recording from the start
zoe <file.jsonl> --follow    # open a recording at its live edge
zoe <file.jsonl> --speed N   # playback speed (default 8.0)
zoe inspect <file.jsonl>     # print the session tree and exit (no TUI)

Give it a file and it reads the whole transcript, then keeps watching for new lines. Give it a directory, or no argument at all, and it finds the newest session in that project and follows it live. Whichever way you start, the controls are the same: scrub, follow, pause, jump back to live.

The same engine also runs in the browser, compiled to WebAssembly via ratzilla. Open a session from disk, or drop a transcript on the page. It stays local there too.

Features

The graph

Time travel

Inspection

Reading your sessions

Keys

space play/pause · [ ] prev/next prompt · End or g jump to live · drag the bar to seek · ? for everything else.

Full keymap
Key Action
space play / pause (resumes from the playhead)
[ / ] previous / next prompt era
End / g jump to the live edge
s toggle gap compression (faithful pacing vs. skip idle stretches)
mouse drag seek along the scrubber
o / f camera: Overview / Follow
r relayout (tidy the graph)
arrows / Tab / Shift-Tab move between agents
h j k l pan the graph
+ / - / 0 zoom in / out / reset
c center on the selected agent
click open an agent's detail panel
j / k / PgUp / PgDn scroll the detail panel
i session info overlay
? help overlay
esc close an overlay / clear the selection
q / ctrl-c quit

j / k scroll the detail panel when an agent is selected, otherwise they pan the graph.

Hand the camera to the action with f and it glides to whichever agent just did something. This is what watching a live run looks like:

zoetrope in follow mode, the camera tracking whichever agent is working

Or drive it yourself: pan, zoom where you point, open an agent's panel, and drag the scrubber to travel back through the session.

Panning, zooming, opening a detail panel, and dragging the scrubber

Under the Hood

zoetrope treats the transcript as an append-only event log. It tails the files, parses each line defensively, and folds them into a derived model of agents, tool calls, and prompts. Nothing is mutated in place. The model is a pure function of the facts seen so far, so seeking backwards is exact.

A few of the pieces that turn a log into a watchable session:

The model, the timeline and the rendering all live in the portable core, a library with no IO that compiles for any target, including WebAssembly. The native frontend (the zoe binary in this crate) and the browser frontend (the zoetrope-web crate under web/wasm/, which runs the hosted app) sit on top of it and differ only in their IO and event loop.

See docs/DESIGN.md for the module map and the transcript format, and docs/ARCHITECTURE.md for the invariants above in full.

A note on the transcript format

The JSONL format zoetrope reads is undocumented and internal to Claude Code, so it can change without warning. zoetrope is built to degrade rather than break: unrecognized records are skipped, missing fields fall back, and a malformed line never takes down the session. If a new Claude Code release makes something render oddly, please open an issue.

Contributing

Pull requests are welcome.

License

MIT.

Acknowledgements

zoetrope (furkankly/zoetrope)

Searching Database…

What is this?Zoetrope turns a Claude Code (or Codex) coding-agent session into a live, animated flow graph showing the main agent, its subagents and workflows, and every tool call, which you can watch in your terminal or in a browser.
Is this a terminal app or a browser app?Both: the native build is a terminal UI made with ratatui, and the exact same engine is compiled to WebAssembly so it runs as a hosted web page too — you can just drop a transcript file on the page with no install at all.
How do I install and run it?Install via Homebrew on macOS/Linux, via Cargo if you have a Rust toolchain, or download a prebuilt binary for macOS (Apple Silicon or Intel), Linux (musl, arm64/x86_64) or Windows (x86_64); whichever way, the command is `zoe`, pointed at a transcript file or a project directory.
Do I need Claude Code already set up to use this?Yes — zoetrope only reads the JSONL transcript Claude Code writes for every session under ~/.claude/projects/, so you need to have already run (or be running) a Claude Code session; it needs no API key or account of its own.
What happens if Claude Code changes its transcript format?The JSONL format is undocumented and internal to Claude Code, so it can change without warning; zoetrope is built to degrade rather than break, skipping records it doesn't recognize instead of crashing.
Does any of my session data leave my machine?No — zoetrope is read-only and has zero network access; there's no HTTP client anywhere in its dependency tree and the tokio dependency is pulled in without its networking feature, which you can verify yourself with cargo tree.
What does a node in the live graph actually show me?Each card is an agent — the main session, a subagent, or a workflow group with its children nested underneath — showing status, current tool, tool count and output tokens, with tool calls appearing as chips underneath that resolve to a checkmark or an X.
Can I rewind and replay a session after it's finished?Yes, there's a scrubbable timeline indexed by event rather than wall-clock, so you can seek backwards and watch agents un-finish and tool counts fall back exactly to how the session stood at that moment, with optional gap compression to skip dead air.
Can I inspect exactly what one agent did, in detail?Clicking any agent opens its provenance panel: the prompt that spawned it, its model, the reasoning around it, and every tool call with timings; `zoe inspect` dumps the whole tree headlessly so it works even without a terminal.
Why build a graph viewer instead of just reading the raw log?The raw transcript is a flat append-only event log that's hard to follow line by line; zoetrope folds it into a derived model of agents, tool calls and prompts so parentage, timing and completion become something you can actually watch unfold.
Creator
furkankly
Size
11.6 MB
Stars
1K
Age
1mo
Commits · 90 Days