Demo Engine IDE

Native macOS Demoscene IDE & Real-Time VFX Production Platform

I designed and built Demo Engine IDE, a professional-grade, native macOS integrated development environment and real-time visual effects engine for creating high-performance demoscene productions, broadcast visuals, and live VJ performances. The platform unifies GPU shader programming, audio-reactive systems, timeline sequencing, and export pipelines into a single executable production workflow.

Demo Engine is not a renderer alone—it is a full creative runtime that bridges low-level graphics engineering with high-level creative tooling, enabling artists and engineers to author cinematic, synchronized visual experiences with deterministic performance characteristics.

Core Engine Architecture & System Design

The engine is built on a high-performance C++20 core with deep macOS integration, prioritizing GPU throughput, low-latency audio synchronization, and long-running production stability.

Rendering & Systems Foundation

• Native Apple Metal 3.0 backend optimized for Apple Silicon, with OpenGL 4.3 fallback for legacy hardware

• Hybrid C++20 / Objective-C architecture, bridging a low-level engine core with a native Cocoa UI

• Type-safe RAII resource management for shaders, buffers, and textures

• Multi-threaded render graph execution and background resource loading

• Shader binary caching delivering 50–80% faster cold start times

The rendering abstraction cleanly separates what is rendered from how it is rendered, allowing features like compute shaders, mesh shaders, and raymarching pipelines to evolve without destabilizing the editor or export path.

Audio-Reactive & Time-Synchronized Systems

A defining capability of Demo Engine is its microsecond-accurate synchronization between audio, visuals, and timeline execution. • Real-time FFT analysis and beat detection via AVFoundation • Smoothed frequency band extraction for stable visual modulation • BPM-locked scheduling for quantized scene changes and effect triggers • MIDI, OSC, and remote control bindings for live performance

This architecture ensures that visual events remain phase-locked to audio, even under high GPU load or long runtimes—critical for demoscene and broadcast contexts.

Creative Workflow & IDE Tooling

The IDE transforms raw shader code into structured, cinematic compositions through a set of visual authoring tools layered atop the engine runtime.

Visual Authoring Tools

• Node Graph Editor

Visual composition of render passes, post-processing chains, and effect graphs.

• Non-Linear Timeline

Keyframe-driven animation and sequencing of parameters, scenes, and transitions.

• Live Shader Coding

Hot-reloading Metal/GLSL shaders with immediate visual feedback.

• Project System (DEPP)

Declarative project format for assets, timelines, presets, and export settings.

These tools enable rapid iteration without sacrificing determinism or export fidelity.

Production-Grade Rendering & Effects Pipeline

Demo Engine includes a production-ready post-processing and effects system, designed for both live playback and offline export: • 24 GPU-accelerated post-FX (bloom, DOF, CRT, glitch, SSAO, motion blur, etc.) • 17 blend modes for compositing and transitions • Deferred rendering and GPU compute pipelines • Integrated particle system with force fields, constraints, and audio-reactive emission • SVG and typography system with SDF text rendering, variable fonts, and animation

Effects are composed declaratively and executed through a deterministic render graph to ensure predictable performance.

VJ, Broadcast & Output Capabilities

The engine supports live performance, broadcast pipelines, and offline production: • NDI streaming for network broadcast • Syphon I/O for macOS visual routing • 4K+ video export with H.264, H.265, ProRes 422/4444 • HDR export formats (OpenEXR, HDR, PFM) • Alpha-channel rendering for compositing pipelines

A Resolume-style VJ system provides clip grids, BPM sync, layer transitions, and live parameter control.

Reliability, Observability & Long-Running Stability

Demo Engine was designed for hours-long live operation, not short demos: • Crash recovery with state persistence • Health monitoring for frame time, GPU load, and memory pressure • Telemetry and diagnostics for performance regression detection • Remote REST and WebSocket APIs for automation and control • Extensive automated test suite (1700+ tests), including GPU integration tests

These safeguards ensure confidence in live and commercial environments.

Extensibility & Integration

The engine can be embedded or controlled externally: • C++ embedding API for native applications • Swift / SwiftUI integration via Metal views • REST, WebSocket, OSC, and MIDI control surfaces • IDE bridge APIs for external editor tooling

This allows Demo Engine to function as both a standalone IDE and a graphics subsystem inside larger systems.

Technical Summary

Core Stack

• C++20, Objective-C, Metal 3.0, OpenGL 4.3

• AVFoundation (audio), CoreAnimation, Cocoa

• Custom render graph, shader system, and composition engine

Domains Covered

• Real-time graphics & GPU programming

• Audio-reactive systems

• Native macOS application architecture

• Creative tooling & IDE design

• Broadcast, VJ, and demoscene production pipelines

Why This Project Matters

Demo Engine demonstrates the ability to: • Architect performance-critical creative software • Build native tools that fully leverage modern system APIs • Balance low-level engine engineering with high-level UX design • Deliver systems that are both artist-friendly and production-reliable

It sits at the intersection of graphics engineering, audio systems, tooling design, and creative technology, representing a rare blend of deep technical rigor and expressive software craftsmanship.