Set up a Godot project with BMGD

Configure a new Godot project with BMGD workflows for full production game development.

When to Use This Guide

You’re starting a new Godot game project
You want to use BMGD’s Full Production workflow
You need formal documentation (GDD, architecture, sprint tracking)

When to Skip This

You just want to prototype quickly — use Quick Flow instead
You’re using Unity or Unreal — see the setup guides for those engines
You’re prototyping or doing a game jam — Quick Flow is faster

Prerequisites

Before starting:

BMad Method installed with BMGD module enabled

Godot 4.2+ (recommended) or Godot 3.x installed

Basic familiarity with Godot and GDScript

A game concept or idea you want to develop

Steps

Step 1: Create your Godot project

Open Godot Project Manager
Click New Project
Browse to your desired folder location
Choose a renderer:
- Forward+ — Modern PBR, best for 3D games
- Mobile — Optimized for mobile platforms
- Compatibility — GLES2, for older hardware
Name your project folder
Click Create & Edit

Step 2: Generate your project context

BMGD uses a project-context.md file to maintain consistency across all workflows.

In your BMad-enabled environment at the project root:

/bmgd-generate-project-context

This invokes the Game Architect (Cloud Dragonborn) to create a project-context.md file that includes:

Project name and description
Target platforms (PC, mobile, web)
Engine version and renderer choice
Performance budgets
Critical technical decisions

Step 3: Run the brainstorming workflow

Define your game concept with the Game Designer agent.

/bmgd-brainstorm-game

The Game Designer (Samus Shepard) will guide you through:

Selecting and combining brainstorming techniques
Generating and refining game ideas
Choosing a concept to develop

Step 4: Create your Game Brief

Capture your vision and positioning.

/bmgd-game-brief

The Game Designer creates game-brief.md with:

Game vision and elevator pitch
Target audience and market positioning
Platform and genre decisions
Competitive analysis
Art and audio direction

Step 5: Design your game (GDD)

Create a comprehensive Game Design Document.

/bmgd-create-gdd

The Game Designer helps you:

Select your game type from 24 available templates
Define core gameplay mechanics
Design progression systems
Plan levels and content
Specify art and audio requirements

Output: gdd.md

Step 6: Create your technical architecture

Plan your Godot project structure and systems.

/bmgd-create-architecture

The Game Architect (Cloud Dragonborn) creates architecture.md with:

Project structure (scenes, scripts, resources)
System architecture (game loop, nodes, signals, autoloads)
Godot-specific patterns (tree organization, resource management)
Performance budgets and optimization strategy
Export configurations and platform settings

Step 7: Plan your first sprint

Ready to start building? Use the Game Scrum Master to plan your work.

/bmgd-sprint-planning

The Game Scrum Master (Max) creates:

sprint-status.yaml — Your sprint tracking file
Stories from your GDD and Architecture
Sprint goals and definition of done

Step 8: Start implementing

Build features with the Game Developer agent.

/bmgd-dev-story [story-name]

The Game Developer (Link Freeman) helps you:

Implement story tasks with GDScript
Follow Godot best practices
Write tests for your features
Review code before marking complete

What You Get

After completing this setup, you’ll have:

File/Folder	Purpose
`project-context.md`	AI context for consistency across all BMGD workflows
`game-brief.md`	Your game’s vision and positioning
`gdd.md`	Complete game design document
`architecture.md`	Technical architecture and Godot-specific patterns
`sprint-status.yaml`	Sprint tracking with stories and progress
`stories/`	Folder containing individual story files

Godot-Specific Considerations

Project Structure

BMGD recommends this Godot project structure:

res://
├── scenes/
│   ├── levels/
│   ├── characters/
│   ├── ui/
│   └── components/
├── scripts/
│   ├── autoload/
│   └── utils/
├── assets/
│   ├── art/
│   ├── audio/
│   └── data/
└── project.godot

Scene Organization

Godot uses a tree of nodes. Your architecture should define:

Autoload Singletons — Global managers (game state, audio, saves)
Scene Composition — Reusable scenes (player, enemies, pickups)
Signal Patterns — Decoupled communication between nodes

The Game Architect will specify these patterns in your architecture.md.

Performance Budgets

Godot projects typically target:

60 FPS for most games
30 FPS for mobile with heavy computation
144+ FPS for competitive games

Your architecture.md will specify frame time budgets.

Testing Setup

For Godot automated testing, the Game QA agent (GLaDOS) can help:

/bmgd-test-framework

This sets up GUT (Godot Unit Test) with:

Unit tests (script logic without scenes)
Integration tests (scene interactions)
Test fixtures and test doubles

Tips

Best Practice: Always run bmgd-generate-project-context after creating a new Godot project. The project-context.md file is the “single source of truth” that all BMGD agents reference.

Avoid: Don’t create deeply nested scene trees. Godot’s scene system encourages composition — prefer many small scenes over one large scene.

Remember: Godot uses GDScript (Python-like) by default. Your architecture should specify if you’re using C# or GDScript — both are supported but have different workflows.

Common Mistakes

Mistake	Solution
Skipping project-context generation	Always generate `project-context.md` first — it guides all other workflows
Creating monolithic scenes	Break your game into reusable scene components — the Game Architect can help design this
Not using autoloads properly	Keep autoloads minimal — only use for true singletons (game state, save system)
Mixing GDScript and C# arbitrarily	Choose one primary language and stick with it — mixing adds complexity without benefit

Next Steps

Quick Flow vs Full Production — Understand both development approaches
Set up Unity with BMGD — If you’re considering Unity instead
Run sprint planning — When you’re ready to start building
Agents Reference — Learn about all 6 BMGD agents