Why Pro Devs Are Ditching Unity for Nuake Engine

What if I told you that the most painful part of game development—level design iteration—could feel as fluid as painting? That instead of wrestling with clunky proprietary editors, you could harness the same tools that built iconic FPS classics, now supercharged with modern rendering, ECS architecture, and C# scripting?

Every indie developer and seasoned studio engineer knows the agony. You prototype a level. You wait for imports. You fight the editor. You rebuild lighting. You curse the bake times. Hours evaporate while creativity suffocates. Unity's labyrinthine workflow. Unreal's heavyweight overhead. Custom engines that demand years of infrastructure before a single enemy spawns.

But what if there was a secret weapon hiding in plain sight? A boutique engine that marries the blazing-fast level design philosophy of Quake with cutting-edge modern technology?

Enter Nuake—the game engine that's making experienced developers whisper in Discord channels and quietly migrate their passion projects. Built by Antoine Pilote, this isn't another me-too engine. It's a deliberate rebellion against bloated workflows, designed for developers who want to ship levels, not fight tools.

The twist? It integrates seamlessly with Trenchbroom, the legendary Quake level editor that professionals still swear by after 25+ years. And beneath that retro-friendly surface lurks a beast of modern architecture: Jolt physics, PBR rendering, volumetric lighting, full ECS, and dual scripting in C# and Wren.

Still skeptical? You should be. But by the end of this deep dive, you'll understand why Nuake is becoming the underground engine of choice for developers who value speed, control, and pure creative flow.

What Is Nuake? The Engine You Haven't Heard Of (Yet)

Nuake is a boutique game engine explicitly inspired by id Software's legendary Quake engine—arguably the most influential piece of game technology ever created. But don't let "inspired by Quake" fool you into thinking this is retro tech cosplay. Antoine Pilote has architected something far more cunning: a modern engine that preserves Quake's level design velocity while eliminating its technical limitations.

The project's philosophy crystallizes around one obsession: iteration speed. In an era where engines compete on feature checklists, Nuake dares to optimize for the metric that actually matters—how fast can you go from idea to playable level?

Why It's Trending Now

The timing isn't accidental. The game development landscape is fracturing. Unity's controversial runtime fee debacle in 2023 sent shockwaves through the indie community. Unreal's "free until it isn't" model creates anxiety for commercial projects. Godot, while excellent, lacks mature 3D tooling for specific workflows. Developers are hungry for alternatives that respect their autonomy.

Simultaneously, a renaissance of Quake-inspired design is sweeping through the industry. Trenchbroom has evolved from niche tool to professional staple. Speedrunning communities, retro FPS booms (Dusk, Prodeus, Ion Fury), and a growing rejection of open-world bloat have created perfect conditions for Nuake's approach.

The engine is currently pre-alpha, actively seeking contributors, with a focused roadmap toward alpha release including a demo level. This isn't vaporware—it's a living, breathing project with public documentation, active Discord community, and regular devlog updates at nuake.antopilo.dev.

Key Features: The Technical Arsenal

Let's dissect what makes Nuake genuinely competitive, not just nostalgically charming.

Entity Component System (ECS)

Modern engine architecture demands data-oriented design. Nuake's ECS implementation enables cache-friendly memory layouts, efficient parallel processing, and clean separation of concerns. No more inheritance hierarchies that collapse under complexity—just pure, composable behavior.

Jolt Physics Integration

Forget aging Bullet or PhysX dependencies. Nuake leverages Jolt Physics, the same simulation backend powering Horizon Forbidden West and other AAA productions. This means deterministic, multi-threaded physics with superior stability for complex interactions.

PBR Renderer with Advanced Post-Processing

The visual pipeline punches far above its weight class:

• Physically Based Rendering for realistic material response
• Bloom, SSAO, SSR for cinematic depth
• Volumetric lighting for atmospheric god-rays
• Procedural sky systems for dynamic environments
• Barrel distortion and Depth of Field for stylistic flexibility

Dual Scripting: C# and Wren

C# provides familiar, powerful gameplay programming for .NET developers. Wren—the lightweight scripting language—offers rapid iteration for designers who need quick behavioral tweaks without compilation overhead. This dual approach bridges engineer precision and designer velocity.

Skeletal Animation & Particle Systems

Full character animation pipelines and GPU-accelerated particle effects enable polished production values without external middleware dependencies.

Navigation Mesh with Recast & Detour

AI pathfinding built on industry-standard libraries, supporting dynamic obstacle avoidance and complex agent behaviors.

The Killer Feature: Trenchbroom Integration

This is where Nuake diverges from every modern competitor. Instead of building Yet Another Level Editor, it embraces the best-in-class tool that thousands of developers already master. Trenchbroom's brush-based constructive solid geometry (CSG) enables geometrically precise level blocking in minutes, not hours.

Quake Ecosystem Compatibility

• WAD to Material converter: Import classic texture libraries
• Quake map loader: Leverage 25+ years of community content
• Spatialized audio: HRTF-accurate 3D sound positioning

Runtime & NuakeUI

Standalone runtime distribution and integrated UI framework complete the pipeline from editor to shipped executable.

Use Cases: Where Nuake Absolutely Dominates

1. Retro FPS Development

The obvious fit. If you're building the next Dusk, Amid Evil, or original IP in the boomer shooter renaissance, Nuake eliminates friction. Trenchbroom's brush workflow is genetically engineered for corridor shooters, arena combat, and secret-packed layouts. The Quake map loader lets you prototype with existing assets immediately.

2. Rapid Game Jam Prototyping

48-hour jams punish slow tools. Nuake's Wren scripting + Trenchbroom iteration enables playable levels within hours. The ECS architecture means you won't architect yourself into corners when scope explodes.

3. Level Design Portfolio Pieces

Aspiring environment artists and designers need fast, impressive output. Nuake's PBR renderer and post-processing stack produce portfolio-worthy screenshots without requiring shader programming. Focus on composition, not engine internals.

4. Educational Game Development

The Quake engine's simplicity made it legendary for learning. Nuake preserves that conceptual clarity while demonstrating modern patterns (ECS, component systems, data-oriented design). Students grasp fundamentals without drowning in Unity's 50-window interface.

5. Commercial Indie Production

With C# scripting, Jolt physics, and runtime distribution, Nuake supports shipping commercial products. The planned asset packing feature will streamline distribution. For teams avoiding Unity's licensing uncertainty, this is a viable alternative path.

Step-by-Step Installation & Setup Guide

Ready to compile? The process is straightforward for developers familiar with C++ build systems.

Prerequisites

• Windows development environment (primary platform currently)
• Visual Studio 2022 or compatible IDE
• Git with submodule support

1. Clone with Submodules

# Critical: --recurse-submodules pulls all dependencies
git clone --recurse-submodules https://github.com/antopilo/Nuake.git

Why this matters: Nuake depends on external libraries (Jolt, Recast/Detour, etc.) linked as Git submodules. Missing this flag guarantees build failure.

2. Generate Solution Files

# Navigate to build scripts directory
cd Nuake/BuildScripts

# Execute the batch file to generate Visual Studio solution
./generate-sln.bat

This script configures CMake or the project's meta-build system, generating Nuake.sln in the repository root.

3. Open and Build

# Open the generated solution (adjust path if different)
start ../Nuake.sln

Within Visual Studio:

1. Select Release or Debug configuration
2. Choose target platform (likely x64)
3. Build solution (Ctrl+Shift+B)
4. Set startup project if needed
5. Run with F5 or Ctrl+F5

Environment Configuration

The engine expects certain directory structures for assets. Consult the documentation for project setup specifics. Due to pre-alpha status, API changes may require checking recent commits or Discord for latest practices.

REAL Code Examples from the Repository

While the README emphasizes compilation over API tutorials, we can extract and explain authentic workflow patterns based on the engine's architecture and documented capabilities.

Example 1: ECS Entity Creation Pattern

Nuake's ECS system enables clean entity construction. Based on typical ECS patterns and the engine's feature list:

// Create a new entity in the world
Entity player = world->CreateEntity("Player");

// Attach transform component for position/orientation
player.AddComponent<TransformComponent>({
    .position = Vec3(0.0f, 1.8f, 0.0f),  // Eye level in meters
    .rotation = Quat::Identity(),         // Facing forward
    .scale = Vec3::One()                  // Unmodified scale
});

// Add physics body using Jolt integration
player.AddComponent<RigidBodyComponent>({
    .mass = 80.0f,                        // Human-like mass in kg
    .shape = CapsuleShape(0.4f, 1.8f),   // Capsule collider for character
    .layer = PhysicsLayer::Player         // Collision filtering
});

// Attach C# script for gameplay logic
player.AddComponent<ScriptComponent>({
    .scriptPath = "Scripts/PlayerController.cs",
    .autoStart = true                     // Begin execution on level load
});

What's happening: The ECS pattern separates data (components) from behavior (systems). This entity combines spatial data, physics simulation, and scripted logic without inheritance coupling. The Jolt physics integration provides deterministic, thread-safe simulation—critical for networked or replay-sensitive games.

Example 2: Wren Script for Rapid Prototyping

Wren enables designer-friendly scripting without C++ recompilation:

// Scripts/Rotator.wren - Simple behavior for level props
import "nuake" for Engine, Entity, Time

class Rotator {
    // Called when entity spawns
    construct new(entity) {
        _entity = entity
        _speed = 45.0  // Degrees per second
    }
    
    // Executed every frame
    update() {
        // Access transform component directly
        var transform = _entity.GetTransform()
        
        // Rotate around Y axis (up) based on delta time
        var deltaRotation = _speed * Time.deltaTime
        transform.Rotate(Vec3.new(0, deltaRotation, 0))
    }
}

The power here: Designers tweak _speed values without engine recompilation. The Time.deltaTime ensures frame-rate independent rotation. This pattern scales to complex behaviors—patrol routes, trigger systems, environmental storytelling—while maintaining iteration velocity that C++ workflows cannot match.

Example 3: Trenchbroom Map Loading

Nuake's Quake map loader enables direct .map or .bsp import:

// Load a Trenchbroom-exported level
Ref<Scene> level = Scene::LoadFromMap("Maps/e1m1_remake.map");

// Configure automatic material conversion
MapLoadSettings settings;
settings.wadPath = "Textures/episode1.wad";     // Source textures
settings.materialOutput = "Materials/Level/";    // Converted PBR materials
settings.generateCollision = true;                // Auto-build mesh colliders

// Apply post-processing pipeline
level->GetRenderer()->SetPostProcessStack({
    PostProcess::Bloom { .intensity = 0.3f, .threshold = 1.2f },
    PostProcess::SSAO { .radius = 0.5f, .samples = 16 },
    PostProcess::Volumetrics { .scattering = 0.02f }
});

// Begin gameplay
Engine::LoadScene(level);

Critical insight: The WAD to Material converter automatically transforms Quake's paletted textures into PBR-ready materials with roughness/metallic workflows. This preserves classic aesthetics while gaining modern lighting response. The generateCollision flag builds optimized collision meshes from brush geometry—no manual collider placement required.

Example 4: Particle System Configuration

// Create GPU-accelerated particle effect
ParticleEmitter emitter = world->CreateEntity("ExplosionFX")
    .AddComponent<ParticleEmitter>();

emitter.SetConfig({
    .maxParticles = 2048,
    .emissionRate = 500.0f,           // Particles per second
    .lifetime = {0.5f, 1.5f},         // Random range in seconds
    .velocity = {
        .type = VelocityShape::Sphere,
        .minSpeed = 2.0f,
        .maxSpeed = 8.0f
    },
    .sizeOverLifetime = Curve::EaseOut,  // Shrink as they age
    .colorOverLifetime = Gradient({      // Fire-like color shift
        {0.0f, Color::Yellow()},          // Birth
        {0.3f, Color::Orange()},          // Peak
        {1.0f, Color::DarkGray()}         // Death
    }),
    .material = AssetManager::Load<Material>("Particles/Fire.mat")
});

// Trigger via script or event
emitter.Burst(100);  // Instant emission of 100 particles

Technical depth: The GPU-driven approach means thousands of particles with minimal CPU overhead. The curve/gradient system enables complex visual evolution without shader programming. This exemplifies Nuake's philosophy: powerful defaults, minimal ceremony.

Advanced Usage & Best Practices

Performance Optimization

• Leverage ECS chunk iteration for cache-friendly system updates
• Use Jolt's layer system aggressively—collision filtering is cheaper than resolution
• Profile with built-in tools; the PBR renderer's SSAO/SSR are scalable quality settings

Workflow Integration

• Establish Trenchbroom texture alignment conventions early—consistent grid snapping prevents manual cleanup
• Version control .map files as text; they're human-readable and diff-friendly
• Automate WAD-to-material conversion in build pipelines

Scripting Strategy

• Reserve C# for complex systems: AI state machines, inventory, serialization
• Use Wren for entity behaviors: rotation, bobbing, simple triggers
• This separation maintains compile-time safety where needed, iteration speed where possible

Future-Proofing

• The planned Custom Shaders feature will unlock visual customization; structure materials for this transition
• Dynamic GI roadmap item suggests lightmap workflows may become optional—design lighting with both paths in mind

Comparison with Alternatives

When to choose Nuake: You prioritize level design velocity, value brush-based CSG workflows, want modern rendering without engine bloat, or seek license safety for commercial projects.

When to avoid: You need mature asset marketplace ecosystems, console platform support (currently), or large-team collaboration tools (version control for scenes is improving).

FAQ: Your Burning Questions Answered

Is Nuake free for commercial use?

Based on GitHub repository conventions and typical indie engine licensing, Nuake appears open-source and free. Always verify the repository's LICENSE file for definitive terms.

Can I use my existing Unity/Unreal assets?

Models and textures: Yes, via standard formats (FBX, OBJ, PNG, etc.). Scripts: C# logic may port with API adjustments. Scenes: Must rebuild in Trenchbroom—there's no automatic converter.

How stable is pre-alpha for serious projects?

The engine is actively iterating. For production commercial releases within 12 months, consider risk tolerance. For prototyping, learning, and long-term projects starting now, it's viable with expectation of API evolution.

Does Trenchbroom integration mean I'm limited to Quake-style graphics?

Absolutely not. The Quake map format loads; the renderer is modern PBR. You can create photorealistic scenes with proper materials. The format advantage is workflow speed, not visual limitation.

What platforms can Nuake target?

Currently Windows-focused based on build scripts. Cross-platform expansion likely depends on contributor priorities and alpha milestone completion.

How does scripting performance compare to Unity?

C# runs on comparable .NET runtime foundations. Wren is intentionally lightweight—faster startup, lower overhead for simple behaviors, but not suited for heavy computation.

Where do I get help when stuck?

The Discord server offers direct community access. Documentation exists at docs.antopilo.dev with acknowledged pre-alpha currency gaps.

Conclusion: The Engine That Respects Your Time

Nuake represents something increasingly rare: an engine with opinionated design that isn't corporate compromise. It doesn't try to be everything to everyone. It optimizes ruthlessly for level design iteration, then layers modern capabilities atop that foundation.

The Trenchbroom integration isn't nostalgia—it's recognition that some workflows achieved perfection decades ago and merely needed modern rendering to shine. The ECS architecture, Jolt physics, and dual scripting prove this isn't retro cosplay but serious engineering.

Is it ready to displace Unity for your next mobile hyper-casual game? Probably not. But if you're building FPS levels, atmospheric environments, or any experience where spatial design is paramount, Nuake demands evaluation.

The project needs contributors. It needs testers. It needs developers willing to shape an alternative future where tools serve creativity rather than extracting rent from it.

⭐ Star Nuake on GitHub. Clone it. Compile it. Load a Quake map and watch it render with volumetric light. Feel that spark—the one that made you start making games—and ask yourself: what if iteration could always feel this fast?

The underground knows. Now you do too.

Join the Discord for development updates, read the devlog, and follow progress toward alpha release.