This work begins with code. Not with an image, not with an object, not with paint or clay or a room — with code. The code is the origin and the authority. What it generates is the work: a living digital thing that exists in time, loops, breathes, and ends. Any subsequent form — a physical object, an installation, a spatial experience — must remain faithful to what the code actually does. A screenshot is not the work. A video of the work is not the work. Showing something more legible, more printable, more displayable in place of the running code is a betrayal of the intent. The chain is specific: code creates a digital loop; the loop informs an object; the object opens into a physical experience. Each step is earned by the one before it. Each step asks the same question — what is this code doing, and what does fidelity to that look like here?
Three code-based works in three dimensions — digital, object, and spatial. The same code runs all three.
The work exists in three dimensions. The digital dimension is where the code runs and the work lives — a loop, a generative system, a living thing in time, existing in the Loop Metaverse. The object dimension is where the same code runs a physical thing: a Teensy 4.1 driving an LED panel, the code knowing it is on hardware and behaving accordingly. The spatial dimension is a distributed room — multiple nodes, sensors, motors, projectors, each receiving OSC instructions from a shared nervous system, each contributing to a single organism. The specific works within each dimension are in development. The framework is fixed.
The digital dimension lives in the Loop Metaverse. The code runs as a generative loop — seeded, deterministic, ownable. A six-character hex seed governs the entire visual composition: entities, colors, lifecycles, spatial arrangement. The same seed on any machine produces the same output. This is the foundational logic of on-chain generative art: the artwork is the algorithm, the hash is the provenance, the loop is the form.
The most important property of the digital dimension is that the code knows it is there. Context-awareness is not a feature added on top — it is written into the system. The same codebase that runs in the Loop Metaverse will behave differently on a Teensy 4.1 because the code understands its role. The seed is the shared identity across all three dimensions. A recording of the loop is an output. It is not the work.
The object dimension is a Teensy 4.1 driving an LED panel approximately 20 square inches. The same code that runs in the Loop Metaverse runs on this hardware — it knows it is on an object, and it behaves accordingly. The object is not a display showing the digital work. It is the digital work running in a different context. The code's context-awareness is the object's identity.
Andreas Gysin's LCD 1 remains the conceptual benchmark: hardware and software as a single entity, a device with no other reason to exist. The Teensy 4.1 + LED panel is this work's equivalent — a purpose-built node whose sole function is to run this code in this form. The fabrication partners map directly onto what is needed to realize it.
Enclosure and mounting hardware. The object's physical form — what holds the LED panel and the Teensy — is as considered as the code running on it.
CW&T's single-purpose object philosophy is the closest match to the ambition: a thing designed to do exactly one thing, indefinitely.
If the object dimension is editioned — one per seed, one per collector — production scaling partners are in place.
The hardware layer: Teensy 4.1 receives OSC from the network, drives the LED panel, reports its state back into the distributed system.
The spatial dimension is a room that is also an organism. Multiple Teensy 4.1 nodes receive OSC messages from a Linux engine and each drive a different output — projector, fan, LED wall, sensor, LED panel. No single node controls the room. The room is the system, and the system is aware of its own state. A motor glitches: the Teensy recognizes it, the state enters the OSC stream, the audio shifts, the pixels on another node respond. The glitch is not an interruption — it is the room recognizing itself.
Visitors are not audience. They enter with iPhones and can alter what the code does in real time. Multiple people simultaneously. The room responds not as a performance responding to an audience but as an organism responding to stimuli. The distinction matters: in a performance, the work is fixed and the viewer moves around it. Here the work is running, and the viewer is one of its inputs.
Rune Brink Hansen's spatial practice is the relevant precedent — his key insight that the viewer should feel inside the feeling, not in front of an image, is what the distributed room achieves when it is working. The atmosphere is not designed; it is generated, node by node, in real time, from a shared state that no one person controls.
There is no audio track. There is no visual track. There is code, and the code produces all of it. This is Agoston Nagy's position and it is this work's position: sound, image, and movement are not three things coordinated by a composer — they are one system expressing itself through different outputs. The Roland S1 is a node. The LED panel is a node. The fan is a node. None of them has a score. They all have the same source.
This matters because it changes what the work is. A film has a director, a composer, a cinematographer — separate authors of separate tracks assembled in post. This work has one author and one track: the code. Whatever the room sounds like at any moment is what the code is doing at that moment, expressed acoustically. Whatever it looks like is the same thing expressed visually. The separation that most installation art takes for granted does not exist here.
Eight influences span blockchain practice, language-art, spatial installation, hardware/software synthesis, the ethics of native digital aesthetics, mechanical systems, robotic mark-making, and body-as-input performance. Together they describe the full ambition of the project.
The system is the artwork. The code is context-aware — it knows whether it is running in the Loop Metaverse, on a Teensy 4.1 driving an LED panel, or as part of a distributed room. The same codebase behaves differently in each dimension because the dimension is written into the code as a role, not imposed from outside. This is the critical technical realization of the artist statement: fidelity to the code's intent is not a constraint on the work — it is the work's architecture.
The spatial dimension is a distributed network. A Linux computer runs the OSC engine — the central nervous system of the room, not a playback system. Every node talks to every other node. A motor glitches: the Teensy recognizes it, that state change enters the OSC stream, the audio shifts, the pixel behavior on the LED wall shifts in response. The room is aware of itself. No single node is in charge. The Roland S1, Daisy, SP, Bella, the Teensy 4.1s, the sensors, the iPhone, and a plotter node — all are participants in a shared state that none of them fully controls. The plotter is not a documentation endpoint; it is part of a feedback loop where system state generates marks, those marks are scanned/interpreted, and that interpretation re-enters the OSC stream. When something breaks, the system doesn't stop — it responds. The glitch is not an interruption of the work. It is the work recognizing itself.
The dashed line on the iPhone node marks a distinction: it is not a passive output but an input — multiple people in the room can simultaneously alter the work. The room is no longer a presentation. It is a shared instrument. The code running on each Teensy 4.1 understands this: it listens, it responds, it knows it is one node in a larger organism.
The artist statement at the top of this document is the work's spine: code begins everything, and fidelity to what the code actually does is the principle that determines every subsequent form. That principle now has an architecture. Three dimensions — digital, object, spatial — each running the same code in a different context. A distributed room where the code knows its role, the system absorbs its own failures, and the visitors are not an audience but a fourth kind of participant.
What is unusual about this position is that it distributes authorship without diluting it. The artist writes the code. The code runs the system. The system responds to itself and to its visitors. Nobody is in charge of what the room does in any given moment — and yet the room is unmistakably the product of a single set of decisions made at the code level. The author is present everywhere and nowhere simultaneously. That is a precise and interesting place to be.
The work is not finished. The specific works in the digital dimension are still being chosen. The object has not been fabricated. The room has not been built. But the framework is clear, the architecture is designed, and the principle holds at every level. What remains is making: integrating Daisy, SP, Bella, and the plotter as live nodes in the same feedback loop so marks, sound, light, and interaction continually inform one another.