SpartanEngine

• ReSTIR path tracing with spatiotemporal reservoir resampling for real-time multi-bounce global illumination
• Clustered deferred shading with a GPU-built logarithmic-Z grid and cone-vs-AABB culling for spots, so many local lights cost near-constant time per pixel
• IES photometric light profiles (LM-63): spot lights emit the measured beam of a real fixture, from car headlights with regulation cut-offs to architectural downlights, with correct lumens and candela across direct lighting, volumetric fog and path tracing. A feature usually reserved for the big commercial engines
• Hardware ray-traced reflections and shadows via ray queries
• Atmospheric scattering and image-based lighting with bent normals
• Volumetric clouds (Nubis-style) baked into the sky panorama, with cumulus and cirrus layers, multi-scatter lighting and aerial perspective
• Froxel volumetric fog: one view-aligned volume for height and distance fog, sun shafts and underwater caustic shafts, with temporal reprojection and shadowing
• FFT ocean with a Tessendorf spectrum and multi-cascade IFFT in compute, driving a camera-following clipmap with choppy displacement, dynamic normals and crest foam
• Screen-space shadows (inspired by Days Gone) and XeGTAO ambient occlusion
• Shadow map atlas with fast filtering and penumbra estimation

Geometry, materials, textures, lights, transforms and bounds live in persistent, globally accessible buffers. No per-draw descriptor updates, no per-draw resource binding, no CPU-side draw loops.

• Zero-binding draw path: all per-draw data lives in a single bindless storage buffer, push constants carry only an index
• Single global vertex and index buffer for all geometry (inspired by id Tech), with vertex pulling that bypasses the Input Assembler and is shared by rasterization and ray tracing
• GPU-driven indirect rendering with per-meshlet frustum, Hi-Z occlusion and backface cone culling; the CPU issues a single DrawIndexedIndirectCount per pass
• Meshlet clustering via meshoptimizer, with mesh shaders when available and a vertex-pulling fallback
• Bindless everything: materials, lights, samplers, uber shaders, minimal PSO permutations
• Universal HLSL compiled for Vulkan (SPIR-V), DirectX 12, Metal (Metal Shader Converter) and WebGPU (SPIR-V to WGSL through Tint)
• GPU-side asset processing: mip generation (FidelityFX SPD) and texture compression (Compressonator) at load time, not baked offline
• Unified deferred rendering: opaque and transparent surfaces share the same BSDF and render path
• Async compute for SSAO and screen-space shadows, in parallel with shadow rasterization

• NVIDIA DLSS 4.5 Super Resolution (SDK 310.9.1) and Intel XeSS 2.0.2 (SDK 3.0.2)
• AMD FSR upscaling (FSR SDK 2.4.0) on Windows with Vulkan and D3D12. Select AMD FSR in Renderer Options (or r.antialiasing_upsampling 5). The SDK selects FSR 4.1.2 on supported Radeon GPUs and FSR 3.1 on other supported GPUs. Run dependency setup to fetch the signed loader and upscaler DLLs. Frame generation retains its existing, separate SDK.
• AMD FSR 3.1 frame generation (FidelityFX SDK 1.1.4) on Vulkan and D3D12, works on any vendor’s GPU, with frame-generation-aware fps, latency and frame rate limiting
• TAAU: temporal anti-aliasing with built-in upsampling, Halton jitter and variance-clipped history
• Variable rate shading and dynamic resolution scaling
• Foliage impostors as the final GPU LOD, so dense forests stay cheap at distance
• Texture streaming within a fixed memory budget
• Custom GPU breadcrumbs for crash tracing and post-mortem debugging
• Physically based camera with auto-exposure and physical light units (lux, lumens and kelvin)
• Tonemappers: ACES, AgX and Gran Turismo 7 (default), with HDR10 output
• Post-processing: bloom, motion blur, depth of field, chromatic aberration, film grain and sharpening (CAS)

A full vehicle dynamics model running inside the PhysX fixed-timestep loop. Not a gameplay approximation: racing-sim fidelity inside a general-purpose engine.

The binaries/ folder keeps executables at the top level. Windows vendor DLLs live in third_party/ (Direct3D Agility components in third_party/d3d12/), compiler intermediates and Windows symbols in build/, preferences in settings/, diagnostics in logs/, and engine-wide generated data in cache/. Existing preferences, logs, and engine caches migrate on first launch without replacing files already at the new locations. World-specific bake caches remain alongside their world resources. data/, project/, and crashes/ retain their existing roles. steam_appid.txt stays beside the executable for local Steam development. Ship the vendor folder with the executable; game exports and Windows release archives preserve its structure. Python bytecode caches are excluded from game exports.

Project generation creates one target, spartan, built for the selected graphics backend in three configurations:

The same executable is the editor and the game: -game hides the editor panels, and a game.xml written by Build Game next to the executable turns it into a packaged game that plays its start world directly. The full list of command-line arguments is in Getting started.

With dependencies already installed, regenerate without downloading them:

tools/premake5.exe --file=tools/premake.lua --skip-setup vs2026 vulkan

# macOS
tools/premake5 --file=tools/premake.lua --skip-setup xcode4 metal

Engine and world boundary. There is no game layer in C++. source/world/WorldSystems.cpp installs the world lifecycle hooks: camera controls, vehicle render submissions, breakable trees and the optional world systems (ambient wildlife, ambient atmosphere, road details, layered road surfaces). Vehicle physics and state live under source/car, vehicle MCP commands in source/mcp/McpCommandsCar.cpp, and traffic, race drivers, route drivers, car resets and skid marks are regular components in source/world/components. The optional world systems are off by default; a world turns them on through the WorldSystems Lua table from its companion script, the .lua with the same name next to the .world (worlds/plan.lua for plan.world), which runs on every load before the roads are built. Worker model imports publish their entity hierarchy through World::EntityBatch::Commit() after construction succeeds.

Physics. Scene stepping and contact observation use game-independent callbacks; the game installs vehicle contact handling. Vehicle state is opaque to engine consumers, while the existing Physics authoring and Lua API remains compatible.

Asset ownership. World saves record native asset ownership in OwnedResources. Automatic cleanup only removes unreferenced files recorded there; unlisted files, shared libraries, sculpt data and generated caches keep their separate lifetimes. Legacy worlds acquire ownership of referenced assets when saved and do not prune unrelated legacy files.

Component attributes. Attributes exposed for editing go through the component’s setters. Raw copy-only or derived fields are read-only; use the named authoring properties for edits.

Play lifecycle. Play startup captures all authored transforms before any component starts, with both phases spread across frames. Stopping play drains completed worker batches before restoration and removal. World unload cancels staged work and clears renderer scene references and temporal history while preserving device lookup tables.

Use, modify, and redistribute the engine, including reusing its code in other projects. Keep the copyright notice identifying Panos Karabelas and the license with redistributed code; compiled distributions must carry them in documentation or accessible legal notices. No splash screen or logo is required.

Each product keeps the terms of the license version it first shipped under, for its lifetime. One-time buyouts are available on request. Third-party components retain their own licenses, and copies previously released under MIT retain their existing permissions.

See license.md for the complete terms and the license FAQ for plain-language answers.