Monworks

A creation toolkit for classic monster RPGs — grown from a from-scratch, native PC port of Pokémon Red. Not an emulator, ROM patcher, or recompilation.

Meadowbrook, one of the two CC0 sample games in the box — the wild mons roaming the grass are one data file, using the same living-world systems our faithful-port showcase runs.

Download and play

⬇ Grab the latest release — Windows, Linux, and macOS. Two complete original sample games are bundled: you are playing inside a minute, no build step, nothing else to install.

Controls: arrow keys move · Enter/Space is A · Esc is B/START. Controllers work out of the box.

Three ways in

You want to…	Start here
Play the sample games	Download, run, play. Getting Started on the wiki
Make your own monster RPG	Open Monworks Studio (bundled), edit a copy of a sample, export one exe + your project folder. Make Your Own Game
Build the faithful Pokémon Red port	Clone pret/pokered beside this repo and build locally — see below. The extracted game never ships; your build is yours alone

Why it's interesting

• A complete, faithful Gen-1 engine, natively — all 223 maps, battles, saves, audio, link trades and battles; the disassembly is the behavioral spec, and a seeded bot plays NEW GAME → HALL OF FAME as a release gate.
• A real editor — Monworks Studio edits maps, monsters, moves, trainers, items, branching story events, scripts, and translations, with softlock lints that caught real sequence-breaks in the original game.
• Multiplayer your fan game inherits — cable-club trades and lockstep link battles, self-hosted lobby servers with a content-blind relay, replay-verified anti-cheat, and Elo ladders. Your exported game gets all of it.
• Determinism as a feature — battles emit event streams that hash byte-identical across Windows, Linux, and macOS from independent extractions, gated in CI. That's what makes fair online play and replay verification possible.
• Actually shippable — one engine exe + your project folder, MIT code and CC0 samples, with a scanner that mechanically proves an export contains zero extracted Nintendo content.

Everything in the box

The complete feature surface, in fan-game terms. If it's listed, it exists and a test suite gates it — the roadmap is the evidence-backed tracker.

World & story Tiled-native TMX maps on a 16×16 grid (optional Game Boy 32×32 block brushes) · seamless world connections, warps, dungeons · branching event scripts with flags, badges, items, YES/NO asks and nested conditions · a data-authored day/night clock with day-parts, weekdays, and seasons · time- and state-conditioned encounter tables · visible overworld wild encounters with per-species dispositions (wander / flee / chase) · hidden items, signs, marts, prize counters, in-game trades · scripted set-piece battles (no-blackout losses, catch-locks, walk-through narration). Wiki: The Clock · Conditioned Bindings · Overworld Spawns · Set-Piece Battles

Monsters & battles Custom species, moves, and custom types (one sample ships a charm type) · the faithful Gen-1 ruleset plus a modern ruleset (physical/special split lineage) · abilities and held items via a battle-hook layer · natures, genders, shinies · sprite-variant sets (shiny art, seasonal art, whole-game art swaps) · trainer classes with the real Gen-1 AI patterns · battle backdrops and move animations · formula overrides in a sandboxed scripting language — damage, catch rates, stat math are yours to bend. Wiki: Abilities & Battle Hooks · Modern Individuals · Sprite Variants · The Modern Ruleset

Multiplayer — and your game inherits all of it Cable-club trades and lockstep link battles over LAN or direct IP (UPnP handles the router) · two-phase journaled trades that survive crashes and cable pulls · session resume across connection blips, direct or relayed · self-hosted lobby servers (handle + token identity, open/invite/closed registration) with challenge → match introductions · a content-blind relay fallback proven byte-transparent · replay verification: cheated results are re-simulated on the server and voided — a cheat cannot beat an honest player · Elo ladders with operator-authored formats and battle clauses (sleep/freeze/evasion/OHKO) hash-agreed before turn 1. Wiki: Run a Server · Join a Server

Presentation & platform Per-project widescreen viewports (the Game Boy frame is a choice, not a limit) · authentic display filters (DMG, Pocket, and friends) with integer scaling · palette system with per-map, per-time assignments · full controller support with press-to-capture rebinding and hot-plug profiles · engine settings screen (volume buses, filters, keybinds, server address) · title screens, intros, and credits are all project data. Wiki: Widescreen & Scaling · Display Filters · Colors & Palettes

Saves & player comforts Save slots (a household of characters per game) · shared PC storage across a household's characters · bag/box capacity knobs · optional autosave and running shoes · crash-safe trade journaling with honest recovery. Wiki: Quality-of-Life Knobs

Localization Language packs as sparse overlay folders — translate three strings and ship · live language switching mid-game, mid-battle · custom fonts and character maps · a Studio translation workspace with per-surface coverage counts. Wiki: Language Packs

Tooling & shipping Monworks Studio — a native desktop editor, no Godot knowledge required · schema- validated forms for every record type · map painting with collision, warp, NPC and trigger tools, unified undo/redo · a problems panel running softlock lints · byte-identity round trips (opening and saving untouched content creates no diff) · isolated one-click play-testing · a portable, versioned, diff-friendly project format (plain JSON + TMX) · one-exe exports for three OSes with a mechanical clean-content scan · project validation with reviewable suppressions · deterministic battle replays gated in CI across all three OSes. Wiki: Studio Tour · Export and Share

The next era — Crystal's two regions, breeding, and the systems that come with them — is designed and queued on the roadmap.

The faithful port: build it yourself

The Pokémon Red port is a recipe applied to your own clone of the disassembly — this repository never contains or ships Nintendo content. You need Python 3, Pillow, and the portable Godot 4.7 binary — the same commands on Windows, Linux, and macOS:

git clone https://github.com/johnjohto/monworks.git
cd pokeredpc
git clone --depth 1 https://github.com/pret/pokered.git pokered
python -m pip install --user Pillow

# Put Godot 4.7 in tools/godot/ (or set POKEREDPC_GODOT), then:
python tools/build.py
python tools/run.py

The build and run guide covers exact Godot filenames, exports, multiplayer, verification flags, and troubleshooting.

Open Studio

python tools/run.py --studio     # from a source checkout; releases bundle the Studio exe

Copy a sample from samples/ to your workspace, open it, and follow the creator guide. Ship it with python tools/export_game.py --project my-game — one engine exe plus your project folder, verified clean automatically (tools/scan_pck.py gates every export; most creators never need to export locally — releases bundle everything).

How it is shaped

Studio ───────┐
              ├── Core ── Project (data, TMX maps, events, assets)
Engine ───────┘              │
  │                          └── selected Ruleset (built-in: gen1, modern)
  └── plays the same Project Studio edits

• Core owns project schemas, stable IDs, validation, event definitions, ruleset interfaces, and the native map boundary.
• Engine owns runtime presentation and systems; Gen-1 mechanics live behind a built-in ruleset rather than defining the architecture.
• Studio is a creator-facing desktop application over Core — not a Godot plugin.
• Project is the portable, versioned, diff-friendly game folder both applications use. Maps are Tiled TMX/TSX.

docs/                 architecture, formats, engine rules, ADRs, roadmap, guides
game/core/            shared Project/schema/ruleset/event/map contracts
game/rulesets/        gen1 (faithful) and modern mechanics modules
game/scripts/         Engine runtime and Studio application
tools/                extractor, build/run/export, verification suites
samples/              Meadowbrook and Bramblewick (CC0)
pokered/              upstream disassembly (clone separately, git-ignored)

Verification philosophy

The disassembly is treated as executable specification. Focused test scenarios, schema and refusal fixtures, deterministic battle hashes, link soaks, a three-process server suite, and a seeded bot that legitimately plays NEW GAME → HALL OF FAME gate every change. Battle streams reproduce byte-identically across Windows, Linux, and macOS from independent extractions — the CI badge above is that claim, mechanically checked. Studio adds byte-identity round trips: opening and saving untouched content must not create a diff.

Licensing

• The code — engine, Studio, tools, docs — is MIT (LICENSE).
• The sample games are CC0 (samples/LICENSE): copy them, reskin them, ship them, no attribution needed. Your exported game is yours.
• Not licensed for distribution: anything extracted from your own pret/pokered clone (game/assets/, game/project/, builds embedding them). That content derives from Nintendo's game, is produced locally on your machine, and stays personal-use only. Exports use the clean engine build and embed zero extracted content — tools/scan_pck.py proves it for any build.

Elsewhere

The wiki — tutorials for every capability · docs/ — formats, engine rules, and architecture decisions · the roadmap · issues · releases.

---

In the beginning was the Word, and the Word was with God, and the Word was God.