Codebase time-travel & architecture X-ray

See your codebase
as a city.

Kobi X-Ray turns any Git repository into a navigable 3D map. Files are buildings, folders are districts, and a timeline replays every commit from the first one to HEAD.

See what it shows

Open source · runs on your machine · no code leaves it

first commit HEAD

A generated demo city. Drag to travel in time.

Measured on vitejs/vite, on a laptop

files mapped
2,876
commits replayed
9,743
import edges resolved
2,323
seconds to analyse
< 15

The problem

A repository is a black box made of text files.

Joining a team, auditing legacy code or reading a large open-source project all start the same way: thousands of files and no map.

01

Structural blindness

A folder tree does not show coupling. Nothing tells you that touching auth.ts quietly breaks forty modules.

02

Historical amnesia

git log is a wall of text. It does not show which files change every week and collect the bug fixes.

03

Fragmented context for AI

Before asking an agent to refactor, someone has to understand the architecture, or the agent gets steered straight into a hole.

Reading the city

Four encodings. No manual.

The Vite repository rendered as a city: a dense district of tall red and orange buildings under packages/vite, surrounded by lower grey districts.
vitejs/vite at HEAD, coloured by heat.
  • Height is size

    Lines of code. Skyscrapers are the files nobody wants to open.

  • Width is fan-in

    The more files import it, the wider its base. Wide buildings carry weight.

  • Colour is heat

    Recent churn, with bug-fix commits counted double. It cools with a 90-day half-life.

  • Districts are folders

    Nested directories stack like terraces, so the map follows the tree you know.

Tall, wide and red is the combination to worry about: a large file many others depend on that keeps changing.

Features

Everything in the app, on real data.

Every screenshot below is the Vite repository, untouched.

Time travel

Drag the timeline or press play and watch the city being built: districts appear, a file grows out of control into a red tower, then gets split into smaller ones.

  • Every commit of the branch, oldest to newest
  • Activity strip shows churn and the share of bug fixes
  • Step commit by commit with the arrow keys
The Vite city at three moments of its history, from a few scattered buildings to a dense skyline.

X-Ray panel and blast radius

Click any building. Arcs light up what it imports and what depends on it, and the panel counts every file that can break if you change it, hop by hop.

166 files can break if packages/vite/src/node/utils.ts changes. It has 361 commits, 171 of them bug fixes.
  • imports
  • imported by
A selected file with orange arcs to its 94 dependents and blue arcs to its imports; a side panel shows a blast radius of 166 files.

Three lenses, one city

Switch what colour means without losing your place. Hotspots are ranked live for the moment in history you are looking at.

Where the work and the bugs are right now.

City coloured by heat City coloured by cyclomatic complexity City coloured by programming language

Context for your AI agent

One click copies a Markdown briefing of a file or a whole module: what it imports, who depends on it, its blast radius and its history. Paste it into Claude Code or Cursor before the refactor.

  • Deterministic: no tokens spent to generate it
  • Exactly the subgraph that matters, nothing else
  • Works for a single file or a directory
context.md
# X-Ray context: `packages/vite/src/node/utils.ts`

Repository: **vitejs/vite** (main @ f89888822)

## Summary
- Language: typescript
- Size: 1989 lines (1786 non-blank), 154 functions
- Cyclomatic complexity (whole file): 325
- Fan-in: 94 files import it
- Fan-out: 11 internal imports
- Churn: 361 commits (171 bug fixes), +3456/-1463 lines

## Imported by (direct dependents)
- `packages/vite/src/node/build.ts` — 2002 lines, complexity 237
- `packages/vite/src/node/config.ts` — 2971 lines, complexity 282
- …and 92 more

## Blast radius
166 files depend on this file directly or transitively
(94 direct, up to 3 hops away).

How it works

Local-first. Deterministic. Fast.

The city and the time machine cost nothing to run: no server, no model, no upload. The analysis happens in the CLI and the result is rendered by your GPU.

  1. 1

    Scan

    Lists the files Git knows about, honouring .gitignore, skipping lockfiles, binaries and build output.

  2. 2

    Parse

    tree-sitter grammars compiled to WebAssembly extract imports, functions and cyclomatic complexity.

  3. 3

    Resolve

    Imports become edges: relative paths, tsconfig aliases, workspaces, go.mod modules and Rust crates.

  4. 4

    Mine

    One git log --numstat pass becomes a compact timeline of every line added and removed.

  5. 5

    Render

    A treemap lays out the districts; one instanced mesh draws every building in a single draw call.

Languages with a full dependency graph

  • TypeScriptpaths, baseUrl, workspaces
  • JavaScriptESM, CommonJS, dynamic import
  • Pythonabsolute and relative imports
  • Gomodule-local packages
  • Rustmod, crate, super, workspaces

Every other text file still gets a building, with height and heat.

Roadmap

What is built, and what is next.

Point it at a repository you think you know.