Custom-built
Scriptable, inspectable project data and clear engine APIs—iterate and profile your game without a black-box toolchain between you and Vulkan.
By Olympus Game Studios
Hephaestus Engine
A lean, understandable foundation for 3D games and tools, where performance, clarity, and flexibility come first.
Hephaestus combines a modern C++20 core, a Vulkan renderer, and a data-oriented scene model to support both sides of game development: programmers get direct control of systems, while designers can build and iterate content through professional-grade tools.
Proprietary engine · Free for solo developers, indies, and small studios
Built for creators who want control
Hephaestus is built with a dual focus: deep technical control for programmers, and intuitive creation workflows for level designers, UI/UX designers, artists, and technical creatives. Not everyone on a game team is a gameplay programmer, and the engine is designed around that reality.
Performance-minded
Vulkan and a focused runtime path keep the graphics stack explicit and controllable.
Flexible workflows
Scenes, materials, meshes, and UI lean on readable asset formats and scripting where it helps.
Free for solo, indie & small studios
Hephaestus is offered at no cost for individual developers, independent teams, and small studios, so you can ship serious work without licensing friction, while the engine remains a proprietary product with a clear roadmap.
What you get
What sets Hephaestus apart is how it is put together, with ECS-backed scenes, structured editor tooling, and a roadmap aimed at professional-quality tools without the weight of a megascale engine.
Modern scene model
Entity–component design keeps iteration fast; the editor mirrors the same structure you ship in play mode.
Lua-first gameplay
Script behavior with lifecycle hooks and APIs for entities, input, UI, and engine services; C++ stays on the hot paths.
File-based assets
Meshes, textures, PBR materials, scenes, blueprints, .hui UI documents, and scripts are browsable and inspectable in the editor.
Qt editor
Dockable panels, viewport hosting, asset browsing, and native widgets add up to desktop tooling built for long sessions.
HephaestusUI
In-game UI from structured .hui documents with optional Lua controllers; layout and logic stay cleanly separated.
Physics integration
Jolt Physics drives rigid-body simulation stepped with the scene and components for stable, modern behavior.
How the engine is organized
Hephaestus is structured as modular subsystems with clear responsibilities, from Vulkan rendering to ECS, Lua scripting, assets, and the split between editor and runtime.
Rendering
Owns Vulkan device lifetime, frame resources, material binding, lighting data, optional directional shadow mapping (including cascade-related data paths), and skybox / environment rendering, including HDRI-driven backgrounds where configured. Shared between editor viewports and packaged runtimes so authoring matches playback.
Entity Component System
Entities compose transforms, mesh renderers, materials, cameras, scripts, physics-related data, and more. EnTT backs efficient queries while the engine exposes a small, engine-specific API to gameplay and tools.
Scripting (Lua)
The supported path for gameplay logic runs through lifecycle hooks (such as awake, update, destroy) and services for entities, input, UI, and engine integration.
Asset system
Projects rely on file-based assets with export tooling to gather references for distributable builds. The editor surfaces everything through browsers and inspectors.
Editor vs runtime
The Qt editor hosts the viewport, manipulates the ECS scene, and edits assets. The runtime loads the same kinds of data without authoring chrome; packaged builds can boot straight into play mode for a smaller player-facing footprint.
Core technologies
The pillars of the runtime, renderer, tools, and simulation, plus supporting pieces that serve the same architectural goals.
C++ (C++20)
Core language
Runtime, renderer integration, scene systems, and editor glue; hot paths stay fast and dependencies stay explicit.
Vulkan
Graphics API
Swapchains, pipelines, materials, lighting, shadow passes, and sky rendering all go through Vulkan with engine-level abstractions.
Qt
Editor UI
Docking panels, viewport hosting, asset browsing, inspectors, and native widgets, all purpose-built for desktop tooling.
Lua
Scripting
Primary language for gameplay and UI control, covering entities, lifecycle events, and HephaestusUI at runtime without recompiling the engine.
Jolt Physics
Simulation
Rigid-body simulation integrated with the scene and components for stable, modern physics stepping.
Supporting pieces
Implementation detail
EnTT for ECS storage, GLFW for windowing on some paths, and asset helpers; behind the same design goals as the pillars above.
Rendering
Current rendering direction
Not an exhaustive AAA feature list, just an honest snapshot of what the Vulkan path targets today.
- PBR materials. Metallic–roughness workflow with albedo, emissive, roughness, metallic, and ambient occlusion; texture bindings for albedo, normals, roughness, AO, and related options as exposed.
- Lighting. Directional lights with shadow mapping (including cascade-related data), plus point and spot lights with bounded counts suited to real-time use.
- Environment. Skybox rendering with HDRI-based environments (including intensity control) and solid-color fallbacks when no HDRI is set.
Exact limits depend on project settings and hardware; treat them as project-tunable details, not fixed marketing guarantees.
Editor
Tools that feel familiar
The Hephaestus editor is built to feel like professional creative software, inspired by workflows people already know from tools like Adobe and Figma, while still grounded in real-time engine production.
- Real-time viewport with navigation and display options (including shadows and skybox where implemented).
- Asset browser with filtering and shortcuts for supported types, including UI documents.
- Scene hierarchy for create, rename, reparent, and select; mirrors ECS structure.
- Inspectors for transforms, components, and asset references.
- PBR material authoring with property-driven workflows and node-based material graphs where enabled, plus live preview.
Designers can produce meaningful in-engine content without writing code, while programmers still keep full control through Lua scripting and engine-level access.
HephaestusUI
Layout and styling live in .hui files, structured JSON-based documents that define widget trees, properties, anchors, and optional Lua controllers. Recommended high-level calls include display.ui(path) and destroy.ui(target) for lifecycle-safe screen management. Visual editing is iterative, not finished, with directions toward hierarchy- and canvas-oriented tooling.
Current strengths
- Rapid prototyping with Lua,
.huiUI, and fast editor iteration shortens the idea-to-playable loop. - Custom workflows backed by scripting APIs and documented extension points so you can tailor import steps, tools, and gameplay behavior.
- Strong visibility into gameplay behavior through Lua and documented engine APIs, without an opaque black box between your scripts and the renderer.
- Lightweight footprint with a modest codebase and runtime compared to large commercial engines.
- Coherent stack with Vulkan, ECS, Jolt, Qt, and Lua forming a deliberate foundation.
What it is good at
Honest positioning helps you decide faster.
Strong fit
- Indie or experimental 3D projects where hands-on control of the pipeline is a plus.
- Small teams that want a focused runtime and editor stack without enterprise-scale overhead.
- Custom pipelines or internal tools beside a renderer with clear extension and scripting hooks.
- Projects that value clear ownership and control while using a supported proprietary engine.
Weaker default
- Turnkey multiplayer, film-grade animation, or immediate access to massive asset ecosystems without integration work.
Hephaestus does not claim to match Unreal or Unity ecosystem scale (marketplace, animation suites, full audio middleware, multiplayer services, etc.).
Limitations (candid)
A young engine should set expectations clearly. APIs and formats can change; tooling is improving but behind established products; documentation is still growing, so expect to lean on shipped docs and samples; platform coverage is best-effort, and not every combination is validated to shipping quality.
Roadmap themes
Directional themes (not commitments on schedule). Items shift with development bandwidth and project needs.
- Richer UI tools with stronger visual editing for
.hui, better preview, and faster iteration for UI designers. - Visual scripting / node-based gameplay that adds designer-friendly logic alongside Lua.
- Engine optimizations driven by profiling across rendering, loading, and editor responsiveness.
- Expanded rendering with additional lighting models, post-processing, and material features as the Vulkan path matures.
- Packaging and collaboration with smoother export, project templates, and clearer onboarding for new projects.
Visual showcase
A curated look at editor workflows, in-engine scenes, rendering features, and UI tooling in Hephaestus.
Tech demos
Showcases of the engine's capabilities.
Get started
Pick a path that matches how you learn, from overview to docs to hands-on with the build you receive from the project.
Learn the engine
Walk the feature set and architecture on this page, then dive into technical references when you are ready.
Explore capabilities →Read the docs
The latest technical detail ships with the engine in the Documentation/ folder and CHANGELOG.md.
Download & build
Access builds and distribution details through your Olympus Game Studios channel or official distribution path when available.
Contact the studio for access options.Documentation for developers
Go deeper after the tour. System boundaries, asset formats, scripting APIs, and editor workflows are covered in the engine’s documentation tree alongside the changelog.
Documentation/ · CHANGELOG.md
Bundled with Hephaestus distributions—the reference for up-to-date technical detail.
Join the team
We are always looking for developers, technical artists, and creative builders who care about high-quality tools and game technology.
Olympus Game Studios
Hephaestus Engine is developed by Olympus Game Studios as a focused product line built around professional tooling and a coherent runtime for teams who want clear control over their project and pipeline. This site is dedicated to the engine itself, separate from the broader studio presence, but clearly part of the same creative direction.