Repo-Verse
Drop a project folder and watch it become a 3D solar system: every file a planet sized by bytes, every folder a system, every commit a step in a time-lapse. Your code is read locally through the File System Access API and never uploaded.
Loading tool…
How a folder becomes a solar system
The mapping is arithmetic, not decoration. File size sets planet radius on a logarithmic curve — clamp(1 + log10(bytes + 1) × 0.5, 0.3, 5) — so a 40 KB module is visibly bigger than a 2 KB one without a 2 MB asset swallowing the screen. Directory depth sets orbital distance, so the shape of your nesting becomes the shape of the system. File extension picks the colour and the planet archetype: JavaScript burns star-yellow, Python is a blue ice world, Rust is hot rock, Go is an ocean, Markdown is forest green, JSON is crystal. Estimated complexity earns a file a ring, and folders become gas giants with their own children in orbit.
Reading the folder is the browser's own work. window.showDirectoryPicker() hands the page a directory handle, and the tool walks it recursively, reading sizes, modification times and — for text files under half a megabyte — the contents, to count lines, estimate branching complexity, and collect import statements for the dependency graph. Files inside node_modules, .git, dist, build and the other usual suspects are skipped by default, and that ignore list is editable.
Large repositories are not thinned by accident. Above roughly a thousand bodies, the shallowest and largest files keep their planets and everything else becomes a coloured asteroid belt, so a twenty-thousand-file monorepo still turns at full frame rate and the HUD tells you exactly how many files went into the dust.
What it is actually good for
Structure you can see is structure you can argue about. A tree view tells you the names; a system view tells you the proportions — that one folder holds two-thirds of the mass, that the tests orbit far out and thinly, that a single file has grown into a gas giant nobody meant to create. That is a useful thing to put on a screen during a refactor discussion, an onboarding session, or an architecture review.
The privacy point is not incidental either. Source code is the one thing most developers genuinely cannot paste into a random web tool: it is usually someone's intellectual property, and it frequently contains credentials. Repo-Verse has no upload endpoint and no server component. The folder is read through a permission-gated browser API, the parsing and the 3D rendering happen on your own machine, and if you edit a file in the built-in Monaco editor it is written straight back to disk through the same file handle — never round-tripped through anyone's backend.
Getting more out of it
- Use the "Open folder" button rather than "Choose folder" when your browser supports it: only the File System Access API gives write-back saving and access to
.gitfor the timeline. - If the scene looks sparse, check the ignore list in Settings — build output and dependency folders are excluded by default and can be re-included.
- Double-click a planet to focus the camera and open the file in the code inspector at the same time.
- Graph view resolves relative imports between your own files. Package imports are ignored on purpose, so what you see is your internal coupling, not your dependency tree.
- Timeline view needs a real
.gitdirectory. It reads up to eighty commits with isomorphic-git and never writes to the repository. - Drop the max-body count to 400 and pixel ratio to 1× in Settings if you are on a laptop GPU and the scene stutters.
How to use it
- Open a project folder, drag one onto the scene, or load a .zip archive of one. There is also a demo project if you just want to look around.
- Orbit with left-drag, pan with right-drag, zoom with the wheel, and double-click a body to focus it.
- Click any planet to see its size, line count, depth, complexity and language in the info panel.
- Switch between solar, galaxy, graph, timeline and stats views with the buttons or the number keys 1–5.
- Edit a file in the inspector and press Ctrl+S to write it back to disk, or export a PNG, WebM orbit, JSON dump, CSV or Markdown report.
Related: File Inspector for identifying a single unknown file, Code Diff Formatter for comparing two versions of a source file, and Zip Extractor for unpacking an archive before exploring it.
The mapping is arithmetic, not decoration
Nothing here is arbitrary styling. Each visual property is a function of something real about the file:
| File attribute | Celestial property |
|---|---|
| Size in bytes | Planet radius — clamp(1 + log10(bytes + 1) × 0.5, 0.3, 5) |
| Directory depth | Orbital distance from the core |
| Extension | Colour and planet archetype |
| Line count | Rolled up into folder mass |
| Estimated complexity | Rings around the planet |
| Last modified | Recency shown in the info panel |
The logarithmic size curve matters more than it sounds. Linear scaling means a single 2 MB asset makes every source file an invisible speck; a log curve keeps a 40 KB module clearly larger than a 2 KB one while still letting the genuinely huge files dominate.
Extensions pick the archetype, so language shows up as texture and colour: JavaScript burns star-yellow with banded surfaces, Python is a cool blue ice world, Rust is hot orange rock, Go is an ocean, Java is volcanic, Markdown is forest green, JSON is faceted crystal, CSS is a pink nebula. The textures are drawn procedurally onto small canvases at load time — there is no texture pack to download.
Reading a folder without uploading it
Source code is the one thing most developers genuinely cannot paste into a random online tool. It is usually someone's intellectual property, and it routinely contains API keys, connection strings and internal hostnames. Any visualiser that requires an upload is unusable at work for exactly that reason.
Repo-Verse never uploads, because it does not have anywhere to upload to. window.showDirectoryPicker() hands the page a permission-gated handle to the directory you chose, and the tool walks it recursively in the tab: reading sizes and modification times for everything, and reading contents only for text files under half a megabyte in order to count lines, estimate branching complexity, and pick up import and require statements for the dependency graph.
Three ingestion routes exist, in descending order of capability:
- Open folder (File System Access API, Chrome and Edge) — full read plus write-back saving, and access to
.git. - Choose folder (the older
webkitdirectoryinput) — reads everything, but edits download as a copy rather than saving in place. - Archive — a
.zipunpacked client-side with JSZip, useful for a repo someone sent you.
Folders like node_modules, .git, dist, build, target, __pycache__ and .venv are skipped by default, and that ignore list is an editable text box, not a hard-coded rule.
Making a twenty-thousand-file repo hold 60fps
Naively rendering one sphere per file falls apart around a few thousand draw calls. Repo-Verse ranks nodes by depth and size, gives the top ~1,200 real geometry, and turns everything else into a single coloured point cloud — an asteroid belt of small files, positioned by the same orbital formula. Nothing is silently dropped: the HUD tells you how many files became belt dust, and they are still in the file tree, the metrics and the exports.
Beyond that, geometry is shared across bodies at three levels of detail, textures are cached per colour-and-archetype pair rather than per file, and orbit rings are drawn only for the first two depth levels, because past that they are noise.
Clicking a planet opens the file
Selecting a body shows its path, size, line count, depth, complexity, language, planet type and modification date. Double-clicking focuses the camera on it and opens it in an embedded Monaco editor — the same editor core that VS Code uses — in a draggable glass panel over the scene.
If the project came in through the File System Access API, that editor is writable. Press Ctrl+S, the browser asks for read-write permission the first time, and the file is written back to disk through createWritable(). No round trip, no temporary copy on a server. If the project came from an archive or the fallback picker, the editor stays read-only and saving downloads the edited file instead — which is the honest behaviour, since there is no handle to write through.
Markdown and HTML files also get a preview toggle, with HTML rendered inside a fully sandboxed iframe.
Watching the repository evolve
If the folder contains a .git directory, Repo-Verse reads the commit log with isomorphic-git and puts a scrubber along the bottom of the scene. Drag it and planets appear and disappear as files enter and leave the tree; press play and the repository builds itself in front of you, commit by commit.
Making that work needed a small adapter: isomorphic-git expects a Node-style fs.promises API, and the browser offers directory handles. Repo-Verse implements the read half of that interface — readFile, readdir, stat, lstat — on top of the File System Access API, and deliberately implements the write half as functions that throw. The repository is opened read-only by construction, not by policy. Your history cannot be altered by a visualiser that has no code path to alter it.
Five ways to look at the same project
- Solar system — the default; one project as a planetary system.
- Galaxy — every loaded project at once, for comparing two codebases side by side.
- Graph — a force-directed 3D layout of files linked by their internal imports. Package imports are excluded on purpose, so what you see is your own coupling rather than your dependency tree.
- Timeline — the git time-warp described above.
- Stats — a dashboard with summary cards, a language donut, an extension bar chart and a size treemap, all drawn on plain canvases.
Everything exports: a PNG screenshot or a 2× render, an eight-second WebM orbit recorded from the canvas with MediaRecorder, a .repo-verse JSON dump of the whole tree and its metrics, a per-file CSV, and a Markdown report you can drop straight into a wiki page.
What it tells you about your own code
Load a project you know well. The things that jump out are rarely the things you would have predicted: the config folder that is somehow the third-largest system, the one component file that has become a gas giant, the module ringed with complexity markers that everyone has been avoiding, the corner of the graph where four files import each other in a knot.
None of that is new information — it was all in the directory listing. It just was not visible until size, depth and coupling were drawn as distance, mass and light.