🚧  Synaptic Foundry is under active development — Early Access coming soon
Iron Grid — Synaptic Foundry
Iron GridSynaptic Foundry
DocsDownload
🐍 Python-Native · Built-in Physics

The game engine built for makers

Synaptic Foundry is a Python-first game engine with a built-in physics simulation, visual scene editor, and zero-config cross-platform export.

Download Early AccessRead the Docs →

Free & open source · Windows, macOS, Linux

Python
Native scripting language
Built-in
Rigid & soft body physics
Cross-platform
Windows, macOS & Linux

Everything you need to build a game

No plugins. No licensing fees for core features. Everything ships in the box.

🐍

Python-First Scripting

Write game logic in pure Python. No proprietary DSL, no transpilation — just the language you already know, with full stdlib access and pip package support.

⚙️

Built-in Physics Engine

Synaptic Foundry ships a high-performance rigid body and soft body physics engine out of the box. Collision shapes, constraints, joints, and raycasting — zero setup.

🎬

Visual Scene Editor

Compose scenes visually with a node-based editor. Place meshes, lights, colliders, and scripts, then preview in real-time without leaving the editor.

📦

Asset Pipeline

Import FBX, GLTF, OBJ, PNG, WAV, and more. The asset pipeline auto-converts, compresses, and hot-reloads assets during development.

🔦

Deferred Renderer

A modern deferred rendering pipeline with PBR materials, dynamic shadows, screen-space reflections, and HDR bloom right out of the box.

📡

Built-in Networking

Multiplayer-ready from day one. Synaptic Foundry includes authoritative server support, state synchronisation, and a lobby API for up to 64 players.

Python-Native Scripting

Write games the way
you write software

Synaptic Foundry uses Python as its first-class scripting language. Attach a script to any node, subclass Component, and your logic runs directly in the engine loop — no bindings, no glue code.

  • ✓Full Python 3.12+ stdlib and pip package support
  • ✓Type-hinted engine API with IDE autocomplete
  • ✓Hot-reload scripts without restarting the engine
  • ✓Async/await support for coroutine-based game logic
rigidbody_controller.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# rigidbody_controller.py — Synaptic Foundry
from synapse import Component, Vector3
from synapse.physics import RigidBody, CollisionShape
from synapse.input import InputMap
class PlayerController(Component):
"""First-person player controller with physics movement."""
def on_ready(self) -> None:
self.body = self.get_component(RigidBody)
self.speed = 8.0
self.jump = 14.0
def on_physics_update(self, delta: float) -> None:
axis = InputMap.get_axis("move_left", "move_right")
dir = Vector3(axis, 0, InputMap.get_axis("move_back", "move_fwd"))
self.body.apply_force(dir * self.speed / delta)
if InputMap.is_pressed("jump") and self.body.is_grounded:
self.body.velocity = Vector3(0, self.jump, 0)
Built-in Physics

Physics that just works

No third-party integrations. Synaptic Foundry ships its own high-performance physics engine, tightly coupled to the rendering and scripting systems.

Rigid Body Dynamics

Full 6-DOF simulation with mass, friction, restitution, and linear/angular damping.

Collision Detection

Broadphase + narrowphase pipeline with box, sphere, capsule, convex hull, and trimesh shapes.

Soft Body Simulation

Cloth, ropes, and deformable meshes powered by position-based dynamics.

Raycasting & Queries

Single ray, swept shape, and overlap queries with layer-based filtering via one Python call.

Physics query — one line of Python

# Cast a ray and get the first hit
hit = self.physics.raycast(origin=self.position, direction=Vector3.FORWARD, distance=50.0)
if hit:
hit.collider.apply_impulse(Vector3.FORWARD * 200.0)

Ready to build your first game?

Join the early access list and be first to get Synaptic Foundry when it ships.

Join Early AccessView Roadmap