Metadata-Version: 2.4
Name: SimVX
Version: 0.0.0.dev0
Summary: A Python game engine: scenes are plain Python classes, with Vulkan rendering and browser export.
Project-URL: Homepage, https://simvx.com
Project-URL: Documentation, https://simvx.com/docs/index.html
Project-URL: Examples, https://simvx.com/docs/examples/index.html
Project-URL: Source, https://git.simvx.com/simvx/simvx
Author-email: SimVX <contact@simvx.com>
License-Expression: AGPL-3.0-or-later
License-File: COMMERCIAL-LICENSE.md
License-File: LICENSE
License-File: LICENSE-ADDENDUM.md
License-File: LICENSE-EXCEPTION.md
License-File: NOTICE
License-File: TRADEMARK.md
Keywords: 2d,3d,game-development,game-engine,graphics,physics,renderer,scene-graph,vulkan,webgpu
Classifier: Development Status :: 1 - Planning
Classifier: Intended Audience :: Developers
Classifier: Operating System :: OS Independent
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.14
Classifier: Topic :: Games/Entertainment
Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Requires-Python: >=3.14
Description-Content-Type: text/markdown

![SimVX](https://static.simvx.com/pypi/banner.webp)

[![AGPL-3.0-or-later, Python 3.14+, latest development build](https://static.simvx.com/pypi/badges.svg)](https://simvx.com/docs/install.html)

## Scenes are Python code

```python
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.

![SimVX demos](https://static.simvx.com/pypi/features.webp)

> **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.

![Release progress](https://static.simvx.com/pypi/progress.svg)

## 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:

```bash
pip install simvx && simvx-preflight
```

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

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

Or from source:

```bash
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>.
