GDevelop

GDevelop is a full-featured, open-source game engine built for creators of all backgrounds who want to make 2D, 3D, and multiplayer games without writing code. Its event-based visual scripting system lets you express game logic by combining drag-and-drop conditions and actions, which are then compiled to optimized JavaScript at export time — delivering runtime performance without requiring programming knowledge.

The engine targets every major platform from a single project: export to HTML5 for web browsers, iOS and Android for mobile, and Windows, macOS and Linux for desktop via Electron and WebAssembly builds. Physics is handled by Box2D (2D) and Jolt Physics (3D), both running as WebAssembly modules, while PixiJS and Three.js provide hardware-accelerated 2D and 3D rendering respectively.

GDevelop’s ecosystem has matured to include an official Asset Store where creators can sell or download game templates, sprites, and sounds; AI-assisted development tools for generating objects and events from natural language prompts; built-in online services for leaderboards, multiplayer lobbies, and publishing; and a rich extension system used by thousands of community contributors. Games built with GDevelop have reached Steam, the App Store, Google Play, and major web platforms like Poki and CrazyGames.

With nearly 24,000 GitHub stars, weekly releases, and a dedicated Discord and forum community, GDevelop is one of the most actively developed open-source game engines available — equally suited to first-time developers and professional indie studios.

What You Get

• Event-based visual scripting - Author game logic through drag-and-drop condition/action events that the engine compiles to JavaScript at export, so no-code authoring produces code that runs at native speed without an interpreter.
• 2D and 3D rendering - Build 2D games powered by PixiJS (WebGL) with sprites, particles, and lighting, or switch to 3D scenes rendered with Three.js — both within the same project and editor workflow.
• Multiplayer and online services - Add real-time multiplayer through built-in networking extensions with lobby management, and connect to hosted leaderboards, player authentication, and analytics without standing up your own backend.
• AI-assisted game creation - Use in-editor AI tools to describe an object or behavior in plain language and have the engine generate matching events, assets, or logic, accelerating prototyping from concept to playable prototype.
• One-click cross-platform export - Publish the same project to HTML5, iOS, Android, Windows, macOS, Linux, Steam, Itch.io, Poki, and CrazyGames through configured export wizards that handle packaging and metadata automatically.
• Extensible behavior and object system - Extend any game with official or community extensions — JavaScript modules that self-declare their actions, conditions, and expressions in structured manifests consumed by the IDE for autocomplete, type-checking, and UI generation.
• Asset Store and template marketplace - Browse and import free or paid game templates, sprite packs, sound libraries, and ready-made custom objects (prefabs) directly from inside the editor, including volume controls, game-over dialogs, and physics objects.
• Professional debugging and diagnostics - Use the live Debugger, Diagnostic Report (F7), hot-reload preview over network, and an in-game performance profiler to identify logic errors, broken events, and performance bottlenecks without leaving the editor.

Common Use Cases

• Indie mobile game development - Solo developers and small studios use GDevelop to ship 2D mobile titles like Uphill Climb Racing Neon and Vai Juliette! to iOS and Android, using the event system to build AI paths, scoring, and level progression without a dedicated programmer.
• Game design education - Schools, bootcamps, and online educators use GDevelop’s no-code interface and in-app tutorials to teach students the fundamentals of game logic, physics, and storytelling without requiring any programming prerequisites.
• Branded promotional games - Studios like Prime Video have used GDevelop to build official tie-in games for properties including The Boys and Invincible, leveraging fast prototyping and web export to ship polished browser games on tight marketing timelines.
• Steam commercial game publishing - Solo creators building commercial games like Katuba’s Poacher and A Death in the Red Light use GDevelop to handle the complete pipeline from prototype to Steam release, relying on the engine’s export wizard and platform-specific asset configuration to package and submit without custom tooling.
• Browser game platforms - Developers targeting Poki, CrazyGames, or Newgrounds use GDevelop’s HTML5 export and built-in monetization integrations to publish ad-supported browser games, reaching millions of players without a native app distribution strategy.

Under The Hood

Architecture GDevelop employs a deeply layered, component-separated architecture where three independent tiers operate with strict isolation: a C++ core library compiled to WebAssembly (GDCore) that describes the structure of a project and all its events, behaviors, and objects; a TypeScript game engine runtime (GDJS) that executes the final game; and a JavaScript/React IDE frontend (newIDE) that authors and exports projects. The defining constraint is that editor-side classes explicitly know nothing about their runtime counterparts — a project-level Variable and a runtime Variable are entirely separate classes — enforcing unidirectional data flow from structured description through code generation to executable logic. Event-based game logic is transpiled at export time rather than interpreted at runtime, producing actual JavaScript from visual drag-and-drop event trees, eliminating interpreter overhead. Extensions follow the same dual-layer pattern, with a JsExtension.js declaration for the IDE and separate runtime behavior or object files, enabling community extensions to self-register without modifying core code.

Tech Stack The IDE is a React plus Material-UI single-page application written in Flow-typed JavaScript, packaged as an Electron desktop app and also deployable as a web app. The game engine runtime (GDJS) is written entirely in TypeScript and rendered via PixiJS v7 (WebGL) for 2D and Three.js for 3D. Core project manipulation logic is implemented in C++ and compiled to WebAssembly with Emscripten, providing high-performance event code generation and whole-project refactoring without native binaries at runtime. Physics simulations run Box2D for 2D and Jolt Physics for 3D, both as WebAssembly modules. Build tooling includes CMake for C++ compilation, esbuild for fast GDJS runtime bundling, and standard npm scripts throughout. Continuous integration runs on CircleCI for macOS and Linux, Appveyor for Windows, and Semaphore CI for fast JavaScript tests. Localization is managed through Crowdin integration covering both the IDE and extension strings.

Code Quality Test coverage spans multiple layers: Mocha with Node.js for game engine unit tests in GDJS, Jest for IDE components and utilities, Catch2 for C++ core tests, and spec files distributed across Extensions, GDJS Runtime, and the IDE source tree. The project uses Flow for type checking throughout the IDE layer and TypeScript in the game engine runtime, providing meaningful type safety across both tiers. Code naming follows consistent conventions — the gdjs.* namespace for runtime objects and gd:: for C++ core classes — with clearly separated directory trees that enforce the IDE/Runtime distinction. Prettier is configured with explicit format checks in CI for TypeScript, JavaScript, and extension files. Error handling varies across extensions, and the coexistence of Flow and TypeScript across layers introduces occasional friction for contributors, but overall the project demonstrates solid discipline for a large open-source codebase maintained by a distributed team.

What Makes It Unique GDevelop’s most distinctive technical achievement is its compile-time event transpiler: visual drag-and-drop event trees are statically analyzed and compiled to plain JavaScript at export time rather than interpreted during gameplay, delivering near-native performance while preserving a fully no-code authoring experience — a combination that most visual scripting systems do not achieve. The WholeProjectRefactorer provides dependency-aware, project-wide safe renaming and refactoring across visual events, a capability typically found only in IDE toolchains for statically typed languages. The metadata-driven extension registry allows any third-party extension to self-declare its conditions, actions, and expressions in structured manifests, which the IDE then consumes to automatically generate UI components, type-checking constraints, and expression autocomplete without any hardcoded knowledge of the extension — making the system genuinely open-ended. The combination of this metadata system with a context-aware live expression parser that offers in-editor autocomplete and type inference for formula expressions creates a cohesive developer experience that bridges accessibility with the power expected by professional creators.

Self-Hosting

GDevelop’s engine, IDE, and all built-in extensions are licensed under the MIT License, one of the most permissive open-source licenses available. This means you can use GDevelop freely for any purpose — commercial game development, educational tools, or internal projects — modify the source code without restriction, and distribute or sell games built with it without any royalty obligations or requirement to open-source your own game code. The only protected element is the GDevelop name and logo, which are the exclusive property of the project’s creator, Florian Rival; the underlying software itself carries no such restriction.

Self-hosting GDevelop means compiling and running the IDE yourself, which is a non-trivial undertaking. The editor depends on a precompiled libGD.js WebAssembly binary (the GDevelop.js layer bridging C++ core to JavaScript), which must either be downloaded from the project’s CI artifacts or built from source using Emscripten and CMake — a process requiring a specific toolchain that can take hours on first run. Once compiled, the IDE runs as a Node.js/React web application you can serve locally or deploy on any static host, and the Electron desktop app requires additional packaging steps for distribution. There is no official Docker image or one-click self-hosted server; running your own build is a developer-level task, not a point-and-click deployment.

The hosted gdevelop.io service adds convenience layers not present in the open-source build: managed cloud project storage, one-click publishing to the gd.games platform, integrated asset store billing, AI assistant credits, leaderboard and multiplayer backend services, and subscription-gated features like unlimited cloud builds and advanced online services. Self-hosting the IDE preserves local game authoring and manual export pipelines but loses access to these hosted backends unless you build or substitute equivalent services yourself. For teams needing the full platform including multiplayer lobbies, hosted leaderboards, and AI generation, the official managed tier is the practical path.