godogen README

The project's README from github.com/htdt/godogen. As one markdown file: README.md.

Godogen

Autonomous game development for Godot (C# or GDScript), Bevy, Babylon.js, and three.js with Claude Code and Codex.

Watch the video

Watch the demos · Prompts

Describe a game. The agent builds it, generates assets, runs the engine, and proves the result — as a live game you watch and steer, or as a recorded video when you're not there. It reads the situation and decides which, in the run.

This repo is not a game. It is the source for a generator that produces games: godogen -> game repo -> game. You publish into a fresh game repo — choosing engine and host-agent flavor — then the agent runs inside that repo and builds the actual game from a short engine guide.

Source layout

A published repo is intentionally thin: a runtime manifest, a one-page engine guide, and the asset-generation skill. The agent recreates everything else (project scaffold, capture tooling) from the guide.

Engine and host agent (Claude vs Codex) are publish-time render choices, not separate source trees.

What the agent does

Choosing an engine

Every engine gets the same loop — build, generate assets, run, prove — so pick by what you want to hold at the end and how you want to watch along the way.

--engine Language You watch Pick it for
godot C# the project, run or opened in the Godot editor desktop 2D or 3D games; the fewest runtime surprises in long unattended runs
godot-gdscript GDScript the same a Godot project you'll keep developing yourself in the editor
bevy Rust cargo run a Rust codebase: ECS, no editor, many entities
babylon TypeScript a live URL a browser game that leans on engine systems: physics, GUI, particles, animation
threejs TypeScript a live URL a browser game that leans on its look: custom shaders, stylized rendering, a light page

How you'll watch. On a remote box or steering from your phone, a browser engine wins: the dev server gives you a URL you refresh while the agent edits. Godot and Bevy run as desktop apps — from a headless server you see them in the proof video, or by pulling the repo and running it locally. On your own desktop the engines are even here.

2D. Godot has a dedicated 2D engine (pixel-space nodes, tilemaps, 2D physics) and is the natural pick for 2D. Bevy handles 2D well; the web engines are 3D-first and draw 2D as sprites and planes in a 3D scene.

Godot: C# or GDScript. Same engine, scenes, and capture; only the language differs.

Browser: Babylon.js or three.js.

Bevy when you want the game in Rust: code-only, ECS, strong compile-time guarantees, and headroom for many entities. It has the slowest compiles of the five, and its API moves between releases faster than model training data catches up — the guide has the agent read the installed source instead of trusting memory.

No strong preference? babylon to watch and steer from anywhere; godot for a desktop game you'll receive as a video or run yourself.

Getting started

Prerequisites

Publish a game repo

Pick the engine and host agent:

./publish.sh --engine godot          --agent claude --out ~/my-game   # CLAUDE.md + .claude/skills/
./publish.sh --engine godot-gdscript --agent claude --out ~/my-game
./publish.sh --engine bevy           --agent claude --out ~/my-game
./publish.sh --engine babylon        --agent codex  --out ~/my-game   # AGENTS.md + .agents/skills/
./publish.sh --engine threejs        --agent codex  --out ~/my-game

Pass --force to wipe existing contents at the target before re-publishing.

Changelog

See CHANGELOG.md.

Follow progress: @alex_erm

godogen (htdt/godogen)

godot4
Searching Database…

7.4K ·GitHub
What is this?Godogen is a generator that publishes thin starter repos for Godot, Bevy, or Babylon.js games, which an AI coding agent (Claude Code or Codex) then builds out autonomously from a prompt — writing code, generating assets, running the engine, and proving the result with a live view or a recorded clip.
Is this a game, or a tool that makes games?Neither a game nor a game engine — it is the source for a generator. Running godogen publishes a new repo (choosing engine and host agent), and the agent then builds the actual game inside that fresh repo.
How do I publish a game repo?Run publish.sh and pick the target engine (Godot, Bevy, or Babylon.js) and host agent (Claude or Codex); it renders the runtime manifest, engine guide, and asset-generation skill into a fresh repo. Pass --force to overwrite an existing target.
What do I need installed before running a generated repo?Godot 4 (.NET build) for Godot, Rust/Cargo for Bevy, or Node.js 22.12+ with npm and Chrome/Chromium (hardware WebGL2) for Babylon.js, plus Python 3 with pip and either Claude Code or Codex installed.
Is it tested to work on any OS?It's explicitly tested only on Ubuntu, Debian, and macOS; there's no mention of native Windows support. Full generation runs can also take hours, so long unattended sessions usually need a server with SSH kept alive via tmux or screen.
Who is this for, and does it need a beefy machine?It's for developers comfortable running agentic coding tools who want a hands-off or semi-steered way to prototype games; a GPU instance is recommended for long runs since engine rendering and video capture are much faster with hardware acceleration.
What API keys do I need to generate assets?GOOGLE_API_KEY for Gemini image generation, XAI_API_KEY for xAI Grok image/video generation, and TRIPO3D_API_KEY for Tripo3D 3D model generation and rigged animation.
How does the agent prove the game actually works?It judges the running game rather than a clean compile — either a live URL/engine session you can watch and steer, or an unattended run that ends in a 15-20 second recorded proof clip, so visible bugs drive the next fix.
What's different about each supported engine?Godot 4 projects use C#/.NET with build-time scene generation and Jolt physics, Bevy projects are Rust with code-first ECS scenes and offscreen capture, and Babylon.js projects are TypeScript/Vite browser games served at a live URL.
Can I watch the agent work in real time or just get a result later?Both: you can watch the live game and steer it at decision points, or leave the run unattended and get a short proof recording when it's done — the agent reads how you frame the task to decide which mode to use.
Creator
htdt
Size
0.6 MB
Stars
7.4K
Updated
CommitOct 16
Age
9mo
Commits · 90 Days