The stack trace says line 412. It's lying to you.
Forty files open. Zero idea how they connect.
You wrote this code. Six months later it's a stranger's city.
Make the invisible visible.
Your codebase already has a structure. Struct builds it — as a place you can stand in, look around, and navigate.
Every code block becomes a building.
Functions, classes, modules — each one is rendered as a clean geometric structure. Size reflects scope. Shape reflects type. Your codebase becomes a virtual representation you can actually read at a glance.
Connections become streets.
Imports, calls, dependencies — buildings connected as the code is connected. Follow a pathway from one module to the next and you're tracing the exact route your data takes. No more guessing what touches what.
Errors become landmarks.
A failing module doesn't hide in a log file. It lights up on the skyline. Walk inside the building to see exactly how the code works, where it breaks, and what it drags down with it.
"We got tired of being lost in our own code. So we built somewhere to stand."
See your code differently.
We're looking for developers who want to walk their codebase, not scroll it. Join the prototype.
How a codebase becomes a city.
Struct parses your project, maps its structure, and renders it as a navigable 3D environment. Here's what happens under the hood — and above the skyline.
Buildings, generated from code.
Struct reads your project's abstract syntax tree and assigns every meaningful block — module, class, function — a structure in the city. Nothing is decorative. Every dimension encodes something real:
- Height maps to lines of code and complexity
- Footprint maps to the number of exported members
- Floors map to functions inside a module
- Districts group packages and directories
Connections, mapped as streets.
Every import, call, and dependency is traced and drawn as a pathway between buildings. The city's road network is your dependency graph — laid out so that tightly coupled code sits close together and clean boundaries are visible as open space.
- Trace any path from caller to callee, end to end
- Pathway brightness shows how hot a connection is
- Circular dependencies appear as literal loops
- Select a building to isolate everything it touches
Errors, surfaced on the skyline.
Runtime errors, failing tests, and unresolved references mark their building with a visible beacon. Walk inside and the structure opens up: floors are functions, rooms are blocks, and the broken line is marked where it lives.
- Beacons rank by severity — exceptions over warnings
- Blast radius shows every dependent that's affected
- Step from the beacon to the exact line in one click
- Fixed errors clear from the skyline in real time
The best explanation is the demo.
The interactive city on our home page is a simplified slice of the real environment. The full prototype runs on your codebase — and that's what early testers get.
Request Early Access →Three developers. One bad Tuesday.
Struct wasn't born in a strategy meeting. It was born in a debugging session that should have taken twenty minutes and took two days.
Why we're building this.
March 2025. Kelechi was chasing a null reference through a client's codebase — 200+ files, four layers of indirection, a stack trace pointing somewhere the bug wasn't. At some point he grabbed a whiteboard and started drawing the modules as boxes, the calls as lines between them. Ten minutes later the problem was obvious. It had been obvious the whole time — just invisible.
That whiteboard sketch was the first version of Struct. We realized the hard part of debugging complex code usually isn't the fix. It's the finding. Code is spatial — things connect, contain, and depend on each other — but we read it as flat text, one file at a time, holding the map in our heads.
So we stopped holding the map in our heads and built the city instead.
The team
Kelechi
Eight years in backend systems. Owns the part of Struct that reads your code and turns it into a structure. The whiteboard incident was his.
Dami
Game engine background, developer tools convert. Builds the city itself — geometry, lighting, navigation — and keeps it fast enough to feel like a place, not a chart.
Tobi
Solo-dev veteran — the exact user Struct is for. Owns the bridge between the city and your editor, so a beacon in 3D lands you on a real line of code.
Honest status: prototype.
Struct works today on JavaScript and TypeScript projects. It is rough in places. Some big codebases make the renderer sweat. The editor bridge supports VS Code only, for now.
We're not hiding any of that — it's exactly why we want early testers. If you work solo in complex code and you're willing to tell us what's broken, you'll shape what this becomes.
Join as a tester →Help us build the city.
We're opening the prototype to a small group of solo developers. Here's the deal — what you get, what we ask, and where the product stands.
The deal, plainly.
What you get
Full prototype access on your own codebase, a direct line to the three of us, and a real say in what gets built next. Free during the prototype phase.
What we ask
Use it on real work, not a toy repo. Tell us where it helps, where it breaks, and where it gets in your way. A short call every few weeks if you're up for it.
Where the product is
Working prototype. JavaScript and TypeScript today, VS Code integration, more languages on the roadmap. Expect rough edges — and fast fixes.
What happens after you apply
We review applications in small batches and onboard testers personally. You'll hear from a human, not an autoresponder.
Request prototype access
Three fields. Under a minute.
Application received.
We review in small batches, so give us a few days. When your slot opens, one of the three of us will email you directly with setup instructions for your codebase.