GB Studio

GB Studio is a cross-platform desktop application for creating authentic Game Boy games using a visual, drag-and-drop interface. Built on Electron with a bundled GBDK C engine and custom GBVM virtual machine, it lets complete beginners build working ROM files playable on real hardware or emulators — no programming experience needed.

Beyond the visual editor, GB Studio exposes the full power of its underlying engine through a JavaScript plugin system, a CLI tool for CI/CD pipelines, and direct GBVM scripting for developers who want precise hardware control. The application ships with a built-in chiptune music editor supporting both piano-roll and tracker interfaces, a sprite animation editor, a color palette system for Game Boy Color projects, and an integrated emulator for instant preview.

Projects can be exported as native Game Boy ROM files (.gb), web-playable HTML5 builds with mobile touch controls, or .pocket files for the Analogue Pocket handheld. GB Studio has been used to ship commercial games on physical cartridges through publishers like Incube8, and has been used by brands including McDonald’s and Nike for nostalgic promotional microgames.

The project is actively maintained by creator Chris Maltby with contributions from a global community of over 68 developers, and has shipped regular major releases since 2019 — reaching v4.3 in June 2026 with features like a plugin manager, platformer physics improvements, and Linux ARM64 support.

What You Get

• Visual Scripting Engine - A drag-and-drop event system with over 150 distinct event types covering actor movement, dialogue, camera control, variables, math, collisions, and scene transitions — all compiling down to GBVM bytecode without touching code.
• Native ROM Compiler - Compiles your project to a real .gb ROM file using GBDK-2020, playable on actual Game Boy hardware, flash cartridges, or any emulator. ROM size is tracked live in the build panel.
• Web & Pocket Export - Builds an HTML5 web version with optimized mobile touch controls for publishing on Itch.io, and generates .pocket files for the Analogue Pocket handheld.
• Built-in Chiptune Music Editor - Compose Game Boy music using both a piano-roll interface and a tracker view, with support for importing and exporting tracks from external tools like hUGETracker and FX Hammer.
• Sprite & Tilemap Editors - Full sprite animation editor with multi-state support, and a tilemap painter for background scenes — both supporting Game Boy Color palettes and monochrome modes.
• Plugin Manager - Install community plugins directly from the official plugin repository, or author your own using JavaScript to add new script events, scene types, themes, and localization without modifying core code.
• GB Studio CLI - A command-line tool (gb-studio-cli) for automating ROM, web, and Pocket builds from project files, enabling integration with CI/CD pipelines and headless build servers.
• Integrated Debugger - A visual in-editor debugger that shows variable state, event triggers, and VRAM contents during gameplay, with a GBVM script editor for developers who want direct bytecode control.

Common Use Cases

• Independent Game Boy game development - Indie developers use GB Studio to build and release full commercial titles on physical cartridges through publishers like Incube8, reaching audiences who collect Game Boy games.
• Retro game jams - Teams build complete playable Game Boy games within 48-72 hour jam windows, leveraging GB Studio’s rapid scene setup, template projects, and instant in-editor emulation preview.
• Creative coding education - Teachers and educators introduce students to game logic, storytelling, and pixel art through GB Studio’s visual scripting, using it as a gentler on-ramp to programming concepts than text-based environments.
• Branded promotional microgames - Marketing teams at companies like McDonald’s and Nike commission simple, nostalgic Game Boy games as interactive marketing content, using GB Studio’s web export to publish them on landing pages.
• Retro hardware experimentation - Hardware enthusiasts use GB Studio to create and flash custom ROMs onto blank Game Boy cartridges, exploring the constraints and aesthetics of original 1989 Game Boy hardware.
• Accessible game prototyping - Game designers without programming backgrounds use GB Studio to prototype game mechanics and narratives as working ROM demos before committing to a full production stack.

Under The Hood

Architecture GB Studio follows a clear process-separated desktop architecture built on Electron, with the main process handling project I/O, ROM compilation, and native system integration, while the renderer process runs a full React 18 + Redux Toolkit application for the editor UI. State management is handled through a carefully partitioned Redux store with domain-specific slices for entities, editor state, music, debugger, clipboard, and settings, with redux-undo applied selectively to entity and tracker state. The compilation pipeline is isolated as a separate worker that takes project resources, runs them through a multi-stage compiler — precompilation, entity event compilation, data assembly, and GBDK invocation — and emits ROM bytes without blocking the UI. Script events each live as independent handler modules that register a compile function, a label function for UI display, and a field schema, making the system deeply extensible without touching core compiler code.

Tech Stack The editor is an Electron application written in TypeScript (85% of the codebase) with React 18 for UI components, Redux Toolkit for state, and Webpack via Electron Forge for packaging across Mac, Windows, and Linux (including ARM64). The game engine side uses GBDK-2020 (a C compiler targeting the Game Boy’s Sharp LR35902 CPU) combined with a custom GBVM bytecode virtual machine written in C and Assembly that runs the visual scripts at runtime. Music editing uses a bundled web app (gbs-music-web) and integrates with hUGETracker and FX Hammer formats. Plugin sandbox execution migrated from the discontinued vm2 to QuickJS via Emscripten (quickjs-emscripten), providing a safe, embeddable JS runtime for third-party plugin code. TypeBox provides runtime schema validation, and the build pipeline uses Jest with Storybook for component documentation and Knip for dead code detection.

Code Quality The codebase operates under strict TypeScript with noImplicitOverride enabled, and the compiler subsystem uses well-defined interface contracts between the ScriptBuilder, precompile, and GBVM code generation layers. Tests are comprehensive across the event handler layer — each of the 150+ script event modules has dedicated test files exercising compile output with mock builder interfaces — while higher-level integration tests cover data serialization, migration, and resource patching. Comment density in the compilation core is moderate, with clear function-level documentation but limited inline explanation of hardware-specific magic numbers. Error handling in the build pipeline surfaces as progress callbacks rather than typed error objects, which means build failures are communicated through log strings rather than structured diagnostics.

What Makes It Unique GB Studio’s core innovation is encoding the Game Boy’s hardware constraints directly into the editor’s affordances — VRAM tile limits, actor count limits, ROM bank boundaries, and audio channel constraints are surfaced as live warnings in the UI rather than discovered at compile time. The declarative event scripting system generates GBVM bytecode through a registered compile function per event type, meaning new events can be added as self-contained modules without changes to the core compiler. The GBVM itself is a custom stack-based virtual machine running on actual Game Boy hardware at runtime, bridging the visual scripting layer to native Z80-family assembly execution — a design that allows complex multi-threaded game scripts while respecting the constraints of a 4 MHz CPU with 8 KB of RAM.

Self-Hosting

GB Studio is released under the MIT License, which grants unlimited freedom to use, modify, distribute, and commercialize both the tool itself and any games created with it. You can sell ROM files, physical cartridges, or web builds of games made in GB Studio without any royalty, attribution requirement, or license compliance burden. The MIT terms apply only to GB Studio’s own source code — your game assets and project files are entirely your own.

Running GB Studio yourself means installing an Electron desktop application on Mac, Windows, or Linux. The application bundles GBDK-2020, GBVM, and all required build tooling, so there is no separate toolchain to configure for standard ROM output. The CLI tool (gb-studio-cli) adds the ability to run headless builds in CI environments, and the plugin system uses a sandboxed QuickJS runtime for third-party code. There are no server-side components, databases, or infrastructure requirements — projects are local files in a .gbsproj directory. Updates are manual application downloads unless you run from source.

There is no hosted or SaaS version of GB Studio, no managed cloud tier, and no commercial enterprise offering. The project is funded through the creator’s Patreon and community contributions. Support is through GitHub Issues, a Discord server, and community forums — there are no paid support contracts or SLAs. This means that operational decisions (upgrades, plugin vetting, build environment maintenance) rest entirely with you, and there is no vendor to escalate to if a specific hardware compatibility edge case or compiler bug affects your project.