previous
Most blockchain dashboards look like spreadsheets. Rows of numbers, green and red candles, wallet addresses you can’t pronounce. They work, but they don’t help you understand what’s actually happening on a network. You’re reading data, not seeing it.
When our team at BasedAI needed a way to monitor the network, I wanted to try something different. What if instead of reading a dashboard, you could watch the blockchain work? What if every node was a physical object you could explore, and the health of the network was something you could see at a glance?
That’s what The Nexus is. A real-time 3D visualization of an entire blockchain network, where every node is an interactive object and the data encodes itself through color, motion, and spatial position.
A table of nodes with columns for agent count, activation status, token claims, and metadata is technically complete. You can find anything if you scroll long enough. But you can’t feel the state of the network. You can’t glance at it and know whether things are healthy or dying.
In the Nexus, every compute node renders as an icosahedron arranged in a Fibonacci spiral. The spiral uses the golden angle (222.49 degrees of divergence) so nodes distribute evenly without clustering, the same pattern you see in sunflower seeds and pinecone scales. It makes the network feel organic rather than like a grid.
The data lives in the visuals. Brightness maps to activity: idle nodes are dark, busy nodes glow cyan. Nodes with fractional token status spin. Nodes that haven’t registered metadata render as wireframes, while active ones are solid. You can look at the whole spiral and immediately know which parts of the network are alive and which are quiet. No scrolling, no filtering, no mental math. Just spatial awareness.
Rendering that many individual 3D objects in a browser and keeping everything interactive is a real performance challenge. Each node needs to respond to hover (scales up, shifts color), respond to double-click (camera zooms in, metadata panel opens, other nodes fade out), and continuously animate based on its data state.
The scene uses a performance monitor that dynamically adjusts rendering quality based on the user’s hardware. If framerates start dropping, it scales down the pixel ratio. If things are running well, it cranks it up. This means someone on a powerful desktop gets crisp visuals while someone on a laptop still gets a smooth experience.
The entry sequence is deliberate too. When you first load the Nexus, the nodes don’t just appear. They spring-animate from scattered random positions into the Fibonacci spiral over about 1.5 seconds, while the scene rotates to reveal the full layout. It gives you a moment to orient yourself before the data starts making demands on your attention.
The whole point of putting this in 3D instead of a table is that you can explore it. Drag to orbit around the spiral. Scroll to zoom. Double-click any node and the camera smoothly flies to it, the rest of the network fades to dark, and a detail panel slides up showing the node’s metadata, owner, agent count, and activation status.
There’s also an in-scene number pad. You can punch in a specific node ID and the visualization highlights it in the spiral. It’s a small thing but it means you never have to leave the 3D view to find what you’re looking for.
The price data, supply breakdowns, and market stats are rendered as 3D geometry inside the scene, not as DOM overlays on top. The charts are actual shapes in the world. This keeps the whole experience feeling like one cohesive environment rather than a 3D widget with HTML bolted on top.
Oh, and there are a few easter eggs hidden in the node IDs. Try searching for some interesting numbers. That’s all I’ll say.
The visualization is only as good as the data feeding it. A backend service scrapes the blockchain continuously, pulling node stats, token prices, supply data, and network metadata. The frontend fetches this on load with staggered timing so no single request bottlenecks the experience.
State management uses a reactive proxy system, so when new data comes in the scene updates without re-rendering everything. Only the nodes whose data actually changed respond visually. This matters when you have up to 1024 that each need to independently reflect their current state.
The background itself is a procedural shader using fractal Brownian motion noise, creating a subtle animated atmosphere behind the nodes. It’s memoized so the shader only compiles once and just updates the time uniform each frame. A small optimization, but in a scene this dense, everything adds up.
Every visual choice in the Nexus exists to communicate something. The Fibonacci spiral isn’t decorative. It’s the most efficient way to distribute hundreds of objects in space without overlap or wasted area. The color scale isn’t aesthetic preference. It’s a mapping from numerical agent count to perceptible brightness so your eyes do the analysis instead of your brain.
The lighting uses an HDR environment map from a real-world scene, which gives the icosahedrons subtle reflections that make them feel like physical objects rather than flat shapes. When a node spins, the reflections shift across its faces. When you zoom in, the surface detail holds up. These details don’t show up in a feature list, but they’re the difference between a visualization people glance at and one they actually spend time exploring.
I designed the interface, built the 3D scene, wrote the backend data pipeline, handled the shader work, and shipped it. The goal was to prove that complex data doesn’t have to be boring to look at, and that making it beautiful doesn’t mean making it less useful.
Live: basedai-nexus.vercel.app Code: github.com/AaronJCunningham/nexus