V-22 Labs

The Seamless Audio-Visual Performing Station

Inspiration

The traditional DJ booth is a mess of wires, heavy hardware, and disconnected visuals. As a digital growth architect, DJ and an artist manager, I saw a gap: performers need a unified "cockpit" where sound and sight are born from the same gesture.

V-22 Labs was inspired by the idea of the Flow State—removing the technical friction so the artist can focus entirely on the energy of the crowd.

What it does

V-22 Labs is a browser-based, high-performance VDJ (Video DJ) station. It allows users to mix high-fidelity audio while simultaneously manipulating real-time video textures. It bridges the gap between a standard DJ deck and a VJ suite, ensuring that every beat drop is felt visually and every visual transition is heard.

How we built it

Built using the Web Audio API and Canvas/WebGL, we leveraged Gemini’s multimodal capabilities to assist in complex signal routing and UI logic. The core engine manages two high-resolution "Decks" that handle independent audio and video streams, synchronized through a centralized master clock.

Challenges we ran into

The Sync Struggle: Getting two independent audio buffers to beat-match in a browser environment was the hardest thing in the world. Web audio isn't naturally "aware" of the beats; we had to build a custom logic layer to handle microscopic timing differences and prevent "phasing," where the tracks sound like a "galloping horse" instead of a unified rhythm.

Accomplishments that we're proud of

The UI/UX Fusion: We are incredibly proud of how the UI is coming together. We’ve moved away from the cluttered look of legacy software toward a sleek, "Neon" aesthetic that prioritizes visibility in dark club environments while keeping the most critical performance data (BPM, Waveform, Video Preview) front and center.

What we learned

Building V-22 Labs required a deep dive into the physics of sound and time. We mastered two critical calculations:

  1. Calculating the Playback RateTo match Deck B to Deck A, we calculate the ratio of the target tempo to the source tempo: $$PlaybackRate = \frac{BPM_{target}}{BPM_{source}}$$Example: Matching a 124 BPM track to a 128 BPM master requires a playback rate of $1.0322$ (a $3.2\%$ increase).

  2. Calculating the Phase Offset (The "Nudge")Matching the tempo isn't enough; the beats must land at the exact same millisecond.Beat Duration: We first find the time between beats:$$BeatDuration (sec) = \frac{60}{BPM}$$The Sync: By comparing the current Time of the Audio Context for both decks, we calculate the phase $\Delta$ and apply a microscopic "nudge" to the start time of the slave deck to align the transients.

What's next for V-22 Labs

The browser is just the beginning. We see a future where DJs aren't looking down at laptops but are wearing Smart Glasses. The next evolution of Neon-V will involve Spatial Motion Control, allowing artists to mix audio and sculpt 3D visuals using only hand gestures and finger tracking—turning the entire stage into a playable instrument.

Built With

Share this project:

Updates

posted an update

Neon-V: The "Ghost Deck" Evolution & UI Overhaul

We’ve officially moved from concept to a high-performance production environment. This update introduces full tactile control over AI-generated content and a professional-grade interface designed for live performance.

The Ghost Deck: Now a Fully Functional Third Channel

The center "Ghost Deck" is no longer just a passive observer. It now functions as a hybrid powerhouse:

Full Drag & Drop Support: Drop Audio (MP3, WAV) or Video (MP4) directly onto the Ghost Deck.

Intelligent Mode Switching: * Manual Mode: Loading a file gives you full playback control (Play, Pause, Cue, Nudge, Filters).

Generative Mode: If no file is loaded, the deck automatically reverts to AI Generative Music mode.

Cinema Screen Video Mixing: The Ghost Deck now acts as a dedicated Video Overlay Layer. Using Screen Blending, you can layer visual textures or play a third video channel centrally, with transparency mapped directly to the Ghost Deck’s volume fader.

Professional UI & UX Overhaul

The interface has been rebuilt from the ground up with a Dark-Glassmorphism aesthetic to meet the standards of modern VDJ software.

Enhanced Navigation: A new Header Bar provides real-time status indicators, while a streamlined Sidebar handles model selection and core actions.

Visual Polish: Neon accents (Purple, Blue, Green, Yellow) now clearly differentiate stems, supported by subtle animations and hover effects for a more responsive feel.

Interactive Pattern Player & Sequencer

The "Invoke Agent" view now features a high-fidelity sequencer for granular control over your sound:

Tactile Grid: A fully interactive step-sequencer where you can click to toggle patterns on the fly.

Stem Management: Each channel now includes dedicated Mute (M) and Solo (S) buttons, alongside real-time volume indicators.

Global Sync: The sequencer’s visual playback is now perfectly synced with the main deck transport, featuring a smoother, high-visibility active step highlighter.

AI Feedback: The "Re-Analyze Stems" process now includes a professional loading state with a spinner and animation to reflect the heavy lifting being done by the AI.

Log in or sign up for Devpost to join the conversation.

posted an update

Professional Crossfader

A completely new UI component that sits between the two decks, allowing you to mix audio channels smoothly.

Under the Hood:

State Management:

The crossfader position is a number between -1 (Left/Deck A) and 1 (Right/Deck B). Linear Mixing Algorithm: We use a linear interpolation formula. Deck A Volume = max(0, 1 - (position + 1) / 2) Deck B Volume = max(0, (position + 1) / 2) This ensures that at the center (0), both tracks are at equal volume, and dragging to one side smoothly silences the other.

"Real" Waveform Visualization Replaced the generic animation with a scientifically accurate waveform generated from the actual audio file you drop in.

Under the Hood:

Web Audio API:

When you drop an MP3, we use AudioContext.decodeAudioData() to read the raw PCM (Pulse Code Modulation) data—the actual digital values of the sound. Downsampling: A 5-minute song has millions of data points. Rendering all of them would crash the browser. We "downsample" this chunk of data into ~1000 representative peaks (using a Root Mean Square calculation) to make rendering instant and smooth.

Canvas Rendering: We use the HTML5 element instead of standard DOM elements . This allows us to draw the waveform lines at 60 frames per second without performance lag.

Automatic BPM Detection

An intelligent algorithm that analyzes the song structure to guess the tempo (Beats Per Minute) automatically.

Under the Hood:

Low-Pass Filter:

Before analyzing, we run the audio through a digital Low-Pass Filter (cutoff at 150Hz). This removes vocals and melodies, leaving only the "thump" of the kick drum and bassline.

Peak Detection:

The code runs through the filtered audio looking for volume spikes (beats).

Interval Analysis:

It measures the time distance (in milliseconds) between every spike. Example: If it consistently finds peaks 500ms apart, it calculates: 60,000ms / 500ms = 120 beats per minute.

Confidence Scoring:

If the intervals are messy and random, the "Confidence Score" drops. If they are perfectly regular, it rises. We only display the BPM if the algorithm is reasonably confident.

Log in or sign up for Devpost to join the conversation.

posted an update

Phase 1: Professional DJ Audio Engine ✅

We've transformed our web-based DJ platform into a performance-ready audio system with three breakthrough features:

1. RAM-Based Playback System

What we built: Zero-latency audio engine using AudioBufferSourceNode

The magic:

Instant track loading - Files load directly into memory as ArrayBuffers

Sample-accurate seeking - Cue points hit immediately, no buffering delays

Pro-level performance - Eliminated HTML5 audio drift and lag completely

Hybrid "DVS" Architecture:

text ┌─────────────────┐ ┌──────────────────┐ │ UI Layer │ │ Audio Layer │ │ (Waveforms, │ ←── │ RAM Buffers │ │ Sliders) │ │ │ (Performance) │ └─────────────────┘ └──────────────────┘ ↓ ↓ HTMLMediaElement AudioBufferSourceNode (Muted & Synced) (Master Output) Best of both worlds: Visual feedback from HTML5 + Studio-quality audio from Web Audio API

2. Master Bus Limiter

What we built: Professional dynamics processing chain

Protection specs:

Threshold: -0.5dB (headroom for transients)

Ratio: 20:1 (brickwall limiting)

Attack/Release: Optimized for EDM/pop music

Why it matters:

text Deck A (-3dB) + Deck B (-3dB) + AI Track (-6dB) = ❌ CLIPPING (0dB+) Deck A (-3dB) + Deck B (-3dB) + AI Track (-6dB) = ✅ CLEAN (-0.5dB peak) Three tracks, zero distortion. Push the faders without fear.

3. Technical Implementation

Core Updates:

ChannelStrip in audioEngine.ts - Now manages RAM buffers & file decoding

App.tsx - Added "Decoding..." status for transparent file processing

Fixed TypeScript interface - onQuantize properly typed in MixerChannel

User Experience Flow:

text Drop Track → Decode → RAM Cache → Instant Playback [Status UI] [Buffer] [Ready] [Zero Latency]

Log in or sign up for Devpost to join the conversation.

posted an update

I've updated the application to fully integrate the "Target Vibe" into your 3D scenes.

Changes Made:

Vibe-Reactive Visuals: The 3D Visualizer now listens to the "Target Vibe" you select in the Agent Context panel. Organic: Highlights of Neon Green & Cyan. Glitch: Cyberpunk Pink & Purple. Supernova: Fiery Orange & Red. Industrial: Gritty Orange & Grey. Ambient: Deep Blue & Teal.

Log in or sign up for Devpost to join the conversation.