ImmerGround records your live performance events and audio timelines without dropping a single frame, storing exact parameter changes and MIDI triggers in an event sequence file. When your performance finishes, the application routes those exact commands into an offline render pipeline, allowing you to export pristine 720p, 1080p, 1440p, and 4K MP4 video files at steady 30 fps or 60 fps regardless of your hardware real-time rendering limits.
Event Recording Architecture
The core of the recording system relies on an event-driven architecture rather than simple screen capture. Screen capture utilities encode the display buffer into a video file in real time.
This approach consumes significant GPU overhead. When the rendering load peaks during dense visual effects, the display framerate dips.
A real-time screen capture utility records those dropped frames. The final video output contains stuttering video.
ImmerGround takes a fundamentally different path. It bypasses the display buffer entirely during the recording phase.
When you trigger the record button, the engine spawns a dedicated background thread. This thread acts as a listening node.
It captures every single state change across the entire application interface. Every fader movement, button press, MIDI note, and audio reactive threshold violation generates a discrete event object.
These event objects contain a timestamp, a target parameter ID, and a value payload. The timestamp uses high-resolution system clocks.
The engine aligns these timestamps against the audio timeline. 0 over two seconds generates hundreds of event objects.
The background thread appends these objects into a lightweight binary sequence file. This sequence file acts as a precise script of your entire performance.
Because writing small binary structures to disk requires negligible CPU resources, the recording process has zero impact on real-time render performance. You can execute complex visual routines on older iPads or entry-level Mac hardware without inducing stutter.
Audio recording operates on a parallel track. The application captures the incoming audio stream from the microphone or direct line input.
It stores this audio data as an uncompressed WAV format within a temporary session directory. The engine synchronizes the start of the audio file with the zero-point timestamp of the event sequence.
This guarantees perfect alignment between the recorded audio and the recorded parameter changes. The event architecture also manages state snapshots.
At the exact moment recording begins, the engine writes a master state snapshot. This snapshot contains the current value of every parameter, the loaded video source files, and the active routing configurations.
When the time comes to render the video, the engine loads this snapshot first. It restores the exact visual state that existed when the recording started.
It then steps through the event sequence, applying every captured delta change at the precise timestamp. The system stores these sessions inside the application sandbox.
You can record dozens of performances during a single session without worrying about storage space. The event sequence files measure in kilobytes.
The uncompressed audio files consume standard disk space based on sample rate and duration. A ten minute performance recording requires roughly 100 megabytes of storage for the audio, while the performance sequence uses less than 50 kilobytes.
This efficiency allows you to record multiple takes, review them quickly, and select the best performance for final rendering. Memory management during the recording phase relies on cyclic buffers.
Instead of allocating new memory for every event object, the engine pools objects in a ring buffer. As the performance progresses, the engine flushes the buffer to disk in chunks.
This prevents memory leaks and ensures stable memory consumption even during extended recording sessions lasting several hours. Live electronic musicians playing long club sets can leave the recording running without encountering application crashes.
Real-Time Quick Preview MP4 Output
While offline rendering provides maximum quality, performers often need immediate access to their recordings. They need to verify performance timing, check audio levels, or quickly share a clip with collaborators.
To support this need, ImmerGround includes a real-time quick preview system. This system operates alongside the event recording architecture.
It provides a low-overhead video export immediately upon stopping the recording. The quick preview system hooks into the final output stage of the real-time render pipeline.
It reads the rendered frame buffer immediately before it reaches the display. It routes these frames into a hardware-accelerated video encoder.
On Apple hardware, this means utilizing the VideoToolbox framework. VideoToolbox accesses the dedicated media engines present on Apple Silicon and modern Intel processors.
These media engines encode video frames with minimal impact on the main CPU or the graphics processing unit. 264 format inside an MP4 container.
It uses a variable bitrate profile optimized for speed rather than ultimate quality. The resolution of the preview video matches the internal render resolution of the application.
If the application dynamically lowers the internal resolution to maintain framerate during a heavy visual load, the preview video reflects that lower resolution. The framerate of the preview video matches the display framerate.
If the display drops to 45 frames per second, the preview video records at 45 frames per second. 264 video stream in real time.
When you press stop, the MP4 file is immediately ready for playback or sharing. No waiting period exists.
The system places the file in the standard iOS Photos library or the macOS file system. You can open it in the default media player, send it via AirDrop, or upload it to a messaging platform.
This quick preview is not intended for final distribution. Its purpose is purely functional.
It provides a rough reference point. The variable framerate can cause sync issues in non-linear editing software.
The variable resolution results in inconsistent image clarity. The hardware encoder prioritizes speed, which can introduce compression artifacts during fast motion or complex color gradients.
However, for immediate review, it is indispensable. The quick preview system allows performers to adjust their techniques on the fly.
A VJ can record a test run of a new visual sequence, watch the preview, and immediately spot timing errors in their MIDI controller mapping. A musician can record a quick take of a music video concept, review the visual response to the bassline, and tweak the audio reactivity thresholds before recording the final take.
The immediate feedback loop accelerates the creative process. By splitting the recording process into two distinct outputs, the event sequence and the quick preview, ImmerGround satisfies two contradictory requirements.
It provides instant access to a reference video while simultaneously preserving a pristine set of instructions for a perfect offline render. You never have to choose between speed and quality.
The system gives you both.
Render HD Engine: 720p, 1080p, 1440p and 4K Export
The Render HD Engine translates the captured event sequence into a final, high-fidelity video file. This process happens entirely offline.
Offline rendering removes the constraints of real-time performance. The engine processes one frame at a time, taking as much time as necessary to render every pixel accurately.
It guarantees a perfectly steady framerate and maximum image quality. When you initiate an offline render, the engine creates an isolated, invisible render context.
This context operates independently of the main application interface. It configures the graphics pipeline based on your selected export settings.
You can choose between four standard resolutions: 720p, 1080p, 1440p, and 4K. All resolutions use a standard 16:9 aspect ratio for horizontal video or 9:16 for vertical video.
The engine allocates frame buffers matching the exact dimensions of your chosen resolution. The render pipeline walks through the event sequence frame by frame.
For each frame, it calculates the precise time based on the target framerate. You can select either 30 frames per second or 60 frames per second.
A 60 fps export requires rendering exactly twice as many frames as a 30 fps export. This directly doubles the total render time.
However, 60 fps provides smoother motion for fast-paced visual changes. At each frame interval, the engine reads the event sequence to determine the state of all parameters.
It applies any changes that occurred since the previous frame. It calculates the position of video playback sources.
It updates the audio reactivity values based on the stored audio file. Once the entire state is updated, it issues the draw commands to the graphics processing unit.
The GPU processes the shaders, applies the color conversions, and generates the final image for that specific frame. After the GPU finishes rendering the frame, the engine copies the pixel data from the graphics memory to the system memory.
It then passes this pixel data to the video encoder. The offline render utilizes a high-quality encoding profile.
It uses higher bitrates than the quick preview system. It employs advanced motion estimation algorithms and multi-pass encoding techniques.
This results in a cleaner image with fewer compression artifacts, especially in areas with complex gradients or rapid movement. The system allows you to configure the output format.
264 or High Efficiency Video Coding. 264 at roughly half the file size.
However, it requires more processing power to encode and decode. For 4K exports, High Efficiency Video Coding is strongly recommended to keep file sizes manageable.
The engine uses a constant framerate for all offline renders. Constant framerate ensures perfect synchronization when importing the video into non-linear editing software.
| Resolution | Frame Rate | Target Bitrate (H.264) | Estimated File Size (per min) | Typical Render Speed (M1) |
|---|---|---|---|---|
| 720p (1280x720) | 30 fps | 5 Mbps | 37 MB | 4x Real-time |
| 1080p (1920x1080) | 60 fps | 16 Mbps | 120 MB | 1.5x Real-time |
| 1440p (2560x1440) | 60 fps | 30 Mbps | 225 MB | 0.8x Real-time |
| 4K (3840x2160) | 30 fps | 45 Mbps | 337 MB | 0.5x Real-time |
| 4K (3840x2160) | 60 fps | 60 Mbps | 450 MB | 0.25x Real-time |
The render time depends heavily on your hardware and the complexity of the visual setup. The table above provides rough estimates based on a standard Apple Silicon M1 processor.
A render speed of 4x real-time means a one-minute performance takes 15 seconds to render. 25x means a one-minute performance takes four minutes to render.
Devices with more GPU cores, such as the M1 Max or M2 Pro, will render significantly faster. Older iPads will render slower.
During the render process, the application displays a progress bar. Because the rendering happens on a background thread, you can theoretically continue using the device for other tasks.
However, offline rendering consumes significant system resources. Running other demanding applications simultaneously will slow down the render process.
For maximum speed, leave the application in the foreground and avoid multitasking.
Frame Synchronization and Source Drift Handling
A critical challenge in offline rendering involves synchronizing external media sources. When you use video files as input sources within ImmerGround, the application plays those videos in real time during your performance.
The recording system captures events, not the video pixels. During the offline render, the engine must play those source videos back exactly as they played during the live performance.
It must ensure that a specific frame of the source video aligns perfectly with a specific frame of the final output video. Video playback systems naturally exhibit small timing variations.
Disk read speeds fluctuate. Video decoding hardware can stall for a millisecond.
In a real-time scenario, these tiny variations go unnoticed. The application simply displays the most recent available frame from the video source.
If the video decoder runs slightly behind, the application might display the same frame twice. If the decoder runs slightly ahead, the application might skip a frame.
This is a standard mechanism for maintaining overall timing in real-time applications. However, in an offline render, these timing variations cause catastrophic drift.
1 percent, the final output will be out of sync by six seconds. A visual trigger meant to align with a specific impact in the source video will fire completely off the mark.
To prevent this, the Render HD Engine implements a strict frame synchronization algorithm. When the offline render begins, the engine overrides the standard hardware-accelerated video playback mechanisms.
Instead of telling the video framework to play the file at standard speed, it takes manual control of the playback playhead. For every frame it renders, it calculates the exact absolute timestamp required for the source video.
It then commands the video framework to seek to that specific timestamp and extract exactly one frame. It waits for the video framework to return that specific frame before proceeding.
This process guarantees frame accuracy. It forces the source video to conform precisely to the timeline of the recorded event sequence.
The engine handles all the complex calculations required to map different framerates. If you load a 24 fps source video and render a 60 fps final output, the engine automatically calculates which source frames to duplicate and which frames to hold.
It performs this mapping mathematically, ensuring perfect consistency across multiple render passes. The system also manages audio drift.
The recorded uncompressed WAV file serves as the master clock for the entire offline render. The engine calculates the position of the render playhead based on the number of audio samples processed.
A 48 kHz audio file contains 48,000 samples per second. To render a frame at exactly one second, the engine ensures it has processed exactly 48,000 audio samples.
This tight coupling between audio samples and video frames eliminates audio-video desynchronization, a common issue in video rendering. This strict synchronization requires significant processing overhead.
Requesting individual frames from a video file out of sequence or at non-standard intervals is computationally expensive. Video compression relies on inter-frame dependencies.
To decode a single frame, the system often has to decode several preceding frames. This is why offline rendering takes longer than real-time playback.
The engine sacrifices speed to guarantee perfect synchronization. The result is a final video file where every visual effect, every parameter change, and every source video frame aligns flawlessly with the audio timeline.
Hardware Requirements for 4K Video Export
Rendering 4K video requires substantial hardware capabilities. The pixel count for a standard 4K frame (3840x2160) is exactly four times higher than a 1080p frame (1920x1080).
This quadruples the workload for the graphics processing unit, memory bandwidth, and the video encoding hardware. While ImmerGround allows 4K export on all supported devices, understanding the hardware requirements will optimize your workflow and prevent rendering failures.
The primary bottleneck for 4K rendering is the graphics processing unit. The engine executes complex fragment shaders on every pixel of the frame.
For a 4K frame, the GPU must process over eight million pixels. At 60 frames per second, that requires processing nearly 500 million pixels every second.
Apple Silicon devices handle this workload exceptionally well due to their unified memory architecture and robust integrated GPUs. An M1 chip with an 8-core GPU can render 4K video, but it will take considerable time.
Upgrading to an M1 Pro, M2 Max, or an M3 series chip drastically reduces render times by distributing the workload across more GPU cores. Memory bandwidth is the second critical factor.
The GPU must constantly read texture data, process the pixels, and write the frame buffer back to memory. Unified memory architecture provides extremely high bandwidth between the CPU and GPU.
Base model iPads and Macs with 8GB of unified memory can process 4K renders, but they may need to swap data to the solid-state drive during complex visual scenes with multiple video sources. This swapping slows down the render process.
Devices with 16GB or more unified memory keep all texture data and frame buffers in fast RAM, resulting in faster and more consistent render times. Thermal management plays a significant role in sustained rendering performance.
When a processor operates at maximum capacity for extended periods, it generates heat. If the device cannot dissipate this heat quickly enough, it engages thermal throttling.
It reduces the clock speed of the processor to prevent physical damage. This sudden drop in clock speed significantly increases render times.
Devices with active cooling systems, such as the MacBook Pro or Mac Studio, maintain peak performance throughout long 4K renders. Devices with passive cooling, such as the MacBook Air or iPad Pro, will eventually throttle during extensive rendering tasks.
To minimize throttling on passively cooled devices, render in a cool environment and remove any thick protective cases. Storage speed is essential for writing the final 4K video file.
264 at high quality can exceed 60 megabits per second. The internal solid-state drives on all Apple Silicon devices easily exceed this requirement.
However, if you are rendering directly to an external drive, ensure you use a high-speed connection. 0 or low-quality SD cards will create a bottleneck.
The video encoder will stall waiting for the storage drive to accept the data. 0, USB 4, or Thunderbolt drive for external rendering.
- Unified Memory Architecture allows the CPU and GPU to share the same physical memory pool, eliminating the need to copy large frame buffers between separate memory spaces.
- Apple Silicon Media Engines provide dedicated hardware for encoding H.264 and HEVC video streams, offloading this demanding task from the primary CPU and GPU cores.
- Active Cooling Systems utilize internal fans to dissipate heat, allowing the processor to maintain maximum clock speeds during long rendering sessions without thermal throttling.
- Solid State Drive Bandwidth dictates how quickly the system can write the massive data files generated by 4K video exports, preventing the encoder from stalling.
- GPU Core Count directly scales the rendering speed, as fragment shaders process pixels in parallel across available compute units.
If you encounter failed renders or application crashes during a 4K export, the most common culprit is memory exhaustion. Ensure you close all other memory-intensive applications before starting a 4K render.
If the problem persists, try rendering at 1440p or 1080p. 1440p provides a significant visual upgrade over 1080p while requiring significantly less memory and processing power than a full 4K render.
Content Creation Workflows for YouTube, Music Videos and Social Reels
The offline render engine generates final video files ready for distribution or further editing. Understanding how to integrate these files into your broader content creation workflow maximizes their utility. For a visualizer bound for YouTube, our guide to making a music visualizer for YouTube covers the upload settings and how Content ID treats the music.
The high-quality MP4 files exported by ImmerGround serve as excellent source material for non-linear editing applications like Final Cut Pro, Adobe Premiere Pro, or DaVinci Resolve. For music video production, the standard workflow involves rendering multiple passes of the same performance.
A director might record one pass using a highly reactive visual style focused on bass frequencies. They might record a second pass using a distinct color palette focused on mid-range frequencies.
Because the event sequence perfectly synchronizes to the master audio file, both rendered video files will align flawlessly on an editing timeline. The editor can then cut between the different visual styles, layer them using blend modes like Screen or Add, or use masks to isolate specific visual elements.
This multi-pass approach allows for complex visual compositions that would be impossible to achieve in a single real-time performance. When creating content for YouTube, 4K export provides a distinct advantage even if your source material is lower resolution.
YouTube uses higher bitrate compression profiles for 4K uploads compared to 1080p uploads. Uploading a 4K file forces the platform to assign more bandwidth to your video.
This results in a cleaner image with fewer compression artifacts, preserving the sharp edges and complex color gradients generated by ImmerGround. Always select the 4K 60 fps option for YouTube uploads if your hardware supports it.
Ensure your audio mix is finalized before importing the video into your editing software, as the rendered MP4 contains an uncompressed audio track suitable for final delivery. For social media platforms like Instagram Reels or TikTok, vertical video is mandatory.
ImmerGround supports native vertical rendering. Set your master output resolution to 9:16 before recording your performance.
When you export the video, select a 1080p or 4K resolution. The engine will render a native vertical video file.
Avoid rendering a horizontal video and cropping it in post-production. Cropping discards a massive amount of pixel data, resulting in a blurry, low-quality image.
Native vertical rendering utilizes the full resolution of the export format, delivering crisp, high-definition video perfectly formatted for mobile screens. If your workflow requires specific color grading in post-production, manage your visual setups carefully.
High-contrast visual styles with extreme saturation limit the flexibility of secondary color correction in an editing application. To retain maximum grading flexibility, aim for a balanced visual output with moderate contrast and saturation during the live performance.
You can always increase contrast and saturation later, but recovering detail lost to overexposure or extreme color clipping is impossible. Consider using a neutral color palette during the performance and relying on your editing software to apply the final creative look.
The constant framerate output of the Render HD Engine ensures smooth playback and precise editing capabilities. Variable framerate videos often cause audio synchronization issues or playback stutter in professional editing applications.
ImmerGround eliminates this problem by writing standard, constant framerate MP4 files. You can confidently drop the exported video onto any standard timeline, apply complex effects, and render your final project without encountering timing errors.
Where to get free visual tools
Building high-quality visual performances requires precise timing and testing. ImmerGround provides a suite of free web-based tools to help you prepare your audio and MIDI hardware before you start recording.
These tools run directly in your web browser, requiring no installation or plugins. The primary visualizer application is available directly at the Web Visualizer.
This lightweight version allows you to experiment with different visual styles, test audio reactivity using your computer microphone, and familiarize yourself with the interface before committing to a full download. It provides a great starting point for understanding how the core engine translates audio frequencies into visual geometry.
Accurate timing is crucial for synchronizing visual effects. Use the BPM Finder to determine the exact tempo of your audio tracks.
You tap a button along with the beat of the music, and the tool calculates the precise beats-per-minute. You can then enter this value into the ImmerGround master clock to synchronize LFOs, sequencers, and beat-driven visual effects.
Hardware controllers require proper configuration. The MIDI Tester allows you to connect any USB MIDI controller to your computer and verify that it sends the correct signals.
It displays the precise note values, continuous controller numbers, and velocity data transmitted by your hardware. This tool is essential for troubleshooting connection issues and ensuring your controller maps correctly to the visual parameters.
If you need high-quality audio material for testing and practice, access the free library of Audio Loops. These loops span various genres and tempos, providing clean, isolated drum beats, basslines, and synth melodies.
They are specifically designed to test the frequency response of the audio reactivity engine. Download these loops and import them into your session to experiment with different visual setups without needing to produce your own music first.
What to do next
To maximize the quality of your video exports and streamline your workflow, follow these structured steps.
- Configure your workspace: Connect your primary MIDI controller, route your audio interface inputs, and secure your hardware to prevent accidental disconnections during a performance.
- Establish a master snapshot: Dial in your starting visual state, set your color palettes, and map all hardware controllers. Save this state before you hit record.
- Execute a test recording: Record a short 30-second segment of your performance, pushing the visual limits and triggering multiple rapid changes.
- Review the quick preview: Stop the recording and immediately watch the MP4 file to verify that your hardware mappings trigger the correct visual responses and your audio levels do not clip.
- Perform the main take: Reset your master snapshot, initiate the recording sequence, and execute your full performance without worrying about real-time framerate drops.
- Initiate an offline render: Select your target resolution based on your distribution platform. Choose 4K 60 fps for YouTube, or 1080p 60 fps for standard social media.
- Monitor system resources: Ensure your device has adequate cooling and close memory-intensive applications while the Render HD Engine processes the final video file.
- Import and edit: Transfer the final MP4 file into your non-linear editing software, synchronize it with any secondary camera angles, and apply your final color grade.
