Build configurations

What debug, debuggame, dev, profile and release change, which definitions they set, and which one to use for each job.

Last updated Oct 26, 2026Edit this pageVersion 1.0.0

A build configuration decides how the code is compiled: optimized or not, with asserts or without, with editor code or stripped for a player. mbt build takes it with -c (case-insensitive) and builds dev when you pass none. mbt package defaults to release.

At a glance

ConfigurationOptimizedEngine assertsEditor codeLink-time optimizationLive CodingTypical use
debugnoyesyesnoyesStepping through engine code
debuggameengine yes, game noyesyesnoyesStepping through your gameplay at playable speed
devyesyesyesnoyesDaily editor and game work, performance numbers with tools
profileyesnonoThinLTOnoProfiling the code a player runs
releaseyesnonoThinLTOnoWhat players receive

defines each property.

The names that came from Unreal Engine are gone. An old name fails with a message that names its replacement, for example 'Shipping' is no longer a configuration: use 'release':

Old nameNow
Developmentdev
Testprofile
Shippingrelease
Release (optimized, no asserts, editor included)removed; use dev

Which one to use

  • Working in the editor: dev. It is optimized and keeps every engine assert.
  • Debugging engine code: debug.
  • Debugging your game module: debuggame. The engine compiles as in dev; the game's own modules compile unoptimized, so you can step through gameplay without running the renderer at debug speed. A module can opt in or out with OptimizeCode in its rules.
  • Measuring performance with tools: dev.
  • Measuring the code a player runs: profile. It is the release code generation, with the log and the console's stat commands kept; GPU timers are available through r.GpuTimings.
  • Shipping a game: release, through mbt package.

The editor target builds in debug, debuggame and dev only; it is refused in profile and release.

Each configuration builds into its own folder, so switching configurations never overwrites another one's binaries.

Note

In the installed editor build the engine is prebuilt in one configuration, dev. Your modules always build in that configuration, and mbt corrects another -c with a log line.

Definitions every module sees

On top of a target's own definitions, every module of a build gets:

ConfigurationDefinitions
releaseMOWO_BUILD_RELEASE=1, WITH_EDITOR=0, MOWO_OPTIMIZED=1
profileMOWO_BUILD_RELEASE=1, MOWO_BUILD_PROFILE=1, WITH_EDITOR=0, MOWO_OPTIMIZED=1
devMOWO_BUILD_DEV=1, WITH_EDITOR=1, MOWO_WITH_ASSERTS=1, MOWO_OPTIMIZED=1
debuggameMOWO_BUILD_DEBUGGAME=1, WITH_EDITOR=1, MOWO_WITH_ASSERTS=1, MOWO_OPTIMIZED=1
debugMOWO_BUILD_DEBUG=1, WITH_EDITOR=1, MOWO_WITH_ASSERTS=1

Code that a player build must not contain tests MOWO_BUILD_RELEASE, which profile defines too; code that only the build players receive drops tests MOWO_BUILD_RELEASE && !MOWO_BUILD_PROFILE. The engine's MOWO_ASSERT and MOWO_CHECK_SLOW key on MOWO_WITH_ASSERTS, not on _DEBUG, so dev fires every engine invariant while compiling against the release C runtime.

WITH_EDITOR follows the configuration, not the target, because the game and editor targets build into one shared folder per configuration. If it followed the target, whichever was built last would leave every shared library compiled the other way. release and profile are where editor code comes out. No configuration defines a test switch: tests live only in the Test targets. A module named like a configuration is a rules error.

Symbols and the C runtime

Every configuration emits debug symbols, release included. They stay beside the binaries, and packaging never stages them, so the crash server can symbolicate a retail dump without a player ever receiving a symbol file.

Every configuration, debug included, compiles against the release dynamic C runtime, because the vendored third-party libraries exist only as release builds.

Optimized configurations other than debuggame build deterministically: the same source gives the same bytes, with no link timestamp and no build-machine path in the image. That keeps patches and store uploads small.

debug, debuggame and dev build modular: one shared library per module. release and profile game and server builds link monolithic by default: one executable with the engine linked in. A build whose link mode is not its configuration's default goes to its own folder, <config>-monolithic/ or <config>-modular/, so the two never overwrite each other. See Targets and link modes.

Profile-guided optimization

mbt package --pgo instrument builds release or profile binaries that write raw profiles when you run them; --pgo optimize merges those profiles into Engine/Build/PGO/<platform>/Engine.profdata and compiles with it, where <platform> is the platform id (win-x64, linux-x64, osx-arm64); an instrumented run writes its raw profiles to build/PGO/<platform>/Raw/. Record on the same machine that built the instrumented package, because the profile path is compiled in.

Page feedback

Was this page helpful?