pokeredpc

Pokémon Red, rebuilt as a native PC game—and now Monworks, a standalone monster-RPG creation toolkit (with Monworks Studio, its editor). v2.0.0 shipped July 2026.

pokeredpc is a from-scratch, data-driven Godot 4.7 port of pret/pokered. It is not an emulator, ROM patcher, or static recompilation. A local extractor turns the disassembly into project data and assets; an original native engine reproduces the game using the assembly as its behavioral specification.

Both halves are complete and playable: the faithful port, and the Monworks toolkit — a desktop editor plus a generic Engine/Project/Ruleset architecture for making other monster-catching RPGs without opening the Godot editor.

Status

Track	State
Native Pokémon Red	Shipped (v1.0 playthrough sign-off, v1.1 Cable Club multiplayer, v1.2 session resume) — all 223 maps, complete critical path, battles, saves, audio, link trades/battles
Monworks toolkit	v2.0.0 shipped — versioned portable projects, ruleset/formula/event hatches, Studio with map/event editors and softlock lints, sandboxed HatchScript, per-project widescreen viewports
Sample games	Two original CC0 projects: Meadowbrook (the starter world) and Bramblewick (the genericity stress test, beaten end-to-end by its own bot)
Creator exports	Distributable — one engine exe + your project folder; the clean engine build embeds zero extracted content (mechanically verified)

The detailed, evidence-backed tracker is docs/roadmap.md. The v2 product direction lives in docs/v2/plan.md, and the supplied Studio reference boards are translated into an implementation contract in docs/v2/studio-visual-direction.md.

Build and play

You need Python 3, Pillow, PowerShell 7, a local checkout of pret/pokered, and the portable Godot 4.7 binary. Extracted assets and builds are deliberately not stored in this repository.

git clone https://github.com/johnjohto/pokeredpc.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:
pwsh tools/build.ps1
pwsh tools/run.ps1

Controls: arrow keys move/navigate · Enter/Space is A (interact/confirm/advance) · Esc is B/START (back/cancel/open the start menu).

See the build and run guide for exact Godot filenames, exports, multiplayer, verification flags, and troubleshooting.

Open Studio

After building the project:

pwsh tools/run.ps1 --studio

Studio opens as a native, resizable 1280×800 desktop application with a persistent 80–200% UI-scale slider (125% by default). It currently edits species, moves, items, and trainers, validates through the same Core schemas the Engine uses, creates and paints native maps, places typed gameplay objects, edits seamless world connections, and launches a separate play-test process with an isolated save. Do not edit the extractor-owned game/project in place; copy it to a creator workspace and open that copy.

Developers can open the focused Phase-5 native-map tracer directly:

pwsh tools/run.ps1 --studio-map-fixture

The map workspace supports a tileset palette, tile/erase/fill and optional Gen-1 block brushes, per-cell collision, pan/zoom, typed warp/NPC/sign/trigger tools and inspectors, reciprocal cardinal world links, exact unified undo/redo, source-preserving Save/Revert, and play-testing directly on the active map. NPCs and triggers can create/open events in a schema-derived command-list editor with typed fields, nested if/ask branches, validation, undo/redo, Save/Revert, and child-process play-test. A problems panel runs the softlock lints that caught real sequence-breaks in the original. MIDI and pluggable chiptune import are tracked as backlog in gh #60.

Make your own game

Start from a sample and follow the creator guide:

pwsh tools/run.ps1 --studio               # open samples/starter (Meadowbrook), edit, play-test
pwsh tools/export_game.ps1 -Project my-game   # ship it: engine exe + your project folder

Exports use the clean Monworks Engine build — no extracted content rides along (verify any build with python tools/scan_pck.py <exe>), so your game is yours to distribute under the MIT/CC0 model.

How it is shaped

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

• Core owns project schemas, stable IDs, validation, event definitions, ruleset interfaces, and the native MapDocument boundary.
• Engine owns runtime presentation and systems. Gen-1 mechanics live behind a built-in ruleset rather than defining the whole 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.
• Tiled TMX/TSX is the native map format. The canonical grid is one 16×16 movement cell; familiar 32×32 Game Boy blocks remain optional authoring metadata.

The current TMX bridge and lossless preservation rules are documented in docs/v2/tiled-map-bridge.md.

Repository map

docs/                 architecture, format, engine rules, ADRs, roadmap, guides
game/core/            shared Project/schema/ruleset/event/map contracts
game/rulesets/gen1/   faithful Gen-1 mechanics modules
game/scripts/         Engine runtime and Studio application
game/project/         extracted default Project (generated, git-ignored)
pokered/               upstream disassembly (clone separately, git-ignored)
tools/extract.py       pokered source → project data and PNG assets
tools/build.ps1        extract and import
tools/run.ps1          launch Engine, Studio, or a verification scenario
build/                 local previews/exports (git-ignored)

Start in docs/index.md when changing behavior or formats. Decisions with lasting architectural consequences are recorded in docs/decisions.md.

Verification philosophy

The port treats the disassembly as executable specification. Focused --…test scenarios, schema/refusal fixtures, deterministic battle hashes, link soaks, and a seeded legit-play bot cover systems from small rules through NEW GAME → HALL OF FAME. Studio adds byte-identity round trips: opening and saving untouched project content must not create a diff.

Useful fast checks include:

pwsh tools/run.ps1 --selftest
pwsh tools/run.ps1 --schematest
pwsh tools/run.ps1 --tmxtest
pwsh tools/run.ps1 --studiotest

Assets and distribution

Pokémon data and graphics are extracted locally from the user-supplied pret/pokered checkout and remain git-ignored: do not distribute extracted assets or builds containing them — the faithful Kanto build stays personal-use. The toolkit itself ships only original Engine/Studio code, original sample content, and import recipes, never Nintendo content — which is why creator exports (the clean Monworks Engine build) are distributable.

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

License

The original code — the engine, Monworks Studio, the tools, and the docs — is MIT (see LICENSE). The sample projects' content is CC0 (see samples/LICENSE): copy them, ship them, no attribution needed.

What is 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. The faithful Kanto project is a recipe applied to your own clone — the repository never contains or ships it.