--- title: "Prosperon Engine" ---

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.

## What Is Prosperon?

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.

## Key Features

### Compositor Rendering

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.

### Duck-Typed Sprites

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.

### Actor-Based Scripting

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.

### Multi-Device Input

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.

### Source-Control Friendly

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.

### Tiny & Self-Contained

Prosperon is a single executable. No installer, no SDK, no build tools. Version it alongside your project. Supports Windows, Mac, and Linux.

## How It Works

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:

- core — main loop, window management, frame scheduling
- film2d — drawable registry (sprites, shapes, text, tilemaps, particles)
- compositor — builds multi-pass render plans from scene descriptions
- input — multi-device action mapping with control stacks
- sound — audio playback with PCM caching and voice mixing
- resources — asset discovery and path resolution
- draw2d — high-level 2D drawing (points, lines, rectangles, circles)
- tween — fire-and-forget animation with easing functions

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 $delay

## The Rendering Pipeline

Prosperon's rendering is data-driven. Your game logic never touches the GPU. Instead:

1. Register drawables (sprites, shapes, text) with `film2d`
2. Describe your scene as planes with optional effects (bloom, masks)
3. The compositor queries film2d, sorts by layer, builds render passes
4. The SDL GPU backend executes the command list on Metal/Vulkan/DirectX
5. Final output is blitted to screen with letterbox, integer scale, or stretch

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

## The Language: Pit

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:

- Modules (`.cm`) return frozen values—no accidental mutation
- Programs (`.ce`) are actor entry points with message handlers
- No classes—prototypal objects via `meme()` and closures
- Actor primitives—`$start`, `$receiver`, `send`, `$delay`, `$stop`
- Capability-based—actors start with zero permissions, granted explicitly

Pit compiles to bytecode and runs on a QuickJS-derived VM. Modules are cached as `.o` files for fast loading.

## Price

Prosperon is currently $25 in pre-release (50% off the eventual $50 price). That one-time fee grants you:

- Use of Prosperon for commercial or personal games (no royalties)
- All updates through v1.x
- Support for Windows, Mac, and Linux
- Account on the official forum

### Plus Support

$30/year

- Access to support forum
- Vote on 1 feature for upcoming releases

### Pro Support

$80/year

- Access to support forum
- Vote on up to 5 features
- Early access to new features

## Learn

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.

## License

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.