AI-Native WebGL Engine • 15,000+ GPU Particles @ 60 FPS • Deterministic Architecture
MetaCurtis is a high-performance WebGL engine built using a fully AI-native, deterministic development workflow. It renders 15,000+ GPU-accelerated particles at 60 FPS on integrated GPUs while driving a multi-stage narrative system (“Consciousness Theater”).
It is the flagship artifact showcasing my AI-Native Engineering Methodology, demonstrating how complex real-time systems can be built safely, predictably, and at 10–15× velocity using orchestrated AI workflows.
Live: https://metacurtis.com
(Add a GIF/screenshot here for visual impact.)
MetaCurtis is not “just another WebGL project.” It is the reference implementation of a new category:
AI-Native Engineering – a deterministic, pattern-driven way to build complex systems using AI as your development engine.
The entire engine — shaders, R3F orchestration, event bus, stage morphing, particle pipelines — was developed using:
- Claude as architect & diagnostician
- Kodex as implementer
- Evidence Intelligence System as deterministic context layer
Using my Kodex–Claude Protocol v3.0, the engineering process enforces:
- Single-writer rendering
- Contract enforcement
- Evidence-driven debugging
- No race conditions
- No architectural drift
- Reproducible context continuity
- 10–15× velocity over traditional engineering
- 15k–20k particles on integrated GPU
- 60 FPS target
- Shader-driven motion
- Tiered particle architecture
- Adaptive Quality System (AQS)
🔥 Modular, event-driven architecture
Features a multi-layer system:
ConsciousnessEngine (simulation brain)
TheaterDirector (orchestration & lifecycle)
BeatBus (deterministic event topology)
WebGLBackground (single-writer renderer)
Blueprint system for particle states
Stage- and phase-based narrative engine
🌌 Feature Overview 🟣 Particle Engine
15,000+ GPU-driven particles
Dynamic particle attributes
Randomized seeds with deterministic override
Chaos → Coalesce → Settle animation phases
Morphing between 3D constellations & text glyphs
🟢 Deterministic AI-Native Architecture
Pattern S: Single Writer Governance
Pattern D: Deterministic Directives
Pattern C: Contracts & Evidence
Pattern E: Eventguard Ordering
Zero competing writers
Zero mid-frame mutations
🔵 Stage System (“Consciousness Theater”)
Genesis → Discipline → Neural → Velocity → Architecture → Harmony → Transcendence
Each stage has:
Particle blueprint
Camera rig
Color profile
Animated narrative
Morph behaviors
🟠 Performance Systems
AQS: Adaptive Quality System
Tiers for fallback, mobile, integrated GPU
Framerate-aware behavior
Shader optimizations
Buffer reuse
Minimal allocations
🔴 Evidence Intelligence Layer
Full runtime system topology extraction
Event maps
Source-hit analysis
Configuration extraction
Automated “before/after” audit trails (Optional in public version)
🧩 Architecture Overview MetaCurtis Engine (v3.1) │ ├── ConsciousnessEngine.js │ ├── Stage definitions │ ├── Morph timelines │ ├── Chaos / Coalesce / Settle │ ├── TheaterDirector.js │ ├── Opening sequence │ ├── Stage lifecycle │ ├── Event sequencing (Eventguard) │ ├── BeatBus.js │ ├── Deterministic event bus │ ├── Emitters & listeners with schemas │ ├── Pattern C enforcement │ ├── WebGLBackground.jsx │ ├── Renderer (single-writer) │ ├── Buffer management │ ├── ShaderMaterial orchestration │ ├── shaders/ │ ├── particle.vert │ ├── particle.frag │ └── utils/ ├── Blueprint builders ├── Performance monitors ├── Random/DTRNG utilities
🔥 Key Architectural Guarantees
Renderer is the only writer to WebGL buffers
All updates occur through RENDER_DIRECTIVE and MORPH_PROGRESS
Stage changes follow a validated lifecycle sequence
AI-generated code is constrained by contracts
Blueprint system isolates particle math from UI and director logic
🛠️ Installation & Running Locally git clone https://github.com/metacurtis/metacurtis-v3.1 cd metacurtis-v3.1
npm install npm run dev
Opens at:
Requirements
Node 18+
Chrome or Edge recommended
Integrated GPUs supported
Mobile supported (AQS auto-detect)
📚 The AI-Native Methodology Behind MetaCurtis
MetaCurtis was not built through traditional engineering.
It was built using:
Kodex-Claude Development Protocol v3.0
An evidence-driven, multi-pattern AI workflow featuring:
Pattern A — Standard Feature Implementation
4–10× velocity
Pattern B — Diagnostic-Driven Debugging
5–15× velocity
Pattern C — Hybrid (Investigation + Diagnostic)
6–12× velocity
Pattern D — Evidence-Driven Debugging
8–20× velocity (no investigation phase)
These patterns were used to:
build the renderer
debug timing issues
fix morph phase drift
orchestrate opening sequences
enforce architecture invariants
eliminate race conditions
You can read the full protocol here: 👉 https://github.com/metacurtis/ai-native-engineering-patterns
🧪 Case Study: Opening Sequence Problem
AI-generated code created inconsistent timing between:
Chaos phase
Morph progress
Stage transitions
Renderer bind events
Particles would “stick” or misfire.
Solution
Using Pattern B + Pattern D:
Added diagnostic probes
Generated evidence reports
Traced event flow deterministically
Applied Eventguard constraints
Fixed fast-forward drift
Restored deterministic sequencing
Result
Opening sequence became:
glitch-free
deterministic
frame-accurate
fully synchronized
high FPS & stable
💼 Consulting: AI-Native Engineering Pilot
If you're using Copilot, Cursor, or Claude heavily and your team is seeing:
race conditions
unpredictable behavior
regressions
architecture drift
timing issues
nondeterministic rendering
async hell
performance degradation
I run a 4-week AI-Native Pilot where:
we fix one painful engineering problem
install deterministic patterns
restore architectural integrity
increase velocity 5×–15×
leave your team with repeatable workflows
Learn more: 👉 https://curtiswhorton.com
🧑💻 About Curtis (MetaCurtis Creator)
I’m an AI-Native Engineer combining:
deterministic systems architecture
high-performance WebGL
AI orchestration
multi-agent workflows
Marine Corps discipline
deep systems thinking
Creator of:
MetaCurtis Engine
AI-Native Engineering Patterns
Kodex-Claude Protocol v3.0
Consciousness Theater
I help engineering teams ship faster with fewer regressions by stabilizing AI-generated code.
LinkedIn: https://linkedin.com/in/curtisworton
GitHub: https://github.com/metacurtis
Website: https://curtiswhorton.com#