dot
Too small to name.
Below a few pixels a box merges into its parent. You see mass: where the lines are.
label
A name on a box.
Between about 20 and 80 pixels a box shows its name. Folders have a header strip; docs and test folders carry a faint tint.
card
A summary you can act on.
Kind, lines, a metric readout, and any note pinned beside it. The churn stripe on the left edge is readable here.
```
pub fn render(tree: &SymbolTree) -> String {
    let mut out = String::new();
    render_node(&tree.root, 0, &mut out);
    out
```
code
The source itself.
Above about 250 pixels a box is its code, highlighted by tree-sitter, rendered into a texture. You did not open a file; you zoomed in.

Outrider draws and does not edit. Ctrl+Shift+E reveals a file in your file manager, and that is the whole hand-off today. At the whole-repository zoom you are reading names and colors, not code, and Outrider does not summarize: if you want prose, it comes from your agent as a marked note.

Stop 1 · Repository

The whole repository.

Every top-level folder is a container with its name in the strip. Area is lines, so MatterEngine3, projects and MatterEditor are the biggest boxes and you can see that before you know the project. The stripes are git churn: the redder the edge, the more commits have touched it. The panel on the right is a guided tour an agent wrote; this is its first stop.

Captured from Outrider at 7171fda on Matter Engine at d753087d8 · tour step 1 · whole repository

The whole Matter Engine repository as one Outrider map, top-level folders named in their header strips, with the guided tour navigator open on the right.

Stop 1 · Repository

The whole repository.

Every top-level folder is a container with its name in the strip. Area is lines, so MatterEngine3, projects and MatterEditor are the biggest boxes and you can see that before you know the project. The stripes are git churn: the redder the edge, the more commits have touched it. The panel on the right is a guided tour an agent wrote; this is its first stop.

Captured from Outrider at 7171fda on Matter Engine at d753087d8 · tour step 1 · whole repository

Stop 2 · Folder

One folder, its files.

Files pack in shelves left to right in a stable order, sized by their lines. Source files first, docs after. A file that grows shifts its siblings; it never reshuffles them. Here the tour has dimmed everything outside the foundation libraries, so the eye lands on the spotlight.

The foundation libraries lit while the rest of the map is dimmed, files packed in shelves inside each library folder.

Captured from Outrider at 7171fda on Matter Engine at d753087d8 · tour step 3 · foundation libraries, spotlight

Stop 3 · File

One file, its functions.

Inside a file, every function, class and struct is a box of its own, tall in proportion to its lines. This is where the churn stripe and the name are both readable. SpatialQueryLib, framed by the tour, with its symbols named.

The SpatialQueryLib file framed close enough that every function and struct inside it is a named box.

Captured from Outrider at 7171fda on Matter Engine at d753087d8 · tour step 3 · SpatialQueryLib symbols

Stop 4 · Function

One function, its source.

At this size the box is the code, highlighted, rendered from the file on disk. The focused struct is the baker seam: the agent’s note beside it says why it matters. Esc steps back out to the file; Home fits the whole repository again.

A struct in the baker focused until its source is readable, with the tour note pinned beside it and the surrounding functions dimmed.

Captured from Outrider at 7171fda on Matter Engine at d753087d8 · tour step 10 · baker seam, focused struct

outrider-cli

outrider-cli --project ~/dev/matter-engine query symbols create_tileset_image --kind fn
outrider-cli --project ~/dev/matter-engine set hot \
  --expr '{"where":{"metric":"churn","op":">=","value":"p90"}}'
outrider-cli --project ~/dev/matter-engine mask --dim-except hot --strength 0.8
outrider-cli --project ~/dev/matter-engine note \
  'fn:MatterEngine3/src/render/vk_scene_renderer.cpp::VkSceneRenderer::create_tileset_image' \
  'Allocates the tileset image and its mip chain; the upload path is below.'
outrider-cli --project ~/dev/matter-engine comments prompt

Five commands from the shipped skill's own workflow: find a symbol's address, name a set, dim everything outside it, pin a note, and collect your comments as a prompt. Transport is JSON-RPC over loopback to the running window. The same commands are expressible as a JSON view file under .outrider/views/; every file there is a tab and hot-reloads on save.

A tour, playing.

A tour authored with run-outrider, with a highlighted function, dimmed surrounding map, navigator and marked agent narration.

A tour is a view whose camera has steps. Each step frames a set or focuses a symbol, can push or pop a layer, and carries narration rendered beside the thing it describes. → and ← step; Esc leaves. The note in the frame was written by Claude Code through the run-outrider skill, and it is drawn in the marked narration style so you always know which text is the agent's.

Your half of the loop.

Press c on a symbol to attach a question or a change request. outrider-cli comments prompt renders every comment under its symbol's address, file and signature, and asks the agent to answer with a focused view or tour step and to propose code changes as diffs referencing those symbols.

The comments live in .outrider/comments.json inside the repository, so they travel with the checkout and an agent on another machine reads the same list.

“Comments are the user's half of the agentic loop: an agent presents a view or tour, the user annotates symbols with questions and change requests, and the accumulated list is turned into a prompt for the agent.”
crates/outrider/src/view/comments.rs, unedited.

There is no model inside Outrider, no API key and no network client. The agent is whichever one you already run; the shipped integration is a Claude Code skill and a CLI any agent can call. A view can paint a color only from a metric with a stated basis, so an agent can point and narrate and cannot paint an opinion.

Last night's commits, and nothing else.

Before

The Matter Engine repository framed whole with churn painted across every box, the most frequently committed paths red.

After

The same frame with everything outside changed(HEAD~1) dimmed, leaving only the paths the last commit touched lit.

Left: Matter Engine, a C++ voxel and ray-tracing engine, framed whole with churn painted across every box. Right: the same frame under a mask that dims everything outside changed(HEAD~1), the set of paths the last commit touched, applied from the CLI with one command. Swap in changed(worktree) for what is uncommitted.

set

{ "where": { "metric": "churn", "op": ">=", "value": "p90" } }

A set is a named group of boxes. This one is the hottest tenth of the repository. A mask over it dims the rest; a marks layer badges it; a fill paints it. Every painted value on the map inspects as metric, value, basis.

git log main

$ git log --format='%h  %s' origin/main | head -6
70ec293  fix: guard focused leaf height on expanded_w and suppress clippy warning
e9b8140  feat: expand focused nodes and wrap text instead of truncating
8705792  feat: bump PAGE_W from 480 to 640 for wider leaf pages
dfc0665  docs: add focused node expansion implementation plan
44e2a85  docs: add focused node expansion design spec
be6bfe9  feat: rewrite settings window with editable fields, backdrop, and save/cancel

Outrider's own log. Its commits carry a coding-agent co-author line, and it is looked at through Outrider. It is a codebase written with agents by a person who needed to see what they wrote.

Churn is over the whole history, not a window; changed(rev) is the window. Paths are tracked without renames on purpose, so a moved file starts cold. The diff itself is not drawn on the map yet: churn stripes and changed sets, not every hunk.

A focused function in the baker with its callers drawn to the left and its callees to the right, each as a readable code box. — Focus a function and the call layer draws its callers on one side and its callees on the other, each as its own code box. Edges are resolved from the syntax tree by name, so they are fast and approximate; the language server stays the source of truth.

An inheritance tree of the engine's classes drawn as a class diagram, base classes at the top and leaves at the bottom. — The inheritance seam for one class family, drawn in the graph space. Every box is still a real symbol: step into one and you are back on the map, at its source.

A left-to-right data-flow graph of the bake pipeline's stages, with a tour note describing it and the tour navigator open. — A tour step can draw a graph instead of framing a region. This one is the bake pipeline, one node per stage, narrated by the agent that wrote the tour.

A dependency graph of Matter Engine's modules arranged top to bottom, the editor at the top and the foundation libraries at the bottom. — Module dependencies, top down: what depends on what, before you know any of the names. The tour's second stop, and the frame most people ask for first.

1,302files in one map

folders: 175
functions: 12,431
classes: 2,254
lines: 363,336

3.7 s to read it all into one map, cold

Matter Engine's repository at d753087d8, as Outrider indexes it with that project's ignore rules, on a 12-core / 24-thread box, one cold run of outrider-dump, measured 2026-09-13. Vendored third-party trees are filtered out, as they are on the map. Lines include tests and docs, because area on the map is lines and those are on the map too.

MatterEngine3 222,453

projects 44,209

MatterEditor 41,620

The three largest top-level folders by lines. A map of only src/ would be less than a quarter of the picture.

matter_engine.cpp 269vk_scene_renderer.cpp 227vk_scene_renderer.h 185

The three hottest files, by commits touching the path over the full history. They are the reddest boxes on the map before you know their names.

“Same structure always produces the same layout. A small structural change produces a small visual change.”
docs/code-comprehension-viewer-design.md, the layout requirement the outrider-layout tests assert.

Refreshed at build time. A number older than 30 days is removed rather than shown.

Key	Action
`Enter / Esc`	Step into / out of focused node
`Arrow keys`	Move focus spatially
`Alt+Left / Alt+Right`	Navigate history back / forward
`Home`	Reset camera to fit all nodes
`End`	Frame the focused node
`Scroll`	Zoom in / out at cursor
`Click / Drag`	Set focus / Pan the view
`Ctrl+O`	Open folder
`Ctrl+P`	Go to file
`Ctrl+T`	Go to symbol
`Ctrl+,`	Settings
`Ctrl+Shift+E`	Reveal in file manager

The welcome screen's table, unedited. Ctrl reads Cmd on macOS. Also shipped: c to comment on the focused symbol, → and ← to step a tour and Esc to leave it.

Two script-host functions framed side by side at the code rung, both readable, with the tour navigator open on the right. — Two script-host functions framed side by side at the code rung. `Ctrl+T`, a short query, `Enter` gets you to either one: the match is a case-insensitive subsequence, so `prs` finds `parse`, the camera tweens to the symbol and the map does not reflow.

Linux, macOS and Windows. Windows binary. macOS and Linux build from source; Linux verified under WSLg, macOS unverified by the maintainer.

Why not my editor's minimap?

A minimap is one file, shrunk. It shows the shape of the buffer you already opened and nothing about the files you did not. Outrider's unit is the repository: every box is a real file or function, its area is its line count, its stripe is its commit history, and you reach it by zooming rather than by knowing its path. The minimap is in your editor and Outrider is not: it does not edit and does not open your editor. Ctrl+Shift+E reveals a file in your file manager, and that is the whole hand-off today.

Why not a dependency-graph tool?

Graph tools draw architecture as built, and at repository scale that is a hairball with no stable place to stand. Outrider's spine is the folder tree, the one structure that survives agents rewriting the contents nightly, and the one you already know. Every symbol has a fixed position that only moves when its own ancestors change, so the same commit renders the same picture on any machine. Call and inheritance edges are a layer you turn on, and a separate graph space draws class diagrams and dependency pictures when you ask, drawn over or beside the map, never instead of it. Call edges are resolved from the syntax tree by name, not by a language server, so overloads and dynamic dispatch are approximate. If you need an exact cross-reference, use your language server. Outrider is for the shape.

Does it need an API key or send my code anywhere?

No. There is no model, no network client and no telemetry in the source. Caches for rendered textures and churn live in your OS cache directory, capped at 1 GB per project for textures, and Outrider never writes cache files into a repository it analyzes. The only things it writes into your project are the files you or your agent ask for under .outrider/: views, comments, project settings.

Which agent does it work with?

Whichever one you already run. The shipped integration is a Claude Code skill, run-outrider, and a CLI with 15 verbs that any agent or script can call over loopback JSON-RPC. A view is a JSON file, so an agent that can write a file can drive the map. Nothing in Outrider knows which agent is on the other end.

Does it run on my machine?

Linux, macOS and Windows, with settings under the usual per-platform config directory. One binary is published and it is for Windows. On macOS and Linux you build from source with Rust 1.89 or newer, and CI compiles and runs the tests on all three. The window has been run on Windows and on Linux under WSLg; no macOS run is recorded by the maintainer. It needs a GPU that can draw a window; a software rasterizer works and is slow.

Is this a product or a hobby?

An open-source tool, MIT, one maintainer, no company and no pricing page. 321 commits between 2026-07-05 and 2026-09-14, 49,597 lines of Rust across five crates, 656 tests, three tagged releases. It is a codebase written with coding agents by a person who needed to see what they wrote, and it is looked at through itself. It is under active development; expect rough edges and an issue tracker that answers. If you want a vendor with an SLA, this is not that.

Download for Windows

v0.2.0 · 38.9 MB · outrider.exe · released 2026-09-14

All releases

build from source

git clone https://github.com/ElectricJack/outrider-ide.git && cd outrider-ide
cargo build --release
./target/release/outrider /path/to/your/repo

Rust 1.89 or newer. The locked dependency graph does not build on 1.80. On Windows the binary is target\release\outrider.exe.

Platform	How you get it	Status
Windows	Binary above	Published, v0.2.0. Where the maintainer runs it.
Linux	Build from source	Compiles and tests in CI. Run verified under WSL2 (WSLg).
macOS	Build from source	Compiles and tests in CI. No run recorded.

Status is what the repository records, not what we hope. Linux needs the system packages CI installs; the list is in the repository's workflow and in the install notes below.

linux packages

sudo apt-get install -y build-essential clang pkg-config libfontconfig-dev libasound2-dev libssl-dev libzstd-dev libwayland-dev libxkbcommon-dev libxkbcommon-x11-dev libx11-xcb-dev libvulkan1 mesa-vulkan-drivers

The Debian and Ubuntu package line from Outrider's own CI. Other distributions: the same libraries under their own names.

outrider
Open a folder.
With no argument it opens a folder picker; with a path it opens that repository.
Home
See it all.
Indexing runs in the background and the map fills in as it goes; Home fits the whole repository once it is there.
Ctrl+P
Go somewhere.
Type a few letters of a file name and press Enter. Press Esc to step back out, Alt+Left to go back.

Outrider is under active development. If it draws your repository wrong, the issue tracker is the place, and the map's own capture is the bug report.

Your whole codebase, drawn to scale.

A code map, not a file tree.

Too small to name.

A name on a box.

A summary you can act on.

The source itself.

Every file, every function, one screen.

The whole repository.

One folder, its files.

One file, its functions.

One function, its source.

The whole repository.

One folder, its files.

One file, its functions.

One function, its source.

Your coding agent drives the map through a CLI.

A tour, playing.

Your half of the loop.

Watch where the work lands.

Last night's commits, and nothing else.

Edges are a layer you turn on.

Who calls the baker, and what it calls.

The class family, as a class diagram.

The bake pipeline as data flow.

The layer cake.

One map of a repository that does not fit in your head.

Find it by name, or walk to it.

Two functions, one screen.

Questions you will ask before you run it.

First-hand understanding of code you did not write.

Open a folder.

See it all.

Go somewhere.