🎮 gamestack

An agentic framework for building games on any platform — for Claude. Like gstack is for software, but for games.

Questions, feedback, or just want to follow along: Discord · @metatransformr on X

What this actually is (read this first if you came from a link)

This is a skill pack for an AI coding agent — cited game-design knowledge plus reusable engineering patterns, written as Markdown that Claude Code loads on demand. It is not a game, not a game engine, and not a single codebase you clone and godot --editor into — there's no .tscn file in this repo. If you're looking for the actual input/verb/seam architecture and headless test-bench pattern referenced elsewhere (e.g. a Reddit post about building a Godot RPG from the terminal), the concrete, runnable-code version of that lives in docs/headless-architecture.md — a worked Godot example, with the input→verb→seam pattern, the bench pattern, deterministic headless time (--fixed-fps), a playtest API, and a GitHub Actions example. Everything else in this README is the design-knowledge half: what an agent should know before and while it builds.

gamestack is two things working together:

• A design brain — first-party, engine-agnostic skills that give Claude the knowledge of game design (cited, discipline by discipline) and the process to apply it: concept → world → content → self-review → iterate.
• Engine hands — curated, best-in-class community skill packs for each engine (Godot, Unreal, Unity), referenced directly from one marketplace so Claude can turn a design into real engine code.

You design once, then hand off to whichever engine you're shipping in. The design layer doesn't overlap the engine packs — it's the layer they're missing.

                        gamestack  (one marketplace)
                              │
        ┌─────────────────────┼──────────────────┬──────────────────┐
   gamestack                godot               unreal           unity-jahro
 (first-party brain)       (jame581)          (quodsoler)       (jahro-console)
 design · procgen ── implements ──▶  GDSCRIPT · C++ · per-engine code
 combat · process

We don't reinvent engine work others do well — we slot it in and add the design/discipline layer on top, plus the router that binds them.

How it fits together

The two first-party skill kinds

The pipeline

  CONCEPT ──▶ WORLD & SYSTEMS ──▶ CONTENT ──▶ REVIEW & GATE ──▶ HANDOFF ──▶ ENGINE CODE
  pillars,    structure, nav,      procgen +   oatmeal/fanfic/    engine-     godot / unreal /
  core loop,  progression,         handcrafted  sameness/anti-     router      unity pack
  signature   economy, combat,     anchors,     pattern gates      picks the   implements
  mechanics   systemic rules       lore                            engine      the spec
  └──────────────── design brain (first-party) ───────────────┘ └──── engine hands ────┘

game-design-process orchestrates the design half and pulls the right skill at each phase. engine-router runs the handoff to engine code. Start at either, or invoke any skill directly.

Headless, testable architecture (input → verb → seam)

The other half of how this actually gets built — not just designed — once content exists: every system needs to be checkable without a human walking to it in a running game, and every input needs to drive the game through one auditable path.

• Input never performs logic. A keyboard read, a gamepad read, and an automated test all translate to the same verb call on a seam (a single object that owns the action). Keyboard and gamepad can't drift apart; a headless test exercises the real code path.
• Every system that's worth iterating on gets a preview harness ("bench") — boots that one slice headless, takes parameters from the CLI, captures deterministically, quits. godot --headless --path . res://tools/benches/DungeonBench.tscn -- --shots --seed=1234 and you get the same PNGs every time — golden-image testing for procgen, no editor required.
• Headless time isn't wall-clock time by default — Godot's --fixed-fps N flag forces every frame's delta to exactly 1/N regardless of real elapsed time, making physics/animation/movement fully deterministic and machine-speed-independent.
• A playtest API is just verbs composed into a session (boot(), goto(), fight_nearest(), loot_nearby(), rest()) — an integration test, or an AI agent, can play the real game headless and read the result back from logs and screenshots.

This is the concrete form of iteration-loop's preview-harness pattern and AI-playtester concept (the skill describes it engine-agnostically; the pattern itself is good testing hygiene regardless of whether an AI ever touches it). Full worked example with real GDScript, the determinism flag, and a GitHub Actions setup: docs/headless-architecture.md.

First-party skills (the design brain)

Process

Knowledge

Knowledge skills are organized into three tiers (see docs/architecture.md): universal craft (every game needs them → headed for gamestack-core), genre lenses (pulled for that kind of game), and technique modules (pulled when using that technique). Today they all live in the one gamestack plugin and are tagged with their tier in SKILL.md; the split into separate marketplace packs is a later, mechanical move.

🌐 Universal craft — applies to every genre

🛠️ Technical craft — applies to every real-time 3D (or 2D-with-lighting) game, regardless of genre. Engine-agnostic design-spec level (principles, citations, "Test for:" criteria — no engine code); topic breadth inspired by GodotPrompter's implementation-skill library, but researched and written independently. See docs/architecture.md for why this is a separate tier from universal craft and technique modules.

🎯 Genre lenses — pulled for that kind of game

🔧 Technique modules — pulled when using that technique

⚠️ Some earlier skills were built from a deep-research pass whose adversarial-verification phase was cut short by a session limit. art-direction-and-readability is verification-confirmed at its core (TF2 primary sources); narrative-and-quest-design and ai-authored-content-coherence carry a mix of verified and sourced-but-unverified rules, tagged inline (✅/⚠️/❌). Re-run a clean verification pass before treating the ⚠️ rules as settled.

Engine packs (the hands)

Curated from the community and referenced directly in the gamestack marketplace — install the one(s) for your engine. All MIT-licensed; credit to their authors.

Production & PM pack (pairs with gamestack, doesn't overlap it)

BMad Game Dev Studio (BMGD) ⭐197 (third-party, MIT, by BMad Code) is a sibling framework, not a competitor — it covers what gamestack deliberately doesn't:

Install both when you want gamestack's design depth and a tracked production cycle: /plugin install bmad-game-dev-studio@gamestack. The concrete pairing point is iteration-loop's human-playtester channel, which points to BMGD's gds-playtest-plan for structured session design rather than reinventing it — see docs/architecture.md for the full relationship.

Install

Marketplace (recommended)

In Claude Code, add the marketplace once:

/plugin marketplace add rondorkerin/gamestack

Then install the design brain plus your engine pack(s):

/plugin install gamestack          # the design brain (always)
/plugin install godot@gamestack    # + your engine
/plugin install unreal@gamestack
/plugin install unity-jahro@gamestack

Confirm with /plugin. Asking Claude a design question (e.g. "walk me through designing a procedural open-world RPG in Godot") should pull in game-design-process, and engine-router handles the handoff to the Godot pack. Pull updates with:

/plugin marketplace update gamestack

Or ask Claude to check for you — /gamestack:gamestack-upgrade runs the same check, applies the update if one exists, and shows what's new from the changelog. Auto-update on every session start is a per-user toggle Claude Code controls, not something this repo can turn on for you: enable it via /plugin → Marketplaces → gamestack → Enable auto-update.

Manual (single skill, no plugin)

First-party skills are plain folders — clone and copy the ones you want:

git clone https://github.com/rondorkerin/gamestack.git
cp -r gamestack/plugins/gamestack/skills/open-world-design ~/.claude/skills/   # all projects
# or into <your-project>/.claude/skills/                                        # one project only

Claude auto-discovers skills in those directories on the next session — verify with /skills.

Headless / Agent SDK

The skills work under claude -p and the Agent SDK. With the plugins installed, point a headless run at the pipeline:

claude -p "Use the game-design-process skill to design a procedural open-world RPG in Godot. \
Run procgen-review on all generated content, then use engine-router to implement it with the godot pack."

game-design-process sequences concept → world → content → review, procgen-review gates generated content, and engine-router hands the spec to the engine pack — no human in the loop.

Using it

Just describe what you're doing:

"I'm starting a procedural open-world RPG in Godot. Walk me through it." → game-design-process

"Lay out the macro-map for the first region." → open-world-design

"I generated 50 dungeons — check them for sameness before I commit them." → procgen-review

"The design's done — now build it in Unreal." → engine-router → unreal pack

Or invoke a skill directly with /<skill-name>.

Skill anatomy

skills/<skill-name>/
├── SKILL.md       # frontmatter (name + "use when" trigger) and overview
├── GUIDE.md       # knowledge skills: the cited "why"
├── CHECKLIST.md   # knowledge skills: actionable do/don't + test-for criteria
└── *.md           # process skills: the procedure the agent runs

SKILL.md is always cheap; everything else loads on demand. See docs/SKILL_TEMPLATE.md.

Framework internals

The process skills share a spine (modeled on gstack's shape):

plugins/gamestack/
├── ETHOS.md            # the builder ethos, injected into every process skill
├── shared/
│   ├── PREAMBLE.md     # injected at load time via !`cat ${CLAUDE_PLUGIN_ROOT}/...`
│   └── GATE.md         # the headless generate→review→repair loop contract
└── overlays/           # per-engine spec→pack-skill mapping (godot/unreal/unity/threejs)

Each process skill opens by injecting PREAMBLE.md + ETHOS.md, which loads the design bible — <your-project>/.gamestack/bible/ — the persistent, cross-session record of your pillars, world, systems, lore, constraints, and decisions. It is also the engine-independent contract engine-router hands to the engine pack. Design once; the bible remembers; implement per engine.

Roadmap

Engine coverage (curate strong community packs, or build first-party):

• ✅ Godot · ✅ Unreal · 🟡 Unity (debug-only — needs a general authoring pack) · ⬜ Three.js / web

Design brain — knowledge — 🌐 universal craft (the spine every genre needs):

• ✅ Game-design fundamentals · ✅ Game feel & juice · ✅ Level design · ✅ Onboarding & teaching
• ✅ UI/UX & feedback · ✅ Difficulty & balancing · ✅ Pacing & the player journey · ✅ Art direction & readability
• ⬜ Round 2: audio design · accessibility · playtesting & telemetry · monetization & business model · scope/production

Design brain — knowledge — 🛠️ technical craft (the rendering/motion/geometry spine every real-time visual game needs, design-spec level — see docs/architecture.md):

• ✅ 3D graphics & rendering · ✅ Shaders & VFX · ✅ Animation systems · ✅ Procedural geometry

Design brain — knowledge — 🎯 genre lenses (more genres broaden general game-dev coverage):

• ✅ Open-world design · ✅ Combat design · ✅ RPG systems · ✅ Narrative & quest · ✅ Worldbuilding & lore · ✅ Permadeath & lethality
• ⬜ Round 4: platformer/movement · shooter · puzzle · strategy/tactics · sim/management · survival/crafting · deckbuilder · horror

Design brain — knowledge — 🔧 technique modules:

• ✅ Procedural generation · ✅ AI-authored content coherence · ✅ Systemic / emergent design · ⬜ Multiplayer/netcode · ⬜ Save/persistence

Architecture & packaging (core / genre / technique multi-pack split, genre-aware orchestrator): see docs/architecture.md. Research prompts for the open rounds: docs/research-prompts.md.

Design brain — process:

• ✅ Game-design process (orchestrator) · ✅ Engine router · ✅ Procgen review · ✅ Iteration loop (covers playtest analysis, human + AI playtester)
• ⬜ Concept & pillars planning · ⬜ World-layout pass · ⬜ Quest quality gate
• ⬜ Lore-coherence audit · ⬜ Design review

Production & tooling:

• ⬜ Performance optimization (engine-agnostic principles + per-engine hooks)
• ⬜ Asset pipelines via MCP (e.g. Meshy / 3D generation, texture pipelines)
• ⬜ Algorithms (pathfinding, spatial partitioning, noise) · ⬜ Production & project management

Contributing

Research, citations, production lessons, and engine packs to slot in are all welcome — see CONTRIBUTING.md for the skill template and conventions. The design brain's knowledge skills are grown from deep-research docs; reusable prompts live in docs/research-prompts.md.

Community

Discord for questions, feedback, and discussion · @metatransformr on X for updates.

License

MIT © Arcos Labs. Engine packs are MIT-licensed by their respective authors. Use it, fork it, ship games with it.