TempestEngine is a custom C/C++ game engine I've been developing since 2015. Its early development was influenced by Casey Muratori's Handmade Hero, but the engine has since evolved independently. Today, it includes a Vulkan rendering backend, scene editor, physics, animation, asset pipeline, and integrated development tools.

Over eleven years of development, the engine has grown to include GPU-driven rendering, ray tracing, global illumination, adaptive terrain, data-oriented runtime systems and integrated profiling tools. The project focuses on the implementation and architecture of real-time software.

Tempest Engine rendering

Technology

Languages and Toolchain

CC++20GLSLHLSLSlangSDL3CMake

Rendering

VulkanDeferred RenderingPhysically Based RenderingBindless ResourcesGPU CullingRay TracingPath TracingGlobal IlluminationRTXGI DDGITRCGIHDRImage-Based LightingTemporal Anti-AliasingDynamic Rendering

Runtime

Data-Oriented DesignSparse Entity SystemCustom RHIArena AllocationMultithreadingHot ReloadAsset SerializationMemory ProfilingCPU ProfilingGPU Profiling

World and Simulation

Adaptive TerrainConcurrent Binary TreesLarge WorldsProcedural GeometryJolt PhysicsRigid Body DynamicsSkeletal AnimationAnimation BlendingSpatial Queries

Editor and Assets

Scene EditorPrefabsAsset PipelineMaterial EditorShader Hot ReloadTexture CompressionMesh ImportDebug Visualization

Engineering

Engine Architecture

TempestEngine is a native game engine written primarily in C with selective use of C++20. Its runtime, rendering backend, entity representation, memory systems and development tools are implemented as part of the engine.

The architecture emphasizes explicit data representation, memory ownership, cache locality and predictable execution. Engine systems are designed around the data they process rather than extensive inheritance hierarchies.

  • Custom sparse entity representation with component data and hierarchical relationships.
  • Arena-based memory management, temporary memory and explicit allocation lifetimes.
  • Separation between the platform layer, engine runtime and application code.
  • Task-based parallel execution and multithreaded engine workloads.
  • Runtime code reloading and incremental development workflows.
  • Scene serialization, asset persistence and resource caching.
  • Custom rendering hardware interface and GPU resource management.

Vulkan

The graphics backend is implemented using Vulkan. The engine manages GPU resources, command recording, synchronization, descriptor allocation, presentation and rendering workloads.

Rendering combines physically based materials, deferred shading, compute processing and GPU-driven techniques. The renderer exposes low-level control over the graphics pipeline while retaining the resource and pass organization required by a complete game engine.

  • Vulkan graphics and compute pipelines with explicit command submission.
  • Deferred rendering using G-buffer attachments and physically based lighting.
  • Bindless resources using descriptor indexing and runtime descriptor arrays.
  • GPU-driven rendering, visibility processing and occlusion culling.
  • Dynamic rendering and synchronization using modern Vulkan facilities.
  • Physically based metallic-roughness materials and environment reflections.
  • High-dynamic-range rendering, automatic exposure and tone mapping.
  • Temporal anti-aliasing, motion vectors and FXAA.
  • GPU profiling and diagnostics for rendering passes and resource usage.
VulkanVulkanVulkanVulkanVulkan

Lighting and Global Illumination

TempestEngine includes multiple lighting and indirect illumination systems. The rendering architecture supports direct illumination, environment lighting, ray tracing and techniques for reconstructing or approximating indirect radiance.

Global illumination development includes TRCGI and NVIDIA RTXGI DDGI integration. These systems operate alongside the deferred rendering pipeline and its temporal reconstruction and debugging facilities.

  • Physically based direct lighting and shadow rendering.
  • Image-based lighting and prefiltered environment reflections.
  • TRCGI indirect diffuse illumination and radiance processing.
  • RTXGI DDGI probe volumes and irradiance sampling.
  • Probe relocation, classification and temporal accumulation.
  • Hardware ray tracing through Vulkan acceleration structures.
  • Ray queries and ray tracing pipelines.
  • Path tracing and progressive sample accumulation.
  • Temporal filtering, radiance history and intermediate buffer inspection.
  • Decal rendering, including DBuffer materials.
Lighting and Global Illumination

Terrain Rendering

The terrain renderer includes adaptive triangulation, level-of-detail management, material blending and GPU-based terrain processing.

Concurrent Binary Trees provide a compact representation for adaptive terrain subdivision. The implementation builds on earlier geometry clipmap research and supports terrain rendering at different spatial scales.

  • Concurrent Binary Tree representation for adaptive triangulation.
  • Level-of-detail selection and geometry subdivision.
  • GPU-based terrain geometry processing.
  • Heightfield sampling and reconstructed surface normals.
  • Splat mapping and multi-material terrain surfaces.
  • Height-based material blending and slope classification.
  • Triplanar texture projection and material detail mapping.
  • Large-world terrain representation and spatial partitioning.
  • Runtime geometry modification and terrain data updates.

Scene Editor and Asset System

The editor is integrated with the engine runtime and provides direct access to scene data, entity properties, rendering parameters and asset resources.

The asset system manages imported resources and serialized data. Tools for meshes, textures, materials and shaders are part of the engine development environment.

  • Scene composition, entity hierarchies and component editing.
  • Reusable prefabs and serialized scene representation.
  • AssetVault resource storage and asset management.
  • Mesh import and resource conversion.
  • Texture processing and compression.
  • Material editing and shader configuration.
  • Material graph development and MaterialX support.
  • Runtime inspection of rendering and environment parameters.
  • Asset hot reload and persistent editor settings.
Scene Editor and Asset System

Physics and Animation

TempestEngine integrates Jolt Physics with the native runtime. Physics objects, collision queries and simulation data are accessible to engine and application systems.

The animation runtime includes skeletal animation and skinned meshes, with facilities for blending animation data and managing animated entities.

  • Jolt rigid-body dynamics and collision detection.
  • Broad-phase and narrow-phase collision processing.
  • Raycasting and shape-based spatial queries.
  • Physics components and simulation state management.
  • Skeletal animation and hierarchical transforms.
  • GPU skinning and animated mesh rendering.
  • Animation blending and runtime pose evaluation.
  • Animation retargeting and skeleton integration.
Physics and Animation

Development Tools

The engine includes native development utilities for compiling shaders, inspecting runtime state, profiling performance and debugging rendering and simulation systems.

The toolchain is organized around iteration on engine code, shaders and assets while retaining direct access to the runtime and graphics backend.

  • GLSL, HLSL and Slang shader compilation.
  • Development-time shader and asset reloading.
  • CPU execution profiling and timing instrumentation.
  • GPU timestamp profiling and rendering pass analysis.
  • Memory allocation and resource diagnostics.
  • Vulkan validation and device fault diagnostics.
  • Graphics debugging and intermediate rendering visualizations.
  • Vulkan pipeline caching and cache validation.
  • CMake-based native build configuration.
Development Tools

Technical Writing