SimVX 0.0.0.dev0

Scenes are Python code

from simvx.core import Node2D, Sprite2D


class Coin(Node2D):
    def on_ready(self):
        self.add_child(Sprite2D(texture="coin.png"))


class Level(Node2D):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        for i in range(5):
            self.add_child(Coin(position=(64 * i, 0)))

Both classes are nodes, and nodes are scenes. The editor rewrites this same file and leaves the methods you wrote untouched.

This release is infrastructure, not the engine. It reserves the name and puts the documentation and the release pipeline in place. What it installs today is a preflight check; the engine itself comes from the project's own index. See Installing below.

Core architecture

Rendering. Vulkan on the desktop and WebGPU in the browser, from the same scene. Draws are batched and per-object data lives in GPU buffers, so frame cost tracks the GPU work rather than the Python that built the scene. PBR materials, shadows, ambient occlusion, image-based lighting and post-processing are all opt-in. The 2D side is its own pipeline: sprites, tilemaps, particles and 2D lights.

Editor. A scene tree, an inspector, gizmos and a play mode that runs the game in place, all built from the engine's own widgets. Every panel is a Python class you can modify.

Physics. Bodies, joints, areas and queries, in 2D and in 3D, behind one API whichever backend is in use. The default is pure Python and always present. For speed there are native backends: Chipmunk2D through pymunk, used automatically once installed, and Jolt for 3D, which you opt into per project.

Audio, animation, navigation, tilemaps, UI and save/load are part of the same library. Over 100 worked examples come with it: single-feature references, narrated tutorials, re-implementations of well-known games and tutorial projects, and larger demos. Most run in the browser from the docs.

Design decisions

• Scenes are reviewable. A scene change shows up in git diff as source, and a conflict in one is resolved like any other merge conflict.
• No scripting bridge. Engine, editor and game run in one runtime. There is no binding layer between a fast core and a slow script language, and an editor plugin uses the same API as the game.
• Standard tooling. Game code is an ordinary Python package, so you can use pdb, pytest, mypy and anything else on PyPI.
• Export to HTML. simvx export web game.py writes a WebGPU page you can serve from any static host, with no backend and nothing for a player to install.
• Headless is first class. CI can render a frame and assert on the pixels with no display attached, and programmatic input drives a scene the way a player would.

Installing

Requires Python 3.14+ and a Vulkan 1.2+ driver for the desktop renderer. Windowing runs on GLFW, SDL3 or Qt. A Vulkan driver comes from your GPU vendor, not from pip, so this package ships a check for one:

pip install simvx && simvx-preflight

The engine itself is published continuously to the project's own index:

pip install --pre simvx --extra-index-url https://pypi.simvx.com/

Or from source:

git clone https://git.simvx.com/simvx.git && cd simvx && uv sync

Licence

AGPL-3.0-or-later covers the engine. A game-distribution exception then lets you ship your own game under any licence you like, closed source included, at no cost. It has three conditions: that the game display the "Made with SimVX" splash, that it use the engine through its public interfaces, and that changes to the engine itself stay AGPL. A commercial licence covers what that exception does not, such as shipping without the splash. See https://simvx.com.