This file provides guidance to WARP (warp.dev) when working with code in this repository.

GDevelop is a full-featured, no-code, open-source game development software for creating 2D, 3D and multiplayer games. The codebase consists of:

- **Core** (C++): Game structure and IDE manipulation tools

- **GDJS** (TypeScript): The game engine using PixiJS and Three.js

- **GDevelop.js**: WebAssembly bindings of Core/GDJS/Extensions to JavaScript

- **newIDE** (React/Electron): The game editor application

- **Extensions**: Objects, behaviors, and features for the game engine

- **IDE/Editor**: Code that runs in the GDevelop editor (not in games)

- **Runtime**: Code that runs during a game (the game engine)

- Extensions have both IDE declarations (in `JsExtension.js`) and Runtime implementations (in TypeScript files)

- For example: `gd::Variable` (IDE, in Core) vs `gdjs.Variable` (Runtime, in GDJS)

- `Core/GDCore/Project/`: Classes describing game structure (Project, Scene, Object, Behavior, Events)

- `Core/GDCore/IDE/`: Tools for manipulating projects (refactoring, search, etc.)

- `GDJS/Runtime/`: Game engine (TypeScript)

- `GDJS/GDJS/`: C++ IDE part (exporters, code generation from events)

- `GDevelop.js/Bindings/Bindings.idl`: Interface definition for C++ to JavaScript bridge

- `newIDE/app/`: React-based editor application

- `Extensions/`: Built-in extensions (not part of Core)

- Events are NOT executed at runtime - they are transpiled to JavaScript/TypeScript code

- Code generation happens in `GDJS/GDJS/Events/CodeGeneration/`

- A `gd::Instruction` is essentially a function call with parameters

- StandardEvent contains conditions (filters) and actions

git clone https://github.com/4ian/GDevelop.git

cd GDevelop/newIDE/app

npm install # or yarn

cd newIDE/app

npm start

cd newIDE/app

npm start

cd newIDE/electron-app

npm install

npm start

cd GDJS

npm install

npm run build

npm run build # Production build (minified)

npm run build -- --debug # Debug build (no minification)

npm run build -- --out=/path/to/output # Custom output path

npm run check-types

npm run format

npm run check-format

cd GDJS/tests

npm install

npm run test # Single run with Chrome Headless

npm run test:watch # Watch mode

npm run test-benchmark:watch # With benchmarks

npm run test:firefox:watch # Using Firefox

cd newIDE/app

npm test

npm run flow

npm run format

npm run check-format

npm run storybook # Opens on http://localhost:9009

npm run extract-all-translations

npm run compile-translations

**Note**: Only needed if modifying C++ code in Core, GDJS Platform, or Extensions.

git clone https://github.com/emscripten-core/emsdk/

cd emsdk

./emsdk install 3.1.21

./emsdk activate 3.1.21

source ./emsdk_env.sh # Linux/macOS

cd GDevelop.js

npm install

npm run build

npm run build -- --variant=dev # Faster linking for development

npm run build -- --variant=debug # With debugging information

npm run build -- --variant=debug-assertions # With memory checks

npm run build -- --variant=debug-sanitizers # With sanitizers (very slow)

npm test

cd newIDE/app/scripts

node import-GDJS-Runtime.js

cd newIDE/app

npm run reload-extensions

Extension files are in `Extensions/[ExtensionName]/`:

- `JsExtension.js`: IDE declaration (actions, conditions, expressions, properties)

- `*runtimeobject.ts`: Runtime object implementation

- `*runtimebehavior.ts`: Runtime behavior implementation

- `*tools.ts`: Runtime functions for actions/conditions

- `*-pixi-renderer.ts`: PixiJS renderer for objects

- `*.spec.js`: Tests for the extension

After editing extension files:

1. If you modified `JsExtension.js`: Reload IDE with Ctrl+R (Cmd+R on macOS)

2. If you modified Runtime files: Relaunch a game preview

3. Always check the developer console for errors

- Use Prettier for formatting (already configured)

- IDE uses Flow for type checking

- Game engine uses TypeScript

- Modern JavaScript features are supported (see newIDE/docs/)

- C++11 standard (consider upgrading to C++17)

- Use clang-format with Google style: `{BasedOnStyle: Google, BinPackParameters: false, BinPackArguments: false}`

- Configuration in `.clang_format` and `.clang-tidy`

- Prettier - Code formatter

- ESLint

- Flow Language Support

- clang-format

- Located in `GDJS/tests/` for core engine

- Located alongside extensions in `Extensions/[ExtensionName]/tests/`

- Run with Karma using Chrome Headless (or Firefox)

- Include benchmarks with `--enableBenchmarks` flag

- Use Jest (via react-scripts)

- Run with `npm test` in `newIDE/app`

- Coverage: `npm run analyze-test-coverage`

Individual extension tests run as part of the GDJS test suite.

- `Bindings.idl` defines what C++ is exposed to JavaScript

- 90% of the time, editing `Bindings.idl` is sufficient

- May need to add header files to `Wrapper.cpp` for new C++ classes

- Compiled with CMake using Emscripten

When IDE starts, it automatically:

- Downloads or copies libGD.js (if not building locally)

- Imports GDJS Runtime

- Imports extensions

- Imports external editors (Piskel, JFXR, Yarn)

- Builds theme resources

Manual resource import:

cd newIDE/app

npm run import-resources

To test Google Drive, Dropbox, OneDrive in development:

1. Add to `/etc/hosts`: `127.0.0.1 gdevelop-app-local.com`

2. Access IDE at `http://gdevelop-app-local.com:3000`

- IDE: Changes auto-reload when running `npm start`

- Game Engine: Auto-rebuilds when files change (watch console)

- Extensions: Auto-imported when IDE is running in development

- IDE: Uses react-scripts with react-app-rewired for customization

- Game Engine: Uses esbuild (fast builds) + TypeScript for type checking

- C++ parts: CMake build system

- Desktop app: Electron Builder

Builds run on:

- **CircleCI**: macOS and Linux builds

- **AppVeyor**: Windows builds

- **Semaphore**: Fast tests

Artifacts uploaded to S3 at `s3://gdevelop-releases/[branch]/[commit|latest]/`

- Core C++ Documentation: https://docs.gdevelop.io/GDCore%20Documentation/

- GDJS Runtime Documentation: https://docs.gdevelop.io/GDJS%20Runtime%20Documentation/

- Architecture Overview: `Core/GDevelop-Architecture-Overview.md`

- IDE README: `newIDE/README.md`

- GDJS README: `GDJS/README.md`

- Extensions Guide: `newIDE/README-extensions.md`

- Themes Guide: `newIDE/README-themes.md`

1. Edit `Extensions/[ExtensionName]/JsExtension.js` to declare it

2. Implement the function in `Extensions/[ExtensionName]/*tools.ts`

3. Reload IDE (Ctrl+R) and test in a preview

1. Create `*runtimebehavior.ts` extending `gdjs.RuntimeBehavior`

2. Declare in `JsExtension.js` using `addBehavior`

3. Implement `doStepPreEvents`/`doStepPostEvents` for logic

1. Create `*runtimeobject.ts` extending `gdjs.RuntimeObject`

2. Create `*-pixi-renderer.ts` for the renderer

3. Declare in `JsExtension.js` using `addObject`

1. Make changes to C++ files in `Core/`

2. Add to `Bindings.idl` if exposing to JavaScript

3. Rebuild GDevelop.js with Emscripten

4. Test in IDE

cd GDJS/tests

npm run test:watch # Then use Karma's filtering

cd newIDE/app

npm test -- --testPathPattern=YourTest.spec.js

- GDJS uses esbuild for near-instant builds during development

- Type checking is separate and slower - run periodically

- Use `--max-old-space-size=7168` for Node.js when building IDE

- Build times: GDJS ~seconds, GDevelop.js ~minutes, Full IDE build ~minutes

To create async actions:

1. Make your function return a `gdjs.AsyncTask`

2. Use `gdjs.PromiseTask` for promises: `return new gdjs.PromiseTask(yourPromise)`

3. Declare with `setAsyncFunctionName()` instead of `setFunctionName()`

4. Only actions can be asynchronous (not conditions or expressions)