Website • Documentation • Discord • Sample Game (WebGPU)
About
Hyperion is a full-featured modular game engine built from the ground up in C++ and C#, with a focus on high-fidelity atmospheric environments and scalable worlds, without requiring high-end hardware.
It has been developed continuously since 2016, and is largely built around a custom reflection system that allows for serialization, editor integration, network replication, and scripting to be generated automatically from the same source code.
Why Hyperion?
- Dynamic GI without RT hardware. Glimmer, our GI system, uses a hybrid of voxel-based GI and software traced probes to provide dynamic global illumination without requiring ray tracing hardware.
- Reflection gives you functionality for free. Mark a class, struct, or field for reflection and our build tools will allow it to be used in serialization, editing, network replication, and script bindings.
- Multiplayer you can test in the editor. play-in-editor can run as a client, by starting a server others can connect to - or connect to another running server altogether
- Write the entire game in C# or C++ Use C# for scripting or write the entire game in it. Or generate a C++ project that links to Hyperion, then build and package it from the editor.
Screenshots

Glimmer - Emissives
|

Multiplayer, in play-in-editor mode
|
Features
Click a section header below to expand it:
Rendering
- Glimmer - As described above - a hybrid voxel-based + software ray traced probe GI system provides dynamic global illumination without requiring ray tracing hardware
- Clustered deferred shading supporting a large number of dynamic lights while maintaining good frame times, with forward clustered shading for translucent materials.
- Offline lightmapper integrated into the editor. Bakes lightmaps into the scene, reflection/irradiance probes supported for dynamic objects, fog volumes, and other static lighting data such as shadow maps.
- Real time reflections via ray tracing on RT capable hardware, with screen-space reflections everywhere else.
- Automatic instancing. Entities sharing a mesh, material, and LOD can be batched into instanced draw calls automatically
- Indirect draws, Hi-Z occlusion culling, bindless textures, mesh LODs
- Lights: directional, point, spot, and textured rectangular area lights. Shadow maps for static lights can cache static geometry shadows to improve performance.
- PBR materials with parallax mapping, transmission, emissives, and foliage shading.
- Post: TAA, GTAO, bloom, AgX / ACES / PBR Neutral tonemapping, color grading.
- GPU particles, simulated in compute with depth-buffer collision.
- Backends: DirectX 12 (the default on Windows), Vulkan (Linux, Android, macOS, iOS via MoltenVK), WebGPU.
- Shader compiler system with built in permutations support, and live reload in editor to see changes as you make them.
Gameplay & scripting
- Scene graph + ECS hybrid. Entities are nodes in a transform hierarchy and carry plain-data components (mesh, rigid body, character controller, animation, audio, script, UI, ...). Systems run over component sets in execution groups, in parallel where possible.
- Write it in C# or C++
- C# can be used either as a scripting language for gameplay code, or even as your entire game! Look at our CSharpGame sample to see how you can build a game with C#.
- You can generate a CMake project for your game that links to Hyperion by opening the editor and clicking Build > Generate C++ Project. From this menu, you can also build and package your game.
- Reflection and codegen. Tag a class, struct, or field and it gets serialization, an editor inspector, network replication, and C# + script bindings
- Extend the engine with your own components, systems, world subsystems,
Entity subclasses, or a Game subclass.
- Input: keyboard/mouse, touch with on-screen controls on mobile targets, gamepads via Steam Input. First-person, third-person, and follow camera controllers included.
Editor
- Runs on Windows and macOS, built with Avalonia.
- Play-in-editor, Standalone, as client, or against a dedicated server.
- World building tools: terrain sculpting and layer painting, ground cover painting, prefab instance painter, decal painter.
- CSG booleans (union/subtract/intersect), basic mesh edits, convex collision generation via V-HACD.
- Bake lightmaps, probes, static shadows, and fog volumes
World
- Terrain: streamed cells with geomorphic lod (CDLOD). Can be sculpted in the editor. Splat painting supported, as well as procedural splat generation based on the shape of the terrain. Collision is supported via Jolt heightfield shapes.
- Ground cover and grass: ground cover is automatically planted onto the terrain on load, can be painted as well.
- Level streaming: grid-based world layers streamed around streaming volumes on a dedicated thread
- Procedural atmosphere sky, volumetric clouds with cloud shadows, height fog, and baked fog volumes (baking draws static lights' scattering into a 3D texture)
Networking
- Server authoritative entity replication
- Component replication driven by reflection, entity ownership, and interest management
- Client-side prediction for character movement
- Dedicated server (
--server)
Physics
- Jolt backend. Static, dynamic, and kinematic bodies
- Convex decomposition (V-HACD) from the editor.
- Character controller support
Animation
- Skeletal animation with GPU skinning. Import from FBX, glTF
UI
- In-game UI is a custom retained-mode system, drawn by the engine's own renderer (the Avalonia-based editor is unrelated to this).
- Widgets: button, text, textbox, image, panel, grid, list view, tab view, menu bar, etc.
- TrueType/OpenType text via FreeType.
Audio
- 3D positional audio via OpenAL, with the listener following the active camera (note: this will soon be replaced with miniaudio + Steam Audio)
Assets
- Import: FBX, glTF/GLB, OBJ, OgreXML models
- PNG, JPG, TGA, BMP, PSD, HDR, TIF, GIF textures via STB image
- WAV audio
- TTF/OTF fonts
- UUID-based asset registry with redirects, so renaming and moving assets doesn't break references.
- Async batch loading, with memory-mapped blob storage paged in on demand.
- Content cooking, plus a cache server so a team (or your devices) can pull cooked content over HTTP instead of cooking locally.
- Automatic mesh LOD generation, using meshoptimizer.
- Automatic convex decomposition for physics collision meshes, using V-HACD
Platforms
Currently, we are focusing our efforts on developing the engine for Windows, Linux, macOS, Android, iOS, Web (WebAssembly + WebGPU), and Steam Deck (via Proton). The editor is supported on all desktop platforms. (Windows, Linux, macOS)
Getting started
Clone with --recursive to pull in submodules, then run build.bat Release on Windows or ./build.sh Release on macOS. You'll need CMake and the .NET 10 SDK, plus vcpkg (VCPKG_ROOT set) on Windows or the Vulkan SDK on macOS and Android. See Compiling the Engine for the full list and per-platform notes.
Documentation is a WIP but we have some available on our site: Documentation
For any questions you have, please feel free to ask away in Discord.
AI
AI can be a useful tool, but intention is important when building something super complex like a game engine. We aim to keep the usage of AI-generated code limited to bug fixes, UI changes, and occasionally, prototyping / boilerplate. In an effort to maintain transparency, we aim to note where AI is used generally as part of a commit message, comment on the commit on GitHub, or on the PR; although this is on a best effort basis.
We expect contributors to be honest and upfront about the usage of AI generated code and while AI-generated code isn’t de facto unacceptable, the code must pass the same quality bar that human generated code would.
Credits
Full list and licenses in THIRD_PARTY_NOTICES.md.