zoetrope
Watch a Claude Code session as a live flow graph, in your terminal or your browser.
zoetrope.furkankly.dev · the whole app in your browser, the same binary compiled to WASM
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.
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
- A node per agent: the main session, its subagents, and workflow groups with their
children nested underneath
- Status, current tool, tool count and output tokens on every card
- Edges animate while an agent is working, and settle when it finishes
- Tool calls surface as chips beneath their agent (
⚒ bash ×5, or ⚒ bash 0.5s
ticking during a single call), resolving to ✓ or ✗
- A minimap showing where your viewport sits once the graph outgrows the screen
Time travel
- One scrubbable timeline over both live and replayed sessions
- Indexed by event rather than wall-clock, so a busy minute gets room instead of
collapsing into a sliver
- Scrub, pause, step between prompt eras, or snap back to the live edge
- Seek backwards and you see the session exactly as it stood at that moment. Agents
un-finish, tool counts fall, the graph shrinks back
- Optional gap compression, to skip dead air or keep faithful real-time pacing
Inspection
- Click any agent for its provenance: the prompt that spawned it, the reasoning
around it, its model, and every tool call it made with timings
- Session info overlay: mode, permissions, queued ops, file edits, last prompt
zoe inspect prints the whole tree headlessly, so it runs anywhere without a TTY
Reading your sessions
- Follows a running session live, or replays a finished one
- Reads everything a session writes: the main transcript, its subagents, and
workflows with their own children, so the graph is the whole picture
- Keeps going when Claude Code writes something it hasn't seen: unfamiliar records
are skipped, never fatal
- Read-only, and no network at all (see below)
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:
Or drive it yourself: pan, zoom where you point, open an agent's panel, and drag the
scrubber to travel back through the session.
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:
- Two clocks, kept apart. Content time comes from the transcript's own timestamps;
presentation time is the playhead you control. Every pacing decision (speed, gap
compression, scrubbing) touches only the second one, so no display choice can ever
alter what the session says happened.
- One timeline for live and replay. Behind the live edge it paces forward; at the
edge it pins and folds in new appends as they land. A live session and a saved
recording differ only in where the playhead starts. Same engine, same controls.
- Ground truth over heuristics. Parentage, completion and naming come from what the
format actually records (a subagent's
toolUseId, a workflow's runId, a journal
result) rather than from guessing at strings or timing.
- You own the camera, not the history. The recording is immutable and the graph
never rearranges itself under you (
r to relayout). The camera follows the action
until you touch it, then stays where you put it.
- Zero network, provably. There is no HTTP client anywhere in the dependency tree,
and
tokio is pulled in without its net feature. cargo tree is the proof. This is
a property you can check, not a promise.
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.
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.
- This project follows Conventional Commits for all commit messages (e.g.
feat(timeline): index the playhead by event instead of wall-clock, fix(tailer): fold appends at the live edge without rebuilding). The changelog is generated from them with git-cliff, and non-conforming commits are dropped.
- Run
cargo fmt, cargo clippy and cargo test before opening a PR.
- Those cover the portable core and the native frontend. The browser frontend is a
second crate (
zoetrope-web, in web/wasm/) that only builds for wasm32, so it is
excluded from the root workspace and no root cargo command touches it. From the
repo root, build it with bash web/scripts/build-wasm.sh and lint it with
cd web/wasm && cargo clippy (its .cargo/config.toml defaults the target to wasm32).
License
MIT.
Acknowledgements
Zoetrope 把 Claude Code（或 Codex）编程智能体会话变成实时动态的流程图，展示主智能体、它的子智能体和工作流以及每一次工具调用，你可以在终端或浏览器中观看。