Tommy Rombouts

I'm Tommy Rombouts, designer, maker, and what I like to call an Analog Futurist.

This is my personal space, where I document experiments, build prototypes, and explore ideas out of pure curiosity. No briefs, no deadlines, no clients.

Prototyping as a Performance is how I think about this practice. Every experiment is a small act, a question asked out loud. Some lead somewhere. Most teach me something.

You'll find interactive prototypes, music experiments, video sketches, and reflections on creativity and craft. Intentionally messy. That's the point.

Looking for my professional work?

If you're here for corporate communication, event design, or stage experiences, you're one click away from the right place. Together with my team, I'm a partner at Tonijn bv, a design agency that shapes corporate communication on screen and in the physical space. From impactful keynote presentations to full stage setups, we craft engaging event environments that leave lasting impressions.

Prototype 2026: SDJ Moog Matriarch — AU Plugin

SDJ Moog Matriarch is an Audio Unit plugin for Logic Pro that embeds an interactive, visual patch sheet directly in the DAW session. The idea is simple: analog hardware patches are fragile memory — a synthesizer recalled from a project two years later is useless if the patch is gone. This plugin solves that by placing the patch documentation where it belongs, inside the session file itself. The plugin is transparent. It passes audio through unmodified; its only job is to display the Moog Matriarch panel as a scaled UI, let the user interact with every knob, switch, fader, and patch point, and save all of that state alongside the project. How it works The panel background is a high-resolution photograph of the Matriarch (2313 × 633 px). Over that image, interactive controls are placed at exact hardware positions, defined in a JSON configuration file. Every control — rotary knob, 3-position toggle, on/off dot, vertical slider, square button, patch point — is drawn programmatically in JUCE and scales uniformly as the plugin window is resized. Patch cables are handled separately: clicking two patch points connects them with a drawn cable. Multiple cables per point are supported. Cable state persists with the session. The JSON layout is hot-reloadable via a button in the plugin UI. During development this meant positions could be adjusted without recompiling — drag a coordinate in the file, hit Reload, see the result immediately. Architecture The data-driven approach kept the C++ lean. A JSONParser reads the layout file into typed structs; a ControlFactory dispatches on the type string and instantiates the right component. Adding a new control type means writing one class and one line in the factory — nothing else changes. Control state is serialised through JUCE's ValueTree mechanism, which hooks directly into Logic Pro's session save and restore cycle. Panel-space coordinates (matching the background image's native pixel dimensions) are multiplied by a single scale factor — windowWidth / panelWidth — so everything stays in proportion at any window size. Implemented controls Seven control types are complete: rotary knob with arc indicator, 3-position dot toggle, single dot on/off toggle, square button toggle, vertical fader, patch point (input and output) with cable routing, and a static text label for annotations. All persist their state with the DAW project. Next steps The current build covers the Moog Matriarch specifically. The next phase is expanding to other synthesizers — each would be a separate plugin binary with its own panel image and layout file, sharing the same C++ source. The JSON-driven architecture makes that straightforward: a new synth requires only a background image, a layout file, and a unique plugin identifier.

Prototype 2026: Fairlight Audio Visualizer

The Fairlight Audio Visualizer is a real-time audio plugin for Logic Pro, built as an Audio Unit with JUCE and C++. It draws two reference points together into a single display: the stacked waveform lines of Joy Division's Unknown Pleasures cover and the Page R sample display of the Fairlight CMI — the legendary 80s synthesizer workstation that redefined what music production hardware could look like. The result is a waterfall visualizer that updates in tempo-synced steps, building a history of frequency snapshots as audio plays through it. The intent is not technical analysis but visual art: playing a synthesizer through the plugin and sweeping frequencies paints evolving waveform landscapes that can be captured as poster-ready stills. Tempo-Synced Waterfall The display cycles through 32 horizontal slices, advancing one slice per 8th note as locked to Logic Pro's transport. Each slice is a 64-band frequency snapshot of the incoming audio, mapped linearly from 20 Hz to 8 kHz — a deliberate choice that spreads bass and mid content across the full width rather than compressing it into the left edge. High frequencies above 8 kHz are cut entirely. A mid-high boost of up to 12× exaggerates peaks on the right side for more dramatic visual contour. The stepped animation creates a stop-motion rhythm that is as much about timing as it is about frequency content. Aesthetic and Color The duotone palette is fixed: #262626 background, #E8DAC8 warm cream for waveforms and text. No fills — outline only, each waveform a single continuous line. Timecode (bars:beats:ticks) appears in the top left in a monospace terminal font, BPM in the top right, raw frequency values along the bottom. The UI is fully resizable from 400×300 to 1920×1080, so the display scales to fill a monitor or a corner of a session. Plugin Architecture JUCE (Jules' Utility Class Extensions) is a C++ framework purpose-built for audio software. It is the industry standard for developing audio plugins and applications — used by Focusrite, Native Instruments, and hundreds of independent plugin developers. What makes it relevant here is that it abstracts the deeply platform-specific work of building an Audio Unit for macOS: the low-latency audio callback, DAW host communication (transport sync, BPM, timecode), the resizable plugin window, and the graphics rendering layer all come from JUCE, leaving the actual creative logic — the FFT analysis, waterfall geometry, and visual design — as the focus of the work. The plugin is a stereo Audio Unit (2-in, 2-out), built as a Universal Binary targeting both ARM64 and x86_64 — running natively on Apple Silicon and Intel Macs. FFT analysis runs at 2048 samples per block via JUCE's dsp::FFT. The core is split across three components: PluginProcessor handles audio and FFT, WaterfallVisualizer owns the display geometry and rendering, and PluginEditor coordinates the two. Two experimental visual styles — a 3D perspective version and an isometric projection — are preserved as backup files in the project. Creative Use The plugin is designed to be played like an instrument. A synthesizer patched into the input becomes a drawing tool: slow filter sweeps trace mountain ridges, sharp transients carve peaks, sustained chords build textured plateaus. Screenshots taken at the right moment produce artwork that reads as autonomous composition rather than signal analysis.

Prototype 2025: Ambient Engine

Ambient Engine is a generative ambient music system that runs entirely in the browser — no DAW, no plugins, nothing to install. The concept is rooted in the same territory as Brian Eno and Peter Chilvers' Bloom: an instrument that plays itself, producing a living harmonic system that never repeats the same sequence twice. The engine drives slow, evolving note sequences based on a fixed harmonic progression. Each chord is converted into a melodic pattern by a custom Emotional Arpeggiator, which selects the next note using three weighted criteria: interval tension, root-distance gravity, and emotional bias — a continuous variable that shifts the system between calm, hopeful, melancholic, and mysterious. The result is an arpeggio that feels organic rather than mechanical. The system has no interest in arriving anywhere quickly. That's the point — what makes it worth building is not how fast each iteration resolves, but how much each one promises. Audio Architecture The signal chain is built from scratch using the Web Audio API. Each generated note passes through a true stereo delay — left and right channels independently configured with their own delay time, feedback loop, low-pass tone filter, and dry/wet blend — followed by a convolution reverb whose impulse response is synthesised at runtime. The reverb supports multiple timbral modes (cloud, bright, dark, ghost), a freeze mode, and variable decay curves, producing the kind of atmospheric depth that transforms single notes into floating harmonic clouds. A high-passed shimmer path adds a subtle brightness feedback similar to Valhalla Shimmer, and a soft master limiter keeps the output stable regardless of feedback level. Scheduling Architecture Generative audio running inside a React app presents a specific problem: React's rendering cycle and the Web Audio scheduler operate on different timelines, and naive implementations drift, double-trigger notes, or lose sync between audio and visuals. Ambient Engine resolves this with a two-layer architecture. React manages the UI state — chord display, background colour, shader intensity, and FX controls — while a dedicated async loop outside the rendering cycle handles exact note timing, arpeggio sequencing, and chord transitions. Refs and promise chains ensure zero note overlap and no drift, mirroring the approach used in native audio engines. Visual System Every note event triggers a GLSL shader response: a soft pulse radiates through the background, and the ambient colour gradient morphs toward the harmonic palette of the current chord. Colour and harmony evolve together — palettes are embedded in the chord data alongside the note information — so the visual and sonic layers stay in continuous correspondence rather than being loosely coupled. The shader itself uses layered 2D value noise with time-based distortion and a music-reactive brightness lift on each note event. Context This is a prototype — a proof of concept for how far Web Audio and WebGL have come as a creative platform. It runs on any modern browser, on Mac, Windows, iPad, or phone, with no configuration required. The browser is the instrument, the DAW, and the stage.

Prototype 2025: Fader – Polyrhythmic Sequencer

Fader is a mobile-first generative music instrument built in the browser. It is a 4-lane polyrhythmic step sequencer that produces evolving compositions by running independent rhythmic lanes simultaneously — each at a different rate, each drawing notes from the same shared chord voicing in a shuffled, non-repeating order. The aesthetic model is the hardware modular world: Elektron DFAM, Cre8audio Subharmonicon — instruments where polyrhythmic interlock emerges from interconnected, independently-clocked subsystems. Each lane occupies a distinct register. A bass voice runs at 8th notes with staccato articulation. An electric piano runs at 16th notes with medium sustain. A pad voice moves in half notes, slow and atmospheric. A percussive hi-hat layer fires at 16th notes with sci-fi texture. Because there is no global clock — each lane advances on its own schedule — the four voices drift in and out of phase with one another, generating patterns that feel alive rather than mechanical. Controls Each lane has four vertical fader sliders that control step velocity and staccato duration simultaneously, and per-step mute buttons for live variation. The interface is deliberately minimal: frosted glass panels, a max-width of 390px, and rotated range inputs repurposed as vertical sliders. It is designed to be held in one hand and played with a thumb. Audio Engine The scheduler runs on 25ms polling intervals with a 140ms lookahead buffer — the same model used in professional Web Audio timing implementations. Notes are pulled from a pooled, shuffled sequence of each chord's root, third, fifth, seventh, and ninth, ensuring harmonic coherence without literal repetition. The signal chain passes through a true stereo delay with independent left/right sync divisions, feedback, and tone control, followed by a convolution reverb with variable impulse response length, and a final dynamics compressor as a limiter. FX parameters are stored in a plain JS object outside React state so the audio engine reads live values without triggering unnecessary renders. Visual System — React Three Fiber and Three.js The background is a full-screen GLSL shader built with React Three Fiber and Three.js. Three.js is a JavaScript library that makes WebGL — the browser's low-level 3D graphics API — approachable. It handles geometry, materials, lighting, cameras, and the render loop, removing the need to write raw OpenGL-style code. React Three Fiber is a React renderer for Three.js: instead of managing the Three.js scene imperatively, you describe it as JSX components that fit naturally inside a React application. For a project like Fader, this matters because the visual layer and the audio engine are tightly coupled — note events need to trigger shader pulses, and chord changes need to shift the colour palette in real time. React Three Fiber lets that communication happen cleanly through the same state and ref system the rest of the app uses, without a separate rendering context fighting for control. The shader itself uses layered 2D value noise with time-based distortion. Each note event fires a callback that triggers an intensity pulse with exponential decay, and simultaneously shifts the colour target toward the palette of the current chord. Colour interpolation runs at a 0.025 lerp speed — slow enough to feel continuous rather than stepped. The result is a visual field that responds to rhythm without feeling reactive in an obvious way. Chord Library 24 pre-composed scenes provide the harmonic material. Each scene contains jazz and ambient voicings, a suggested tempo, and a full colour palette — background gradient, accent, and text colours. The sequencer cycles through scenes automatically, or can be advanced manually.

Prototype 2025: Chord Progression Generator

A study in automation sitting halfway between music theory and creative coding. The starting point was a simple question: how far can you take chord generation inside a web browser? The answer turned into a React app that generates harmonic progressions from a database of 50 songs, plays them back as strummed electric piano, highlights the active notes on a 4-octave keyboard, and exports the whole run automatically — 50 chord variants rendered and packaged without touching a single one by hand. The project is equally interesting to musicians looking for harmonic ideas they wouldn't normally reach for, and to developers curious about combining browser audio with a real production pipeline. The final output was finished in Logic Pro for sound treatment and After Effects for visual polish, with batch exports tying the two ends together. What started as a single question became a complete system. The deeper it went into one narrow territory — harmony, voicing, automation — the more useful it became. That's not a coincidence. Music Theory Engine The song database stores 50 popular songs as JavaScript objects — title, artist, tonic, scale type, Roman numeral degrees, genre style, voicing mode, and tempo. From those inputs, chordGenerator.js derives every chord voicing at runtime using diatonic scale logic. Each chord is voiced as exactly 5 notes: bass root an octave below, root, 3rd, 5th, and an extension. Triad quality (major, minor, diminished) follows the scale; the extension (7th or 9th) is determined by the voicing mode assigned to the song. Four voicing modes shape the harmonic color: pop uses diatonic 7ths only; soul adds 9ths on I and IV; jazz targets 9ths on ii and V; electro applies add9 color uniformly across all chords. Octaves are clamped to a C5 ceiling to keep voicings in a playable register. Playback and MIDI Audio runs through soundfont-player using the General MIDI electric piano preset. The strum effect fires the bass note first, then spreads the upper 4 notes over 250ms — even and odd chords alternate direction for natural variation. Each chord sustains for 2 beats at 30 BPM, slow enough to hear every voice resolve. The engine simultaneously sends Web MIDI output, tested against Logic Pro's Virtual Input, so the session can capture and process the playback directly. The active chord row highlights in real-time as playback advances, and the piano keyboard updates per note event — the display functions as both a practice aid and a visual record of what was just played. Automation Pipeline The 50-variant run was generated fully automatically: the app cycles through every song entry, captures the output, and hands it to the post-production chain. Logic Pro handled sound processing per variant; After Effects handled visual framing and batch export. The workflow is repeatable — updating the song database and rerunning the pipeline regenerates the full set with no manual intervention per item. Progression Patterns The most common patterns in the database map to recognizable harmonic regions: I–V–vi–IV (modern pop), i–VII–VI–VII (dark synth), I–vi–ii–V (jazz-influenced), i–VI–III–VII (soul/electro), and I–IV–V (gospel/rock). Running all 50 across the four voicing modes surfaces how the same Roman numeral sequence reads differently depending on whether it is treated as pop, jazz, soul, or electro — the theory stays the same, the color shifts completely.

Prototype 2025: True Colors

Where the chord progression generator was about harmonic ideas for musicians, True Colors moves into visual territory: each chord in a curated library gets its own color palette, and playing that chord animates the screen in the colors it belongs to. The result is something between a music tool and a color tool — useful for anyone looking for palette inspiration tied to a mood or emotional register that only harmony can set. The interactive explorer holds 50 chord–color scenes, split evenly between pop and jazz registers. Each scene carries a chord label, a 5-hex color palette, and a short flavor description — a one-line cultural reference that grounds the palette in something concrete: a landscape, a time of day, a material texture. The descriptions function as a bridge between the abstract (a chord voicing) and the visual (five color bands filling the screen). Chord–Color Database All 50 scenes live in colorChords.js as structured objects. Each entry defines the chord name, its quality and extension, the 5-hex palette keyed to each note of the voicing, and the flavor line. The pop half of the library tends toward warmer, more saturated palettes with romantic or cinematic references; the jazz half leans into cooler or more complex color combinations — the kind of dissonance that reads as sophistication rather than tension. Browsing through them is itself a kind of study in how mood maps across genres. Playback and Animation Clicking Play fires the chord through two simultaneous soundfont layers: electric_piano_1 for the attack and body, and pad_2_warm for the sustain underneath. The voicing is 5 notes — bass root an octave down, root, 3rd, 5th, and an extension — built at runtime from the chord's root, quality, and extension type. As each note sounds, its corresponding color band rises from the bottom of the screen. Five notes, five bands, a synchronized translation of the chord's harmonic structure into a visual one. Tempo is adjustable from 20 to 80 BPM. At the low end the animation is slow and meditative — colors rise as if breathing. At the high end the strum feels more percussive and the visual follows. The Previous / Next controls let you step through all 50 scenes manually, comparing palettes as you go. Post-Production The final output follows the same pipeline as the chord progression generator: the browser session is captured live, audio is routed through Logic Pro for final treatment, and the visual output is polished and batch-exported in After Effects. The workflow is semi-automatic — the scenes step through in sequence and the recording captures the full run.

Archive 2024: Sound Design Blueprint

Visual templates for the Arturia Minibrute 2 and a WebAR experiment. Ready-made patch templates designed to accelerate the sound design process — each one built around an iconic track and made interactive through WebAR, so you can explore and refine parameters directly on the synth in augmented reality, without a native app. Freaks Like Me Inspired by the Sugababes' 2002 track — smooth vocal harmonies layered over raw, industrial-tinged production with a deep rolling bassline. References the influence of Gary Numan and early electro. Open WebAR template Sunglasses at Night Based on Tiga's reinterpretation of Corey Hart's 1984 classic. The Canadian producer's version is known for its brooding synth textures and pulsating basslines — a sleek, club-ready fusion of electroclash and techno. Open WebAR template Age of Love A 1990 rave anthem and one of the pioneering tracks of trance music. Iconic arpeggiated synth lines, ethereal pads, and a progressive structure that builds relentlessly. Open WebAR template Push It Good Inspired by Salt-N-Pepa's 1987 hit produced by Hurby "Luv Bug" Azor. Built around an instantly recognisable synth riff that defined the sound of late-80s electro-pop. Open WebAR template My Situation Based on Yazoo's 1982 synth-pop track. The British duo — Vince Clarke and Alison Moyet — were known for their innovative use of synthesizers, combining minimalist electronic production with powerful vocals. This template captures the infectious synth riff and pulsating bassline. Open WebAR template Bad Guy Bass Inspired by Billie Eilish's 2019 breakout hit — stripped-down yet powerful, built around a syncopated bassline and deliberate minimalism in the production. Open WebAR template

Archive 2023: PatchJournal — iOS App for Moog DFAM

PatchJournal is the second version of the DFAM companion iOS app — the step from AR experiment to something genuinely useful. The first version put augmented reality on the control panel, projecting preset information directly onto the hardware. This one adds what makes the app worth keeping open between sessions: one-tap patch storage and recall across the complete DFAM parameter set, with the AR layer retained alongside it. Building and releasing the app was equally about learning the full pipeline — not just development, but everything that comes after: landing page, explainer video, App Store submission, pricing, monetisation strategy. Having done it once, I now know what the distance from prototype to published product actually looks like. Patch Storage and Recall Moog DFAM patches are saved into named preset slots with a single tap. Every parameter is captured — switch positions, knob values, patch cable routing — stored in a single record on the device. Recalling a preset brings the full configuration back instantly, so a sound that took an afternoon to develop takes seconds to return to. The idea is simple: spend less time dialling in, more time making music. Full Parameter Coverage Every control on the DFAM surface is covered. Nothing is omitted or approximated — the app stores the complete state of the instrument in one place, on a device that is always nearby. For a synthesizer with no patch memory of its own, it fills an obvious gap. Augmented Reality Layer The AR function from the original app carries over intact. Aim the iPhone or iPad at the DFAM control panel and it detects the hardware automatically, overlaying the stored preset values directly onto the physical interface — each parameter shown in context, exactly where it lives on the panel. It is the fastest way to dial in a recalled patch without checking a screen separately from the instrument. Publishing Pipeline This was the first time I took an app all the way to the App Store. Development is one discipline; release is another. Writing App Store copy, producing the explainer video, designing the landing page, setting a price, navigating the review process — each of those is its own body of knowledge. PatchJournal is as much a study of that pipeline as it is a music tool.

Archive 2022: AR Experiment: Augmented Overlay Presets for Moog DFAM

Dial in sound patches instantly with the help of augmented reality. A visual overlay system for the Moog DFAM analog drum synthesizer that projects preset configurations directly onto the hardware in real time. Concept The Moog DFAM is a powerful semi-modular percussion synthesizer, but recalling patches from memory is slow and error-prone — there are no built-in presets. This experiment solves that by overlaying visual guides onto the physical interface through augmented reality, including knob positions and cable patching instructions. How it works Select a preset from the in-app menu and hold the iPhone over the DFAM. The AR layer aligns to the synthesizer's panel and displays the exact parameter positions needed to reproduce the patch. No screen-switching, no guesswork — the instructions live directly on the instrument. Built specifically for Moog DFAM users.

Archive 2022: AR Performance Capture: Playing Music with an Augmented Self

A live performance experiment combining augmented reality with hardware synthesis. An iPhone captures a real-time AR overlay while the Moog DFAM synthesizer performs underneath — blurring the line between physical instrument and digital layer. The setup routes three synthesizers — Moog Matriarch, Moog DFAM, and ASM Hydrasynth — through a Focusrite interface into Logic Pro. A custom Unity application built with Apple ARKit renders the augmented overlay directly onto the iPhone's camera feed during the performance. Process The experiment succeeded as a real-time capture, though the audio required post-production. The original iPhone recording lacked the multi-track fidelity of the studio session, so the audio was re-recorded in Logic Pro and synchronized with the visual capture. The result is a hybrid artifact — part live performance, part studio production.

Archive 2021: AR Experiment: Retro Studio in Augmented Reality

A virtual retro studio materialised on a wooden table through augmented reality. Speakers, VU meters, mixing faders, and a keyboard — all rendered with physically accurate materials and placed in real space using Adobe Aero. The experiment sits at the intersection of 3D material design and spatial computing. Each asset was modeled in Cinema 4D and textured in Adobe Substance 3D, focusing on realistic surface behaviour — brushed metal housings, translucent VU meter glass, rubber knob grips, and the warm grain of wooden speaker cabinets. Adobe Dimension served as the staging environment for lighting and material validation before exporting the assets into Aero for AR placement. Substance materials Getting the materials right was central to the experiment. Augmented reality is unforgiving — objects that look convincing on screen can feel flat and synthetic once composited into a real-world camera feed. Adobe Substance 3D made it possible to author PBR materials with fine control over roughness, micro-surface detail, and edge wear, giving each object the kind of subtle imperfection that makes it read as physical rather than digital. Ambisonic audio layer The visual scene is paired with an ambisonic music layer produced in Logic Pro using the Roland Zen-Core sound engine. The spatial audio reinforces the illusion of presence — sound sources correspond to the virtual objects in the AR scene, anchoring the experience in three-dimensional space.

Archive 2021: Virtual Event Platform Built with PlayCanvas WebGL

When Covid-19 shut down physical events in 2020, the demand for virtual alternatives surged overnight. Organisations needed ways to host conferences, bring distributed teams together, and share presentations and content — all through the browser, with no installs or plugins required. This experiment at Tonijn bv explored PlayCanvas as a platform for building interactive 3D virtual event spaces running entirely in the browser via WebGL. The result was a navigable multi-room environment where attendees could move between breakout rooms, watch livestreams, interact with presentation content, and engage through integrated chat. Building the environment The 3D spaces were modeled in SketchUp and Cinema 4D, then imported into PlayCanvas where they were assembled into a scene graph with interactive elements — navigation buttons to move between rooms, embedded video players for livestreams, and UI overlays for presentations and dialog. Custom JavaScript handled camera transitions, media playback, button states, and scene routing. Why WebGL The browser-native approach was a deliberate choice. With teams suddenly working from home on varying hardware and network conditions, a lightweight WebGL application accessible through a URL removed every barrier to entry. No downloads, no app stores, no IT approval — just a link and a browser.

Archive 2020: Music in VR: Spatial Audio with Google Resonance

A fully immersive VR experience that lets the listener see the spatial placement of individual audio sources inside a virtual underground space. Each instrument in the mix — synth strings, acid bassline, beats — is assigned to a physical speaker object positioned in the room. Walk around, look up, move closer to a stack: the sound shifts accordingly, revealing the architecture of the mix in three dimensions. The visual environment is deliberately stylised rather than photorealistic. Dark concrete panel walls, overhead industrial lighting cutting through haze, and clusters of speaker cabinets mounted at different heights and depths. The aesthetic is not meant to replicate reality — it aims to evoke the feeling of an underground rave: the weight of concrete around you, the way low frequencies reverberate off hard surfaces, the sense of being enclosed in sound. Spatial audio design Google Resonance Audio handles the spatial rendering inside Unity. Each audio source carries its own properties — position, directivity, and channel configuration. The synth strings are split into a stereo pair, floating left and right. The acid bassline runs as a single mono source from a central speaker. The beats are placed one meter from the concrete walls, with the room's acoustic properties set to simulate the dense, reverberant reflections of a concrete enclosure. The result is a mix that changes depending on where the listener stands — not a flat stereo render, but a spatial composition that surrounds and responds. Visual language The speaker labels visible in the scene are intentional. They expose the spatial configuration to the user — source name, channel assignment, distance from walls, acoustic surface type. The goal was transparency: let the listener understand how the sound is constructed in space, not just hear it. The visual consistency of the environment — monochrome concrete, colour-coded drivers (blue for strings, red for bass and beats), minimal geometry — reinforces the focus on sound rather than visual spectacle.

Archive 2020: VR and Paper UI: Bridging Virtual and Physical Instruments

When building musical instruments in VR, one problem becomes immediately apparent: there is no tactile feedback. Pressing a virtual button, turning a virtual knob — the hand passes through everything. The visual cue says "contact", but the body feels nothing. This disconnect is one of the biggest missing pieces in making VR instruments feel playable. This experiment attempts to bridge that gap between the virtual and the physical world. Instead of recreating an entire instrument inside VR, the setup keeps the real hardware — a Nord Lead synthesizer and a Focusrite audio interface — on the desk, and uses only the HTC Vive hand controllers as the interface between performer and sound. Cardboard as interface Simple cardboard cards are placed on the desk surface in front of the synthesizer. Each card acts as a physical trigger zone — a tangible surface the controller can strike or hover over. Hitting a card triggers a drum sound; moving a controller above another card controls the filter cutoff of the Nord Lead in real time. The cardboard provides what VR cannot: a surface that pushes back. The hand knows it has arrived somewhere. Signal chain The Vive controllers send positional and button data into Unity, which translates gestures into OSC messages. These are converted to MIDI and routed to the Nord Lead for real-time filter control, while drum triggers are sent to Logic Pro. The result is a hybrid instrument — physical keys for melody, cardboard surfaces for percussion and parameter control, all connected through the VR tracking system without ever putting on a headset.

Archive 2020: Contactless Interface: Depth Sensor to MIDI for Real-Time Sound Control

A contactless instrument interface that translates hand movement into real-time sound manipulation. An Intel RealSense depth sensor tracks hand position in three-dimensional space, and that spatial data drives the cutoff frequency of a synthesizer running inside Native Instruments Maschine — no physical contact required. The signal chain bridges three protocols. TouchDesigner reads the raw depth stream from the Intel sensor and maps hand distance to a normalised control value. That value is sent as an OSC message to OSCulator, which converts it into MIDI continuous controller data. Maschine receives the MIDI input and applies it to the filter cutoff of the active sound in real time. Moving a hand closer to the sensor opens the filter; pulling away closes it — an intuitive, physical gesture mapped to a sonic parameter. Why TouchDesigner TouchDesigner acts as the central nervous system of the setup. It handles depth image processing, gesture extraction, value smoothing, and OSC output in a single visual programming environment. Its real-time architecture makes it well suited for low-latency control chains where perceptible delay between gesture and sound would break the musical connection. Visual feedback The external display renders a real-time visualisation of the cutoff frequency directly from TouchDesigner — a generative line pattern that deforms in response to the same depth data driving the audio. The visual and sonic layers respond to the same gesture simultaneously, closing the feedback loop between performer and instrument. What the experiment revealed The setup worked exactly as designed. But running it in practice exposed two things the technical spec couldn't predict. First: without visual feedback, the interaction disappears. To anyone watching, the sound changes seem to happen on their own — there is no visible cause, no legible connection between hand and effect. The gesture that feels expressive to the performer reads as randomness to an observer. Second: the choice of parameter matters more than the precision of the control. Filter cutoff is intimate territory for a sound designer — the relationship between hand position and timbre feels direct and meaningful. But for anyone outside that world, it reads as abstract. Had the sensor controlled volume instead, the connection would have been immediate and universal. The experiment worked technically. What it exposed was the distance between a parameter that means something to the maker and one that is legible to an audience.

Archive 2019: VR Without Headset

Can you use VR controllers without ever putting on a headset? That was the question behind this 2019 installation — and the answer turned out to be a 4×4 grid of pads projected across an entire warehouse wall, played from a distance with nothing but a pair of Vive controllers and a pointing gesture. The setup strips away the headset entirely and redirects the spatial input outward: instead of inhabiting a virtual world, the controller becomes a precision pointer aimed at a massive shared display. Standing in a dark, warehouse-lit space, a single performer can trigger any of the 16 pads by pointing and firing — the grid reads like an oversized Native Instruments Maschine controller, familiar in layout but radically different in scale and interaction distance. Spatial Mapping The core technical challenge was reconciling the physical dimensions of the projection surface with the coordinate data coming out of the HTC Vive tracking system. Unity's world space and the screen's pixel space need to agree precisely — a point aimed at the top-left corner of the projected grid has to land on the top-left pad, not drift by half a square at the edges. Getting that mapping tight enough to feel responsive at performance distance required careful calibration of the relationship between tracked position, ray origin, and the projected quad in world space. Stage-Ready Interaction Removing the headset changes everything about presence and performability. The performer stays visible to an audience, can make eye contact, and orients to the real room rather than a virtual one. The scale of the projection — filling a warehouse wall — makes the interaction legible from across the space. Every hit reads clearly as an intentional gesture, which is essential in a live or installation context where the interface itself is part of the spectacle. The project was an early proof of concept for a class of performance tools that use VR-grade tracking without VR immersion: precise, expressive, and designed to be watched.

Archive 2018: Bassline Synth Modulation in Virtual Reality

The previous VR experiment was rhythmical. Expressive in its own way — you can see that in the recordings — but it had no melodic dimension. No pitch, no sequence, no sense of going somewhere harmonically. That was the shortcoming to fix. This version added frequency modulation, note velocity, and a step sequencer alongside the synthesis controls. For the first time it was possible to record actual melodies inside the virtual environment — not just trigger sounds, but shape them into something with harmonic intent. Synthesis Controls Both Vive controllers serve as hands-on synthesis interfaces, allowing live adjustment of cutoff frequency, resonance, decay, and envelope modulation. The system creates a direct physical relationship between body movement and sound character — leaning into or away from the parameter triggers shifts the timbre in real time. What the upgrade revealed Adding more controls solved one problem and immediately created another. The VR headset of that era had a fixed, relatively low display resolution — enough for spatial immersion, not enough for a dense UI with readable labels and fine controls. Everything worked. Nothing was clearly legible. The interface that felt logical on a screen became a blur at close range inside the headset. The lesson was simple and stayed: VR UI design is not screen UI design scaled down. The medium demands a completely different approach to information density. That became the starting point for the next experiment.

Archive 2018: MIDI Sequencing in Virtual Reality

A step-sequencer you can physically walk around and program by touch. There is no correct starting point — you can approach from any angle, activate any step from any position in the room. The sequence begins wherever you begin. Built on earlier VR instrument experiments, this version focuses entirely on MIDI sequencing: each pad responds to the slightest Vive controller contact, and the full 16-step pattern is programmable within the virtual environment.

Archive 2017: Apple ARKit, GPS Data and Sound

Combining Apple ARKit with GPS data to create a location-aware augmented reality experience with spatial audio. One of the early experiments with ARKit immediately after Apple introduced the framework. How it works GPS coordinates feed into the application to determine the user's position relative to points of interest. ARKit handles spatial anchoring, while the audio layer responds to both position and device orientation — placing sounds in the environment around the user.

Archive 2017: Controlling Virtual Musical Instruments with Hand Gestures

Playing virtual musical instruments using only hand gestures — no controllers, no physical contact. A Leap Motion sensor tracks the hands in 3D space and maps their position and movement directly to musical parameters. Approach The instruments are modelled and animated in Cinema4D, then built as interactive objects in Unity. The Leap Motion controller provides millimetre-accurate finger and hand tracking, allowing expressive playing technique in a fully virtual space. Sound is routed through Logic Pro for recording and production.

Archive 2017: Music in Virtual Reality

An early experiment in creating a virtual environment specifically designed around music and performance. Virtual instruments and stages built in Unity and Cinema4D, playable and explorable through Google Cardboard on iOS. The speakers visible in the virtual space are not decorative — each one represents a channel in a multichannel audio setup, visualising the spatial positioning of specific parts of the mix. As you move through the environment, the audio sources shift in relation to your position and head orientation, creating a spatial audio experience that maps directly onto the physical layout of the speakers in the scene. This approach treats the virtual space as an acoustic space: sound has a location, a direction, and a distance. The result is closer to being inside a live mix than listening to a stereo recording.

Archive 2016: 360 VR Animation Testdrive

This is a 360° video — click and drag to look around inside the scene, or use touch on mobile. The full environment is visible in every direction. A test-drive into 360-degree VR animation — rendering Cinema4D animations as equirectangular video and publishing to Vimeo 360 for playback in Google Cardboard. An early exploration of the workflow from 3D animation to immersive VR content.

Archive 2016: Character Rigging and Walk Cycle Animation

An exercise in character rigging and animation, combining Mixamo with Cinema 4D. Mixamo handles the heavy lifting of skeleton generation and auto-rigging — upload a character mesh and it maps a full bone structure to it automatically, ready to drive with its library of motion-captured animations. The workflow then brings that rig into Cinema 4D for refinement and final rendering. The goal was to explore how far this toolchain could take a custom character model: from a static mesh to a set of looping animations ready for social content, without building the rig from scratch by hand. Animations Created Walk cycle Jump Additional short loops for Instagram stories and social formats

Archive 2015: 3D Printed Model-Kit with Press-and-Fit Properties

Designing a toy as a self-assembly 3D printed model kit — a full sprue-style kit where every part ships attached to a single printed runner, ready to be snapped free and assembled without glue or fasteners. The sprue format — borrowed from classic injection-molded plastic model kits — turns the unboxing into part of the experience. Each piece connects to the runner via small gate points; a gentle twist and it's free, just like the Gunpla kits that inspired the format. Design Constraints The challenge was decomposing the model into a printable kit where every joint relies purely on friction fit. Replicating the snap-fit logic of injection-molded parts in 3D print requires deliberate engineering: wall thicknesses, tolerances and part orientation were all tuned specifically to the capabilities of professional SLS printing through i.Materialise. Unlike FDM printing, SLS allows the entire sprue — body, axles, chassis, smaller detail parts — to be printed as one cohesive object, with the dimensional accuracy needed to make press-fit tolerances actually work.

Archive 2015: Line Rendering Exercise with Exploded View

Playing around with the Toon shader in Cinema 4D. Building constructions with Lego — we all did it when we were young. The paper schematic building instructions that came with the kits were a joy for the eye. Amazing how, without any use of language, step by step, complete stories are told. We see Ikea doing the same thing with their flat-pack assembly guides, and later this kind of storytelling — learn by doing, step by step, discovery without instructions — shows up again in game design. There is also something visually pleasing about the exploded view: in one single overview you see the beauty of all the necessary steps of deconstruction and reconstruction laid out together. A true ode to craftsmanship. I don't know what, when, why or how — but some day I will do more with exploded views.

Archive 2014: Desktop Rotocaster

A small desktop rotational casting machine built from Lego Technic components, designed to reproduce TomyTones 3D printed figures in resin using a rotocasting process. Concept Rotocasting distributes liquid resin evenly across the inside of a hollow mould by rotating it on two axes simultaneously. A Lego Technic drivetrain provides the bi-axial rotation. The TomyTones figure mould is mounted on the machine, allowing multiple cast copies to be produced from a single 3D printed master.

Archive 2014: TomyTones Model in Ceramic

Printing the TomyTones character in ceramic through i.materialise — a material that requires different modelling constraints compared to standard polymer 3D printing. Process Ceramic 3D printing demands thicker walls, larger minimum feature sizes and no thin overhanging details. The Cinema4D model was re-engineered for the material: wall thicknesses brought up to spec, delicate features simplified, and the geometry checked for printability before submission. The finished ceramic piece was presented at Pictoplasma Berlin 2014, an international conference and festival focused on character design and art.

Archive 2013: 3D Printing Case for Raspberry Pi

Designing and 3D printing a custom enclosure for the Raspberry Pi. The case concept takes inspiration from cloud computing — translating an abstract technology metaphor into a physical object that houses the hardware. The model was designed in Cinema4D and printed through an online 3D printing service.

Archive 2013: Remix

The soundtrack of the film Drive had been sitting in my head for a while. That specific atmosphere — cool, synthetic, slightly melancholic, built for forward motion. When I heard a new track by The Arch, I knew immediately what to do with it. Not after analysis. In the first few seconds of listening. I offered to remix the track without being asked — no brief, no budget, no deadline other than the one I set myself. The only reason to do it was the challenge and the joy of it. And to keep the musical muscle trained. A skill you don't use quietly disappears. The remix was produced under the TomyTones name and is available on Spotify.

Archive 2013: Cinema4D and Kinect

This was 2013. Connecting a Kinect sensor to Cinema4D and having it record body movement directly onto an animation timeline — the fact that it worked at all was the exciting part. The setup uses the Ni-mate OSC bridge to stream skeleton data from the Kinect into Cinema4D in real time. Every joint in the body becomes an animation controller. The scene is built from cloners — Cinema4D's instancing system — arranged in a structure where every element is connected to the others. Moving in front of the sensor drives the whole system simultaneously, in ways that no mouse or keyboard workflow could replicate. That's the point of this experiment. The animation that came out of it couldn't have been made manually — not with that quality of organic movement, and not in that amount of time. Technical Setup The Kinect sensor streams skeleton tracking data via Ni-mate as OSC (Open Sound Control) messages. These are mapped onto a Cinema4D rig in real time, driving position and rotation across a network of connected cloner objects. Movements are recorded directly to the timeline during performance.

Archive 2013: 3D Model for Assembly

Developing the TomyTones character as a designer toy concept — starting from 2D sketches in Adobe Illustrator and building the full 3D model in Cinema4D with i.materialise as the output target. Concept The TomyTones figure is a vinyl-style designer toy character. The geometry was designed from the ground up with 3D printing constraints in mind: clean topology, appropriate wall thicknesses and assembly joints that can be printed separately and assembled by hand.

Archive 2012: iBook Authoring and 3D

When Apple introduced iBooks Author in 2012, the demo material was compelling — rich graphics, embedded video, interactive 3D objects, all inside a book format on iPad. I had all the ingredients already: the TomyTones animation, the 3D models, the Cinema4D workflow. The connection was immediate. So I tried it straight away. The software turned out to be more limited than the showcase suggested — the authoring experience was underwhelming and the creative constraints too tight to make it worth pushing further. I made the prototype, embedded the 3D character, confirmed the concept worked, and moved on. That's a valid outcome for an experiment. Not every tool earns a second session.

Archive 2012: iPad — OSC — Resolume

This started as play. A custom TouchOSC layout on an iPad, talking wirelessly to Resolume via OSC — clip triggering, effects, transitions, all from a tablet held in one hand. No cables, no mouse, no keyboard. At the time it was a proof of concept, built out of curiosity. What happened later is the more interesting part: the same technique found its way into professional work at Tonijn bv. A tool that existed because I wanted to see if it could exist became something genuinely useful in a live production context. That pattern — play first, application follows — has repeated itself enough times to feel like a method. The things built without a brief tend to be the ones that open unexpected doors. Setup Custom TouchOSC layouts designed to match Resolume's parameter structure, connected wirelessly over OSC (Open Sound Control). Full performance control from the iPad — clip triggering, effects and transitions — without any physical connection to the computer.

Archive 2012: 3D Model for 3D Printing

A lion head modelled in Cinema4D and prepared for 3D printing. The core task was producing a clean, printable mesh — but as an extra personal challenge, SubSurface Scattering was applied in Cinema4D to visualise the design in an attractive way: simulating how light penetrates and scatters through organic material like skin, giving the render a lifelike, translucent quality. SSS isn't needed for 3D printing itself, but it made for a far more compelling presentation of the model.

Archive 2011: 3D Modelling and Python Molecular Viewer

I have no understanding of antibodies, molecules, or protein structures. That's exactly why this project exists. Browsing articles and blogs one day, I came across visualisations of molecular structures — technically accurate, visually poor. The kind of imagery where the data is right but nobody has thought about how it looks. The connection was immediate: these are 3D objects. Cinema4D can handle this. The ePMV plugin — embedded Python Molecular Viewer — connects Cinema4D directly to scientific databases like the Protein Data Bank, pulling molecular geometry, bonds, and coordinates straight into the 3D scene. No manual modelling. The structure arrives as data and becomes an animation subject. Two things made this project stick. First: the render quality. The IgG1 antibody was rendered using Subsurface Scattering — a Cinema4D technique that simulates how light penetrates and scatters inside translucent materials like skin, wax, or organic tissue. It's not needed for scientific accuracy, but it transforms a clinical data visualisation into something that looks alive. The result looked like nothing a biology textbook had produced. Second: this was my introduction to Python inside Cinema4D — a scripting language running directly inside a 3D application. The scientific data was a one-time subject. The scripting capability was not. Technique The open-source ePMV plug-in runs Python inside Cinema4D and communicates with external data sources. Molecular geometry is imported directly from the Protein Data Bank and animated using Cinema4D's standard toolset.

Archive 2011: TomyTones and 3D Printing

It didn't take long — once I started 3D modelling, I noticed the rapid advances happening in the 3D printing world. i.materialise was founded in 2009 by Materialise to bring 3D printing within reach of consumers, home professionals, and small businesses — sitting alongside Materialise's industrial platform, Materialise OnSite. It operated as an online service, community, and marketplace where you could upload a design and choose from over 100 different materials and finishes. For a time, the Tomy Tones character was adopted by i.materialise in their documentation — a personal milestone that connected the modelling work to a real platform with a global audience. Over the years, the service attracted many notable designers, including avant-garde fashion designer Iris van Herpen and fashion-tech designer Anouk Wipprecht.

Archive 2010: 3D Modeling the World of Tomy Tones

Around 2010, I set out to sharpen my 3D modelling skills — with a deliberate focus on form and construction. It was a natural extension of my technical background in furniture making: an eye for proportion, structure, and how objects fit together in space. That discipline quickly found professional relevance in developing event media content — video mapping, stage design, and motion graphics. To give the experimentation a creative anchor, the character Tomy Tones came to life as both subject and muse. Cinema 4D became the tool of choice.

Archive 2003: Cinérex – Feeling Fine

Feeling Fine is a single by Cinérex, released in 2003. Written and produced by Tommy Rombouts, Kevin Ross, and Alissa Kueker. The song exists in two versions: the original Album Version and the Delicate Edit, which became the lead track of the CD single release. The Album Version The original version of Feeling Fine, as heard on the album, was shaped by a clear set of sonic references: the soulful, understated vocals and neo-soul atmosphere of Erykah Badu, the live-band-meets-hip-hop groove of The Roots, and the stripped-back minimalism of The Neptunes — the production duo behind N.E.R.D., known for their sparse drum programming, unexpected chord choices, and the ability to make space feel deliberate rather than empty. That influence is audible in the restraint of the arrangement: not filling every bar, letting the low end breathe, and trusting the feel of the groove over density. From album to stage When Cinérex began performing the material live, Feeling Fine developed into something more immediate. The live version pushed harder — more presence, tighter energy, less room for the arrangement to drift. That version became the foundation for the Delicate Edit, a reworked cut built around performance feel rather than studio precision. It runs 3:20 and prioritises concision: elements enter and leave with intention, and the structure is tight enough to hold attention without overstaying. Synthesis and arrangement The EMU Planet Phatt and Clavia Nord Lead 1 remain the primary sound sources. By 2003 the workflow had settled into a reliable pattern: rhythmic and lower-register content from the Planet Phatt, harmonic and melodic material from the Nord Lead, all running through the Focusrite channelstrip before hitting the converters in Samplitude 2496. The arrangement was constructed in audio rather than MIDI — each part recorded and placed manually on the timeline. Format and availability Feeling Fine is no longer commercially available. Both versions are preserved here as part of the broader Cinérex archive.

Archive 2001: Cinérex – Twist and Starts

Twist and Starts is the main single from CX, the debut album of Cinérex — a music project active around 2001. The CD single carries two songs from the album. Written and produced by Tommy Rombouts, Kevin Ross, and Alissa Kueker, with Bass by Mirko Banovic and Guitar by Jo Mahieu. The record is an archive piece. It is no longer available for commercial distribution, but it remains a useful reference point for how electronic music was assembled at the turn of the millennium — before the DAW became the instrument, and when hardware still dictated the workflow. Building the rhythm without MIDI Samplitude 2496 was the production environment — a multitrack audio editor at its core, with no sequencer or MIDI engine integrated. Drum patterns were not programmed; they were constructed as audio, placing each hit manually on the timeline rather than snapping to a grid. This approach forced a different relationship with timing and feel. Patterns were shaped by listening and nudging rather than by quantising, which accounts for a quality in the groove that a step-sequenced session would not have produced in the same way. Synthesis hardware The two primary sound sources were the EMU Planet Phatt and the Clavia Nord Lead 1. The Planet Phatt was a phrase and rhythm synthesizer built around sample playback — its strength was dense, rhythmically pre-loaded content that could be repitched, filtered, and layered into something that didn't immediately telegraph its factory origins. The Nord Lead 1 was one of the first commercially available virtual analogue synthesizers. Its subtractive architecture — four oscillators per voice, FM between them, a sharp ladder-style filter — allowed tight control over timbre. Bright attack transients, long vowel-like filter sweeps, dense unison patches: the Nord Lead handled the harmonic material while the Planet Phatt filled the lower rhythmic register. Signal path and gain staging All sources passed through a Focusrite channelstrip before reaching the converters. At this point in the timeline, quality analogue hardware made a real difference at the input stage — the converters and preamps bundled into affordable audio interfaces were not yet competitive with dedicated outboard. The Focusrite strip was used primarily for tone-shaping at capture: controlling low-end build-up, adding presence to synthesizer attacks, and ensuring the gain structure into the DAW was consistent between takes. The video clip A Korg keyboard appears prominently in the video clip shot alongside the release, though it played no part in the actual production of the track. Its presence was visual — the right shape for the frame — not functional. The footage was captured with the same economic constraints as the music itself: practical locations, available light, no crew.

Archive 1999: Recording with Ibanez Talking Machine

Remixing "Everybody's Weird" by dEUS under the artist name Cinérex, built around the distinctive sound of the Ibanez VOC TM-776 Talking Machine — a rare guitar effect pedal from the mid-seventies. The Ibanez Talking Machine The Ibanez VOC TM-776 allows a guitar signal to be shaped by the movements of the player's mouth, producing speech-like vowel sounds from the instrument. Produced between 1975 and 1977, the same effect type was used by Richie Sambora on Bon Jovi's "Livin' on a Prayer" (1986). Recording Setup The session was recorded to Tascam DA-88 and Tascam 38. The DA-88 is a modular digital multitrack recorder that uses Hi-8 tape and records up to eight tracks per unit — multiple units can be chained together for 16 or more tracks. The DA-88 won the Emmy Award for technical excellence in 1995.

Archive 1999: Music Production Tools Moving to Laptop

Documenting the transition of a full studio production setup onto a Compaq laptop running Samplitude 2496 — a significant shift in how music was made at the end of the nineties. This was the TnA project period, which also included sound design work for the Fuse club. The track "Do We" was released on vinyl (12") by Wha? Roots Recordings (WHA? 009) in 2001.

Archive 1997: From Producer to DJ with Pioneer CDJ-500s

Technological advancements always drove me forward — new possibilities, new inspiration, fuel to keep making music and pushing into multimedia. But a musician only exists when there is an audience. By 1997, CD players had become robust and reliable enough for stage use, and I could now burn my own discs. Combined with a Pioneer sponsorship, this opened the door to DJing. Inspired by the duo LTJ Bukem and MC Conrad, I decided never to perform alone — always flanked by MC Alissa, band member of Cinérex. I Love Techno 1999 The photos are from I Love Techno in 1999 — that evening I was working double, wearing two hats: DJ-producer on stage, and backstage with the Amphion team, pioneering live audio streaming of the event using RealAudio technology. Not as straightforward as it would seem today. Equipment The Pioneer CDJ-500 was central to the setup — one of the first CD players reliable and sturdy enough to trust on stage. Being able to burn custom CDs added a new creative dimension: original productions and edits, played live.

Archive 1996: Debut Single Cinérex — I Spy

The debut single of Cinérex — a track produced entirely on a Pentium 90MHz PC using first-generation consumer audio software. In 1996, everyone around us was producing on dedicated hardware. We used a PC. Not as a statement — it was just what we had. It turned out to be enough for MTV and TMF airplay. Production Context In 1996, producing music on a PC was still an experimental approach. The session ran on Cool Edit and SoundForge, with synthesis handled by the Clavia Nordlead 1 — one of the first virtual analogue synthesizers. The result was a track that bridged the hardware and software eras of music production.

Archive 1993: Digital Excitation Goodlife — Teknoville Party

A recording from the Teknoville party — one of the early rave events in Belgium, hosted by national radio Studio Brussels at the Cherrymoon club. Instruments The main instrument in this performance is the Akai VX600 — a synth with a brutal, aggressive filter, notorious for being difficult to control and occasionally drifting out of tune for no apparent reason. The bassline is a Casio CZ1000, particularly well-suited to that style of bass — a sound that would later become known as the "Reese Bass." Influence We were chasing the "Trance" sound — a sub-genre that emerged from the early techno scene. Listening back, you can clearly hear the influence of tracks like "What Time Is Love?" and "Kylie Said to Jason" by The KLF — who were, to my knowledge, the first to coin the term "Trance" on a record sleeve. Nobody knew yet whether trance would become a genre or just a passing moment. We kept going anyway — not because we knew where it was heading, but because the direction felt right.

Archive 1992: Digital Excitation — Sunburst

"Sunburst" by Digital Excitation — produced on Atari ST with a hardware setup built around the Yamaha TX16W sampler, Yamaha SY55 synthesizer, Roland TB-303 bassline machine and Boss DR-550 drum computer. The TB-303 The TB-303 was launched by Roland in 1981 as a budget auto-accompaniment device for solo guitarists — a programmable bass machine intended to simulate a bass player. It sold poorly, was discontinued in 1984, and flooded the second-hand market at throwaway prices. What followed is one of electronic music's great accidents: Chicago house and acid producers discovered that by tweaking the cutoff and resonance controls while a sequence played, the machine produced a uniquely squelchy, gurgling sound unlike anything designed before it. That "acid" character became a cornerstone of house, techno and rave — and remains one of the most recognisable sounds in dance music to this day. The track was remixed by Cubic 22.

Archive 1992: Digital Excitation — Lifetime Warranty

After stumbling across a second-hand Akai VX-600 — bundled with a wind controller — we found our next direction. Inspired by "Infinity" by Guru Josh and the emerging trance sound, we built a track around aggressive, rhythmically interrupted string sounds. No filters were used — all manipulation was done live, in real time, using the EQ on the mixing desk.

Archive 1991: Digital Excitation — First Appearance on MTV

This was 1991. We were very young, and we had no particular expectations about what making electronic music on an Atari ST might lead to. We weren't challenging anything deliberately — we were just making what we thought we should make, with the tools we had, because it excited us. Seeing the music video on MTV Europe's Party Zone was a surprise. A genuine one. Something made in a bedroom with a sampler and a drum computer resonated with an audience far beyond anything we had imagined. That doesn't happen because of strategy. It happens because the work is honest. The setup was an Atari ST with Yamaha TX16W and Akai S-1000 samplers, and the Casio CZ-1000 synthesizer. No guitar. No live band. Just sequences, samples, and a strong belief that this was music.

Archive 1991: Digital Excitation — Dreamparty

"Dreamparty" by Digital Excitation — one of the breakthrough tracks from the Belgian new beat and early rave era. Produced on Atari ST with Roland TR-808 rhythm machine, Yamaha TX16W and Akai S900 samplers. The track was remixed by Frank De Wulf and Cubic 22.