Developer Rik Arends has built an experimental 3D source code visualizer capable of displaying and navigating through millions of lines of code like a virtual environment. Arends, the creator and maintainer of the Rust-based Makepad project, demonstrated a 2.5-million-line codebase running at more than 120 frames per second. The unusual project has since attracted attention for both its scale and the enormous memory requirements of its earliest version.
Arends published a demonstration on September 12 showing the visualizer smoothly flying through a dense landscape of source files while keeping individual lines of code readable at close range. He said the application was running at 120 Hz on his system, although the video uploaded to X was limited to 60 FPS. Rather than reducing files to abstract blocks, the tool can transition from a large-scale view of a repository down to the underlying source text.
That initial demonstration was also extremely memory hungry. Arends said the version shown with the 2.5-million-line repository was consuming roughly 21GB of RAM, which made ideas such as immediately moving the experience into a web browser impractical. Subsequent work introduced additional indexing, caching and streaming techniques as he experimented with substantially larger repositories.
One of those tests involved Chromium, the enormous open-source browser project underlying Google Chrome and several other browsers. Arends later demonstrated the visualizer operating on Chromium’s source tree at 120 Hz on an Apple M3 Max system, initially using around 8GB of memory. After moving level-of-detail information and search indexes into a disk-backed cache, he reported memory usage dropping to about 3.5GB.
Tom’s Hardware reports that the Chromium repository used for the experiment contains around 51 million lines and could be loaded by the visualizer in roughly 60 seconds. That makes the test substantially larger than the 2.5-million-line repository shown in Arends’ original demonstration. The exact memory figures should not be treated as a direct before-and-after comparison for the same workload, however, because Arends’ 21GB figure came from the earlier demonstration while the 3.5GB result was reported during the later Chromium experiments.
The visualizer grows out of Arends’ work on Makepad, an open-source Rust application development environment focused on high-performance interfaces and fast iteration. Makepad uses its own GPU-oriented rendering stack and targets native platforms as well as the web, making a large interactive visualization a natural technical experiment for the project. Arends founded Makepad in 2019 and continues to maintain it.
What remains less certain is whether developers actually need to fly through their repositories. A 3D overview can provide an immediate sense of a project’s size and structure, but converting that spectacle into useful software-engineering information requires more than rendering source files as a landscape. Suggestions around the project have included showing dependencies between components and adding a time dimension so developers could visualize how a codebase changes between revisions.
Existing tools already explore similar ideas. CodeCharta, for example, can turn software projects into three-dimensional maps designed to expose metrics, hotspots and changes between versions. Arends’ experiment differs in its emphasis on fluid navigation and the ability to move from an enormous repository-scale view toward readable source code in real time.
Arends has indicated that the visualizer could eventually become a product offered for a small fee, although its final feature set and practical purpose have not been established. His more recent work describes a broader concept combining large-scale code visualization with AI-assisted development workflows, with conventional editors appearing as users zoom into specific areas of a project.
For now, the project is primarily a technical demonstration of how much source code can be rendered and navigated interactively on modern hardware. Moving from 2.5 million lines at over 120 FPS to experiments involving Chromium’s roughly 51-million-line tree shows that the concept can scale far beyond a typical repository, while the dramatic reduction in memory use during later tests suggests Arends is still actively optimizing how that scale is handled.
