rexpad

A live todo list for coding agents, drawn in a Rex
pane beside the agent.

When an agent starts a multi-step task, it writes its plan to rexpad and opens
a pane next to its own. As it works, it checks items off and moves the
highlight to whatever it's doing now. You can see the plan, the progress, and
what's left at a glance, without scrolling back through the transcript.

• Drawn, not printed. The list is a real image sent with the kitty
  graphics protocol: SF Pro text, progress rings, and checkboxes, rendered at
  your display's pixel density.
• Follows your theme. Colors come from the Rex theme you're using and
  update when you switch themes.
• Made for agents. A short CLI, a Markdown checklist format, and an agent
  skill that teaches Claude Code (or any agent that reads skills) when and how
  to use it.
• One list per agent. Each agent pane gets its own list automatically.

Requirements

• Rex on macOS or Linux. The viewer works in
  any terminal that supports the kitty graphics protocol, but opening the pane
  automatically needs Rex.
• Go 1.27 or later to build it.
• For the exact look on macOS, the static SF Pro fonts from
  developer.apple.com/fonts. The system's
  built-in SF can't be loaded by the renderer. Without them rexpad uses Inter
  if installed, then Go's bundled fonts.

Install

1. Install the binary

go install github.com/almonk/rexpad@latest

This puts rexpad in $(go env GOPATH)/bin (usually ~/go/bin). Make sure
that directory is on your PATH.

Or build from a clone:

git clone https://github.com/almonk/rexpad
cd rexpad
make install   # builds ~/.local/bin/rexpad and links the skill (see below)

2. Install the agent skill

The skill is what tells your agent to use rexpad. It's built into the binary:

rexpad skill install

That writes ~/.claude/skills/rexpad/SKILL.md, where Claude Code finds it.
New Claude Code sessions pick it up automatically; check with /skills, or
invoke it directly with /rexpad.

For other agents, install it into their skills directory instead:

rexpad skill install --dir ~/.codex/skills   # Codex
rexpad skill show                            # print it, to paste anywhere else

make install links the skill to the repo instead of copying it, so edits to
skills/rexpad/SKILL.md take effect immediately while you work on rexpad.

3. Try it

In a Rex terminal:

rexpad set <<'EOF'
# Try rexpad
- [x] Install the binary
- [~] Open the pane
- [ ] Ask an agent for a multi-step task
EOF
rexpad show

A pane opens on the right, taking 30% of the width, without taking focus. Run
rexpad next a few times and watch it update.

Scrolling

Long lists follow the active item on their own. To look around yourself, use
the trackpad or mouse wheel over the pane, or click into it and use the keys:

Finding

The list is drawn as an image, so the terminal's own find can't see its
text. Press / (or Ctrl-F) in the pane to open rexpad's find bar instead.

The query is fuzzy: its letters have to appear in order, but not next to each
other, so bld finds "build". Spaces split it into terms that must all
match, in any order. Case is ignored unless you type a capital. As you type,
the list folds down to the matching items, each kept under its group's header,
and the matched letters are highlighted. The match you're on gets an outline.

Using it with an agent

You don't need to do anything once the skill is installed: when you give the
agent a task with several steps, it writes its plan and opens the pane. You can
also ask for it directly: "show your plan", "keep a todo list", "what are you
working on?"

Under the hood the agent runs commands like these:

rexpad set <<'EOF'          # write the whole plan
# Fix
- [~] Guard the missing session in SidebarView
- [ ] Add a regression test
EOF
rexpad show                 # open the pane (does nothing if it's already open)
rexpad next                 # finish the current item, start the next
rexpad add "Bump the dependency pin"
rexpad done 4

The checklist format

# Group title
- [ ] pending item
- [~] active item (working on it now; [>] and [/] work too)
- [x] done item

Each # Group gets a progress ring that fills as its items are done, with
the active item counting half. rexpad get prints the list back with each
item's ID as {#ID}, and rexpad set --json takes the same list as JSON.

Commands

rexpad [--list NAME] COMMAND

Showing the list
  show [--below] [--ratio PCT] [--theme T]  open the viewer beside your pane (30%, no focus change)
  hide                                      close the viewer pane
  view [--theme terminal|light|dark]        run the viewer in the current terminal (q quits)
  render -o FILE.png [--width PT]           write a PNG of the list

Writing the whole list
  set [--json]      replace the list from stdin (Markdown checklist or JSON)
  get [--json]      print the list with item IDs
  clear             empty the list

Changing items
  group TITLE                    add a group; later adds go to it
  add [-g GROUP] TEXT            add an item, prints its ID
  start ID                       make ID the active item
  done [ID...]                   check items off (no ID: the active item)
  next                           finish the active item, start the next one
  undo ID...                     mark pending again
  edit ID TEXT / rm ID...
  progress GROUP PCT|auto        pin a group's ring, or go back to counting items

Agent skill
  skill install [--dir DIR]      install the skill (default ~/.claude/skills)
  skill show                     print the skill

rexpad help prints the full reference.

Configuration

How it works

• State: each list is a JSON file in ~/.local/state/rexpad. Commands
  read it, change it, and write it back atomically.
• The viewer (rexpad view) is what runs in the pane. It checks the file
  every 150 ms and renders the whole list to one tall PNG at the pane's pixel
  density, which it uploads once with the kitty graphics protocol. Scrolling
  moves the placement's crop window over that image, so it costs a few bytes
  per step rather than a new image. The placement is pinned to the pane's
  columns and rows, so a client with different cell metrics (such as Rex on a
  phone) scales it to fit instead of overflowing. New images are placed before
  old ones are deleted, so updates don't flicker.
• Find: rows fold away like an accordion. Only how open each row is
  eases; where the rows sit follows from that, so folding neighbors never
  overlap. Mid-fold, every frame is a new image the size of the view, about
  60 a second. Once the rows settle, the viewer goes back to one tall sheet.
• Theme: the viewer asks the terminal for its foreground, background, and
  blue (OSC 10, 11, and 4), and mixes the grays from those in the same
  proportions as the light design. It asks again every 2 seconds and whenever
  the terminal reports a color-scheme change.
• The pane: show runs rex split beside $REX_BLOCK without taking
  focus, then sets the 70/30 ratio with rex block move, and remembers the
  pane so it doesn't open a second one.

Development

make build     # ./rexpad
make test
make install   # ~/.local/bin/rexpad, plus a symlinked skill

The layout constants in render.go are in points, measured against a 2x
reference design. rexpad render -o out.png is the quickest way to check a
change.

License

MIT