Volume 02
The City Tradition
The big, deep, well-cited branch of "3D code visualization" — the one that renders statistics about code, shaped like buildings, islands, streets, forests, galaxies. Eighteen years of it. Most of it is dead. Some of it is genuinely alive. None of it renders the code.
Nothing in this volume is tagged renders text — that's the point. These map files to shapes; the source itself is at most a tooltip or a click-through.
This is the part of the field that did the sensible thing. Rendering a whole codebase's worth of legible text at sixty frames a second was, for most of this period, considered infeasible — so the field reached for a metaphor instead. A class is a building; lines of code is the height; complexity is the footprint; a package is a city block. Now you have something you can fly over, and the rendering problem collapses to "draw a lot of boxes," which GPUs have been good at since 1996.
It's a real idea with real empirical support — people do orient faster in a stable city than in a hairball graph. It's also a different idea from rendering the source itself, and it dominates the literature for the same reason the rendered-text branch is thin: a building is cheap to draw; a repo's worth of legible text is not. The roster, from the root down.
CodeCity, and the building-per-class line
CodeCity 3D downloadable; the lineage's origin point
Richard Wettel, Michele Lanza · University of Lugano (USI) — REVEAL group · 2008; Most Influential Paper, VISSOFT 2020 · Smalltalk/Moose desktop app, still downloadable (v1.4.3)
The one everyone cites. A class is a building; its number of methods sets the footprint, its number of attributes sets the height; a package is a district. Lay it out, color by some metric, and a system you could never "see" becomes a skyline you can walk over and reason about — design problems show up as god-buildings and sprawling slums. It's a Smalltalk research artifact from 2008, it's still downloadable as a Windows/macOS standalone or a VisualWorks image, and it is the trunk that the next dozen entries grow out of.
project page · downloads
M3triCity 3D alive (their corpus only)
REVEAL group · USI Lugano · ICSE Companion 2022 · hosted web app, Babylon.js; recently refreshed
The spiritual successor to CodeCity, rebuilt for the browser, and the one CodeCity-family tool that does something genuinely distinctive: it visualizes a system's data schemas alongside its code, and it scrubs through the project's whole revision history with a play/pause timeline so you watch the city grow, shift, and rot over commits. The catch — there's no "paste a GitHub URL" field; you browse the projects they've pre-imported. Live, polished, demo-bound.
metricity.si.usi.ch
CodeCharta 3D alive — the practical choice today
MaibornWolff (consultancy, open-source) · since 2017 · ~440 stars, releases on a corporate cadence (v1.143, April 2026)
If you want a real codebase rendered as a city right now, in any language, this is it. You run their CLI analyzer locally — it ingests SonarQube, Tokei, Code Maat, git log, raw source parsers, CSV — and it spits out a .cc.json.gz that you drag into the hosted Three.js visualizer. Buildings are files, districts are folders, and you bind height / footprint / color to whatever metric pair you want (LOC, complexity, churn, coverage). Not zero-click, but actively maintained by people who get paid to maintain it, which puts it in a different reliability tier than everything else in this volume.
codecharta.com · github.com/MaibornWolff/codecharta
GoCity 3D dormant, but the demo still works
Rodrigo Brito · since ~2019 · ~1.8k stars; last release 2022; the page is up
The one tool in this entire survey where you genuinely paste a GitHub URL and immediately get a 3D city — structs become buildings stacked on file-slabs, folders become districts. The price of that simplicity: Go only, and nobody's touched it since 2022. Still, "type a repo, get a building" with zero local toolchain is rare enough that it's worth knowing this exists.
go-city.github.io · github.com/rodrigo-brito/gocity
BabiaXR (CodeCity visualizer) WebXR alive
URJC Madrid + Bitergia · multi-year, active into 2025 · A-Frame component library; FOSDEM talks; thesis project
An A-Frame / WebXR component kit for data visualization in the browser, of which a CodeCity-style software-city is one of several visualizers. The closest thing to an open, web-native, VR-capable scaffold for the genre — if you wanted to build a city-metaphor tool today and not start from zero, this is the foundation. (Empirical bonus: the group ran a BabiaXR-vs-Kibana user study, one of the few rigorous comparisons of immersive vs. dashboard data viz.)
babiaxr.gitlab.io · github.com/babiaxr/aframe-babia-components
JSCity · PHPCity · Magnova CodeCity · others 3D mostly frozen ports
various · 2014 → 2024
The CodeCity idea has been ported, language by language, by a long tail of students and hobbyists: JSCity (a Three.js port for JavaScript, from UFMG's ASERG group), PHPCity (Three.js, PHP-only, frozen at 2016, but it's the simplest pure-web city renderer in the wild), Magnova's modern web reboot, and assorted codecity-visualizer / city-blocks repos. None actively developed; collectively they're evidence of how durable — and how easily re-implementable — the building metaphor is once you've decided not to render text.
ExplorViz — the one that's actually alive
ExplorViz 3D WebVR alive — and the most actively developed software-city project anywhere
Wilhelm Hasselbring's group · Kiel University · 2012 → present · ~20 repos, commits landing this month; live demo; Apache-2.0
The exception that proves the "dead academic prototype" rule. ExplorViz renders software landscapes as cities — but the buildings are populated from live trace data: you instrument a running Java app with an OpenTelemetry agent, and the structure plus the runtime communication shows up as a city you can walk through, collaboratively, including in WebVR. Recent work adds semantic zoom and mini-maps for scaling the cities, an LLM "code agent," and an AI chat service. It's the genuinely-maintained, genuinely-usable end of this whole branch.
Worth being precise about the difference from glyph3d-js, because they're often mentally filed together: ExplorViz needs a running, instrumented system and renders the metaphor; glyph3d-js needs a repo and renders the text. Different inputs, different outputs, both legitimately "the whole system, spatially." It's the nearest living neighbor that isn't a direct competitor.
demo.explorviz.uni-kiel.de · github.com/ExplorViz · Semantic Zoom & Mini-Maps (2025)
The other metaphors — islands, streets, forests, galaxies, Minecraft
Once "building" is taken, the obvious move is a different noun. Each of these is one paper's worth of "what if the metaphor were ___ instead."
IslandViz VR / HoloLens dead
Misiak, Schreiber, Fuhrmann et al. · DLR — German Aerospace Center · VISSOFT 2018 · Unity 2018 + SteamVR; HoloLens port archived April 2026
OSGi bundles become islands in an ocean; package dependencies become bridges and shipping lanes. A genuinely pretty metaphor for modular Java systems, built at a serious research institution — and now both the VR build and the HoloLens build are read-only archives. With HoloLens 2 itself winding down, the AR corner of this whole field is effectively closing with the hardware.
github.com/DLR-SC/island-viz · islandviz-hololens (archived)
EvoStreets / SoftVis3D / Getaviz 3D the implementation is dead as of Jan 2026
Steinbrückner & Lewerentz (BTU Cottbus), later Steinbeck & Koschke (Bremen) · SOFTVIS 2010 → VISSOFT/ICPC 2019–20 · canonical impl (SoftVis3D, a SonarQube plugin) archived January 2026
Instead of a grid of buildings, a street network: the directory tree becomes roads branching off roads, files become buildings lining them, so the layout encodes hierarchy as a city plan you could give directions in. The technique kept getting studied — including VR-EvoStreets, which measured how far people actually walk and how much volume they occupy navigating one. But the one productized implementation, SoftVis3D, was archived in January 2026, which leaves EvoStreets effectively paper-only again. Getaviz carries a related evolution-visualization torch.
github.com/stefanrinderle/softvis3d (archived)
CodeMetropolis 3D — inside Minecraft technically alive in a fork; barely
Balogh & Beszédes · University of Szeged · ICSME 2013 / SCAM 2015 · original archived 2022; successor fork released v1.5 in Feb 2025 with ~290 open issues
The CodeCity metaphor, but the renderer is Minecraft — class metrics drive the shape and contents of buildings you then explore in a Minecraft world. Pure novelty over utility, and you have to stand up a Minecraft server to use it, but it's a real published artifact and the geryxyz fork shipped a release in 2025, which makes it — improbably — one of the more recently-updated things in this volume.
Software Forest · Software Galaxies (academic) 2.5D paper-only
HPI (Software Forest, IVAPP 2021) · various (Software Galaxies, VINCI 2021)
Two more nouns. Software Forest places source files as trees in a 2.5D landscape, positioned by semantic similarity (LDA topic modeling plus multidimensional scaling) so related files cluster into groves. Software Galaxies (the academic paper — not anvaka's interactive version) renders coding activity as stars in a galaxy. Both are single-paper prototypes; both are useful mainly as evidence that the metaphor well is bottomless.
SArF Map 3D paper-only — never released
Kobayashi et al. · Fujitsu Laboratories · ICPC 2013 · no public repo, no demo, ever
A "software cartography" approach — cluster the system into feature-aligned regions, render as a contour map / terrain. Fujitsu internal; it exists as an arXiv PDF and nothing else. Listed for completeness; representative of how much of this field is a paper and a promise.
The VR cohort
Around 2017, consumer headsets arrived, and a wave of "CodeCity, but you're inside it" papers followed. Almost all of them are Unity prototypes that never left the lab. The pattern is so consistent it's worth seeing the whole roster at once.
| Tool | Who / when | Metaphor | Status |
|---|
| CityVR | Merino, Ghafari, Anslow, Nierstrasz · Bern + USI · VISSOFT 2017 | "gameful" CodeCity, HTC Vive, Moose-fed | paper-only |
| VR City | Vincúr, Návrat, Polášek · Slovak Univ. of Technology · QRS-C 2017 | method-granularity city; buildings touch in proportion to coupling | paper-only; led to CollaVRation (2024) & SecCityVR (2025) |
| FlyThruCode / MR-FTC / GVR-FTC | Oberhauser & Lecon · Aalen Univ. · Laval Virtual 2017+ | multi-metaphor flythrough, later gamified | ongoing paper series |
| VR-Git / VR-GitCity | Oberhauser · Aalen Univ. · ICSEA 2022 / IARIA Soft 2023 | commit history as a hyperplane; files as tiles; later + city metaphor | paper-only |
| SecCityVR | Moreno-Lumbreras et al. · arXiv 2504.18238 · April 2025 | CodeCity buildings; vulnerabilities as colored floors | very recent; artifact availability unclear |
| Code Arcades | Savidis et al. · arXiv 2509.23297 · Sept 2025 | classes as buildings, formal arguments as windows | just submitted; no repo |
| DynaCity | QAware · Unity | jdeps output + Elastic trace JSON → city | abandoned (3 stars, 5 commits) |
| CollaVRation | STU Bratislava et al. · XP Workshops 2024 | collaborative UML + live programming + round-trip in VR | recent; study artifact on Zenodo |
Two of the names above bridge into Volume 01 because they actually render source — CollaVRation keeps real code in side panels, and ExplorViz's VR mode opens real source on demand — but in their primary view, every one of these is buildings.
The deep roots
Before the headsets, before the cities, the idea was already being tried in CAVEs and on visual-language polyhedra. Worth a line so the lineage is honest about its age.
ImSoVision CAVE historical
Maletic, Leigh, Marcus, Dunlap · ~2001 · probably the first immersive software-visualization system
Class-diagram-style primitives, rendered in a CAVE — projected walls, stereo glasses, the early-2000s idea of "VR." Long predates the consumer-headset wave, and is the deepest documented root of "let's put the software around the programmer."
3D-PP 3D historical
Oshiba & Tanaka · Hokkaido University · Visual Languages '99 · a 3D visual programming environment, built from regular polyhedra
Not visualization of existing code — a 3D language: programs constructed from arrangements of polyhedra in space. Arguably the oldest ancestor of "the program is a 3D thing you navigate," from 1999. Included because the family tree should reach all the way down.
(The other root — SeeSoft, 1992 — lives in Volume 01, because it's the one that kept the text.)
Aside: do people actually navigate these?
Movement patterns in 3D software visualization methodology
Steinbeck et al. · University of Bremen · how to measure whether a 3D code view is actually used as a 3D space
A small but pointed line of work: instrument the camera, track the trajectories, and ask whether users move through these environments or just orbit them like a static sculpture. Directly relevant if glyph3d-js ever wants to claim its spatial layout earns its keep — it's the methodology for proving (or disproving) that.
Where this volume lands. Eighteen years, dozens of tools, one durable insight — a stable spatial layout beats a hairball — and a body count. Openable and usable today: ExplorViz, CodeCharta, M3triCity, BabiaXR, plus the dormant ports GoCity and PHPCity. Everything else — IslandViz, SoftVis3D, CodeMetropolis-original, SArF, CityVR, VR City, DynaCity, the entire 2017+ VR cohort — is archived, abandoned, or never released. All of it, alive or dead, renders a shape standing in for the code rather than the code itself.
→ Volume 01: the smaller branch that kept the text. Volume 06: what that leaves open.
Continue → 03 · VR IDEs & Commercial Code Maps