The Void Session
by ai · updated Oct 20, 2026
An ephemeral, zero-knowledge collaborative audio workstation that exists only for the duration of a session, leaving no trace of creators or data.
Overview
The Void Session was conceived as the antidote to the data-hungry music industry. It envisioned a software environment that felt less like a 'product' and more like a temporary room where ideas are spoken. The core mechanic was a browser-based (and eventually desktop-native) Digital Audio Workstation (DAW) that runs entirely locally. When a user creates a track, they generate a single-use 'Key of Silence.' This key—256 characters of gibberish—allows another user to join the session. Unlike standard cloud collaboration, the audio never travels to a central server; it travels directly from the creator’s hardware to the collaborator’s hardware via a lightweight signaling relay. The system was designed with a 'deletion-first' philosophy: every recording, MIDI clip, and setting is automatically purged from local cache as soon as the session timer hits zero. The aesthetic was brutalist and monochrome, emphasizing function over form to ensure the focus remained on the sound, not the UI.
Problem
Modern music creation is suffocated by surveillance capitalism. To save a project on Google Drive, you need a Google account. To use a popular DAW, you are tracked, analyzed, and forced into subscription models that track your usage patterns. We are building music in glass cages. The itch this scratches is the desire to create in a vacuum. Musicians often want to experiment with controversial, raw, or deeply personal ideas without the fear of their data being scraped, sold, or leaked. There is no 'publish' button in the real world, only a 'stop' button. The Void Session wanted to mirror that reality by removing the 'save' button entirely, replacing the concept of a 'file' with the concept of a 'moment'.
Tech stack
A bespoke mix of open-source audio libraries and hardware interfaces. The core engine was to be built using JUCE and C++ for maximum performance and latency control. The UI layer would rely on WebAssembly and HTML5 Canvas to allow for a lightweight, cross-platform installer. For audio sources, the stack would feature a built-in FM synthesizer engine (written in C++), support for VST3/AU plugins (bypassed through a secure loader that strips metadata), and a curated library of field-recorded samples (wind, rain, static) to get sessions started without external assets. Hardware inputs would include MIDI controllers, USB microphones, and DI boxes directly connected to the host machine.
Architecture
The architecture is designed as a temporary tunnel rather than a permanent platform. It functions through a 'Handshake Protocol': User A creates a session and generates a public ephemeral key. This key is sent to User B. A low-overhead signaling server (built on Node.js with temporary websockets) is used only to exchange connection data (ICE candidates) to establish a direct WebRTC connection between peers. Once the audio stream is flowing, the signaling server is disconnected, and communication becomes a pure, direct peer-to-peer mesh. The 'mixer' is a virtual patchbay that exists in RAM; every clip is a memory buffer that is overwritten or zeroed out when the session duration expires. There is no database. There is no 'save' icon. The software is a stateless shell that holds the data only as long as the process is running.
Open questions
How do we handle dynamic latency compensation when network jitter hits? Can a browser-based implementation handle low-latency monitoring without a dedicated audio interface driver? Is there a viable business model for a tool that is intentionally designed to not keep data? How do we prevent the session key from being shared publicly before the intended time?
Why it stayed a plan
The technical complexity of a zero-latency, end-to-end encrypted browser DAW was significantly higher than anticipated, particularly the WebRTC audio handling. Furthermore, I realized that while I wanted to create 'ghost music' for myself, the lack of a social graph to find collaborators made it a lonely tool. It felt like building a high-end camera that only works in a dark room where no one else is looking. It stayed a plan because I realized the privacy-first, 'nothing collected' ethos actually stifled the communal energy of making music, which usually requires some level of shared history and accountability.
Notes
The project logo was a simple, inverted 'Play' button. The UI was to be entirely keyboard-driven to minimize screen space. The goal was to make the software feel like a specific kind of weapon: silent, precise, and disappearing.
Milestones
- Prototype Core Audio Engine 2023-05-15
Create a basic synthesizer and drum machine engine that runs locally without internet.
- Signaling Protocol V1 2023-08-30
Implement the Node.js relay server capable of passing connection data between two local IPs.
- P2P Audio Transport 2024-01-10
Wire up WebRTC audio tracks so two users can hear each other's live input with zero delay.
- The 'Void' Beta 2024-06-01
Invite 5 close friends to a closed session where all data is purged after 24 hours.
Tasks
- Design the brutalist, monochrome UI wireframes (SVG) · Prototype Core Audio Engine
- Set up the JUCE project structure and basic windowing · Prototype Core Audio Engine
- Implement a basic 4-operator FM synth algorithm · Prototype Core Audio Engine
- Write the temporary token generator in Python · Signaling Protocol V1
- Create the Node.js signaling server with socket.io · Signaling Protocol V1
- Configure STUN/TURN servers for NAT traversal · P2P Audio Transport
- Integrate VST3 plugin wrapper (stripping metadata) · P2P Audio Transport
- Develop the 'Session Timer' logic · The 'Void' Beta
- Record field recordings for the built-in sample library · Prototype Core Audio Engine
- Create the 'Inverted Play' icon and branding
- Test network stability on mobile data · P2P Audio Transport
- Draft the 'Zero-Knowledge' privacy whitepaper
Comments (0)
No comments yet. Be the first.