Welcome to the Void:
Reclaiming the Computer

In the Void, there are no apps. The traditional app paradigm locks your data and tools inside rigid boxes — a separate box per task, each with its own walls. Void operates entirely on actions instead.

When you have an idea, you express the intent. Jot a thought, play a podcast, dim the screen — you issue a command or perform a gesture and the system responds instantly. The point is to keep you in a flow state: strip out the friction of hunting through software silos so you can keep thinking without interruption. The app was always a packaging decision, not a law of nature. Remove it and what's left is just you and your intent.

Your computing experience shouldn't be trapped inside a single laptop or a single phone screen. Void is designed to dissolve the boundaries between physical devices. The computer becomes less an object and more a distributed network spread across the room:

• Turn a custom, 3D-printed dial on my desk and it instantly zooms a map projected onto the wall.
• Walk up to any smart TV or tablet, open a simple URL (io.thatvoid.com), and co-opt that screen as an extension of my workspace.

Hardware here is just-in-time. If I need a new input method or display, I build a cheap modular device — a Raspberry Pi, an ESP32 microcontroller — and it immediately becomes part of the Void. The wooden box below is the patron saint of that idea: hand-built, single-purpose, made because the interaction it enabled didn't exist yet.

How do all these devices and actions talk to each other so seamlessly? Through a global event bus I call the Omnibus.

In traditional computing, you click a button and one specific function runs — a private wire between cause and effect. In Void, everything you do instead emits an event into the Omnibus. Turning a dial, typing a command, tracking your gaze: all of it becomes events broadcast onto a shared channel. Any device or piece of software connected to the Void can listen and react in real time.

The button-press is a private message. The event is a public broadcast. That single change is what lets people, AI assistants, and modular hardware collaborate in the same shared space at once.

This is the hinge of the whole system. Decoupling what happened from what reacts to it is exactly what makes multiplayer (further down) a natural consequence rather than a bolted-on feature.

To see what makes Void radically different on a software level, we go back to Kay's Smalltalk and Engelbart's philosophy of bootstrapping. Mainstream computing relies on static files: you edit a file, stop the program, restart it, and hope. Void moves toward an image-based environment instead — the system runs as a continuous, living state. The line between the “developer environment” and the “user interface” simply doesn't exist.

Using a custom REPL launcher called the /void-bar, I write natural-language or JavaScript commands to live-patch the code of the interface I'm currently using:

This is true bootstrapping: using the tools I build to continuously improve and evolve those very same tools, from inside the system itself. The software is completely plastic — I can tweak, evolve, and rewrite my environment on the fly in under 200 milliseconds, with zero lag and nothing to reload. The system you're using and the system you're editing are the same system.

Up to now I've built the Void mostly for myself — the crash-test pilot of my own digital life, hacking at the experiences that cause me the most pain and rebuilding my environment one piece at a time. It started as a solitary mission to reclaim my own human–computer interaction.

But the natural extension of this architecture — the thing that makes it genuinely transformative — is putting collaboration at the absolute core. Which brings us back to Engelbart's real goal: boosting our collective IQ, building a shared intellectual space.

Because Void rests on an event bus and continuous, image-based state rather than static files, “multiplayer” isn't an awkward bolt-on or a glorified screen-share — it's a consequence of the design. Collaboration is native:

• For code: using CRDTs (conflict-free replicated data types), the codebase itself becomes a shared, living state. Multiple developers inhabit one workspace; changes propagate instantly, with no files and no merge conflicts.
• For knowledge: the Knowledge Web becomes a multi-user world. Zoom out and watch where collaborators are exploring in real time — connections lighting up across the globe as they're forged.
• Radical individuality, still: want to test a wild idea? Opt out of the shared master state, branch into your own private runtime, experiment safely — then selectively pull others' changes in, or push your invention back to the collective.

I started this journey to fix my own computers. But the destination is a fluid, moldable environment where communities can weave ideas, interfaces, and knowledge together — and augment human intellect in real time. The same thing Engelbart was pointing at, from behind that headset, in 1968.