Infernux is an open-source, MIT-licensed game engine in which gameplay, editor tools and render pipelines are written in Python while a C++ runtime, a Vulkan renderer and Jolt physics do the execution, aimed at developers who want Python-first authoring and one project that ships to Windows, Linux, Android and the browser.

What it is

Infernux is a game engine built around a deliberate split: Python is where you work, and C++ is where it runs. Authors write components, editor panels, render pipelines and numerical code as ordinary Python classes, while a native runtime, a Vulkan renderer and Jolt physics handle the heavy lifting. The same project targets Windows x64 and Linux x86_64 for both editor and player, Android arm64/x86_64 as APK or AAB, and the web as HTML plus WASM over WebGPU. It is distributed under the MIT licence and developed in the open on GitHub.

The concrete problem it addresses is the usual arrangement in which the scripting layer is a thin surface over engine internals the author cannot reach. Infernux exposes the same Python surface to gameplay, to the render pipeline through a RenderStack that a native RenderGraph executes, and to the editor itself through dockable panels and menus written in Python. It also carries a longer-term goal it calls 3N, a Neural Network-Native engine, in which the world is data a model can read and the simulation is a place a model can act — rather than AI arriving as a plugin bolted on after the game is finished. The README is explicit that those neural-network features are roadmap items, not shipped functionality.

Key capabilities

• Components are plain Python classes deriving from inx.InxComponent, with fields declared through inx.serialized_field that appear in the Inspector and can be tuned while the game runs; coroutines and prefabs are supported alongside.
• Project scripts and plugins hot-reload transactionally, including the behaviour of instances that already exist in the running scene.
• A RenderStack described in Python is executed by the native RenderGraph, covering Forward, Forward+ and Deferred paths, PBR, shadows, post-processing, GPU particle graphs, skinned animation, and screen-space and world-space UI.
• The game loop includes multi-scene editing, FBX and Blender import with live source sync, Jolt rigid bodies and scene queries, audio, animation state machines and a Timeline.
• Numerical work runs inside the game through batch NumPy access to world data, CPU/GPU JIT, and Taichi integration.
• The editor is extensible in Python: InxPackage plugins carry components, tools, assets and platform exporters, and an optional MCP plugin lets agents drive the editor through the same command and undo paths a human uses.
• Assets keep a GUID identity from import through to the cooked Player, and Players load a packed asset index rather than the project folder.

Who uses it and how

• Solo developers and small teams prototyping gameplay in Python, using InfernuxHub to manage Python environments and Android tooling so that no native compiler is needed to get started.
• Teams shipping one project to several targets at once, taking the editor on Windows or Linux while producing APK/AAB builds for Android and HTML plus WASM builds for the web.
• Rendering and technical-artist work, where the RenderStack is authored in Python against a native graph rather than configured through opaque engine settings.
• Numerical and AI-oriented development, using NumPy batching and Taichi to treat world data as something a model can read and the simulation as somewhere it can act.
• Tool and pipeline builders distributing components, assets and platform exporters as InxPackage plugins, including agent-driven editor workflows through the MCP plugin.

Getting started

Install InfernuxHub from the project's download page, choose an engine version and create a project; the Hub sets up the Python environment and Android tools, after which the five-step start guide walks through a component spinning a cube. Building from source on Windows requires Visual Studio with the Desktop C++ workload, CMake 3.25+, the Vulkan SDK and Python 3.13, followed by ./scripts/setup/configure_development.ps1 and the windows-msvc-release CMake presets.

How it compares

No comparable engines or paid products are named in the material available here, so Infernux stands alone in this registry rather than being positioned against a specific alternative. Its distinguishing axis, as documented, is the Python-authoring and C++-runtime split combined with an MIT licence and self-hosted distribution.

When to use it — and when not to

Infernux is alpha software under active development: APIs still change between releases, and the neural-network features that give the project its 3N framing are roadmap items rather than shipped functionality, so it suits experiments, tools and small games rather than a production schedule. Self-hosters building from source must supply a Visual Studio installation with the Desktop C++ workload, CMake 3.25+, the Vulkan SDK and Python 3.13, and the editor is available only on Windows and Linux — Android and Web are Player targets with no editor. Teams that need a stable, frozen API or an editor on mobile and browser should look elsewhere for now.

import infernux as inx


class Spin(inx.InxComponent):
    speed: float = inx.serialized_field(default=90.0, range=(0.0, 360.0))

    def update(self, delta_time: float) -> None:
        self.transform.rotate(inx.Vector3(0.0, self.speed * delta_time, 0.0))

git clone --recurse-submodules https://github.com/ChenlizheMe/Infernux.git
cd Infernux
./scripts/setup/configure_development.ps1
conda activate infernux
cmake --preset windows-msvc-release
cmake --build --preset windows-msvc-release
cmake --build --preset windows-msvc-install-wheel
python packaging/launcher.py

@software{chen2026infernux,
  author  = {Chen, Lizhe},
  title   = {Infernux},
  year    = {2026},
  version = {0.4.3},
  url     = {https://github.com/ChenlizheMe/Infernux}
}