A minimal, fast, and flexible 2D game engine built on Pit—an actor-based language designed for safe, sandboxed scripting. Prosperon gives you a compositor-driven rendering pipeline, multi-device input, and reflective tooling, all in a tiny executable you version with your project.
Prosperon is a game programming environment for 2D games. Think of it like a 2D S&Box: you write game logic in Pit (a simplified, sandboxed JavaScript), and Prosperon handles rendering, input, audio, and asset management. Games are written as small, focused modules that compose together—no class hierarchies, no giant scene trees.
The engine ships as a single executable. Drop it in a folder, write your scripts, and run. Your entire project is text files—friendly to source control, easy for collaborators, and readable by AI tools.
Describe your scene as planes, layers, and effects. The compositor builds a render plan—bloom, masks, shader passes—and the SDL GPU backend executes it. You declare what to draw; the engine decides how.
If an object looks like a sprite, it is a sprite. Register any object with film2d and it draws. No base classes, no component systems to configure. Just data.
Game logic runs in Pit—an actor language where each program has its own heap and message queue. Spawn actors, send messages, schedule work with $delay and $clock. Clean isolation without threads.
Keyboard, mouse, gamepad, and touch—normalized into named actions. Supports user pairing, control stacks (possess/push/pop), emacs-style keybindings, and gesture recognition out of the box.
Every game file is text. Modules are .cm files, programs are .ce files, configs are plain objects. No binary scene files until you ship. Git merges just work.
Prosperon is a single executable. No installer, no SDK, no build tools. Version it alongside your project. Supports Windows, Mac, and Linux.
A Prosperon game is a collection of modules (.cm) and programs (.ce). Modules return frozen values—APIs, configs, data. Programs are entry points that run top-to-bottom and can spawn child actors.
The engine provides core modules for everything you need:
You compose these into your game. A typical frame:
// Your game registers sprites with film2d
// The compositor queries film2d for drawables
// It builds render passes (clear, draw, effects, blit)
// The GPU backend executes the command list
// Input events are normalized and dispatched to your pawns
// Audio pumps in the background via $delayProsperon's rendering is data-driven. Your game logic never touches the GPU. Instead:
film2dThis means you can inspect the entire render plan as data. Debug it, log it, swap backends. The renderer supports sprite batching, y-sorting, effect pipelines (threshold + blur for bloom, mask rendering), and multiple presentation modes for pixel-perfect scaling.
Prosperon games are written in Pit, an actor-based language that looks like simplified JavaScript. Pit is designed for safe, sandboxed execution—each actor runs in its own heap with hard memory and time limits.
Key differences from JavaScript:
.cm) return frozen values—no accidental mutation.ce) are actor entry points with message handlersmeme() and closures$start, $receiver, send, $delay, $stopPit compiles to bytecode and runs on a QuickJS-derived VM. Modules are cached as .o files for fast loading.
Prosperon is currently $25 in pre-release (50% off the eventual $50 price). That one-time fee grants you:
Read the Prosperon manual to learn about the module system, rendering pipeline, input handling, and deploying your game. Prosperon also ships with example games (pong, snake, chess, tetris, bunnymark) to help you learn fast.
All Prosperon licenses are commercial. You can distribute Prosperon-based games with no royalties and freely ship the Prosperon runtime. For full details, visit the license page.