Set up a Unity project with BMGD

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

When to Use This Guide

You’re starting a new Unity 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 Unreal or Godot — 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

Unity Hub and Unity 2022 LTS (or later) installed

Basic familiarity with Unity and C#

A game concept or idea you want to develop

Steps

Step 1: Create your Unity project

Open Unity Hub
Click New Project
Select the appropriate template for your game type:
- 2D → Core 2D
- 3D → 3D Core
- URP → Universal Render Pipeline (recommended for most games)
- HDRP → High Definition Render Pipeline (high-end visuals)
Name your project and choose a location
Click Create Project

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
Engine and framework choices
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 Unity project structure and systems.

/bmgd-create-architecture

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

Project structure (folders, naming conventions)
System architecture (game loop, input, physics, networking)
Unity-specific patterns (ScriptableObjects, events, object pooling)
Performance budgets and optimization strategy
Asset pipeline and build configuration

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 C# scripts
Follow Unity 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 Unity-specific patterns
`sprint-status.yaml`	Sprint tracking with stories and progress
`stories/`	Folder containing individual story files

Unity-Specific Considerations

Project Structure

BMGD recommends this Unity project structure:

Assets/
├── _Project/
│   ├── Scripts/
│   ├── Art/
│   ├── Audio/
│   └── Data/
├── Packages/
└── ProjectSettings/

ScriptableObjects

Use ScriptableObjects for game data — the Game Architect will include this in your architecture:

Game configuration
Character stats
Item definitions
Level data

Performance Budgets

Unity projects typically target:

60 FPS for most platforms
30 FPS for mobile (if targeting battery life)
120+ FPS for VR/high-refresh gaming

Your architecture.md will specify your targets.

Testing Setup

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

/bmgd-test-framework

This sets up Unity Test Framework with:

Edit Mode tests (logic without running the game)
Play Mode tests (gameplay systems)
Test assembly structure

Tips

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

Avoid: Don’t manually organize your Assets folder before running bmgd-create-architecture. Let the Game Architect define the structure first, then follow it consistently.

Remember: Unity projects can get large quickly. Use the architecture document to keep your project organized as it grows.

Common Mistakes

Mistake	Solution
Skipping project-context generation	Always generate `project-context.md` first — it guides all other workflows
Choosing the wrong Unity template	Consult the Game Architect if unsure — your engine choice affects architecture
Starting implementation before GDD	Complete the Design phase first — changes are cheaper before code is written
Ignoring sprint planning	Even solo projects benefit from story tracking — it keeps you focused on ship

Next Steps

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