Targets and link modes

Which target a package builds, how a dedicated server package differs, and when to ship a monolithic or a modular build.

Last updated Nov 2, 2026Edit this pageVersion 1.0.0

Two choices shape every package: which target you build, and how the engine is linked into it. The target decides which executable ships and what code it contains. The link mode decides whether the engine arrives as many libraries or inside one executable.

Targets

A target is a <Target>.Target.cs file that names a launch module, a target type and the definitions its build applies, as in Unreal's build tool. Modules and targets explains the file. The engine's targets that matter for shipping:

TargetTypeLaunch moduleWhat it addsPackaged by
MowoGameGameMowoGamenothingmbt package (default)
MowoServerServerMowoServerWITH_SERVER=1mbt package --target Server

A project created from a template carries its own targets in Source/: <Project>.Target.cs (type Game, launch module MowoGame, OutputName the project, the game module in ExtraModuleNames) and <Project>Editor.Target.cs Templates/TP_Coop/Source/TP_Coop.Target.cs. mbt package builds the game host through the project's own target: the only .Target.cs in Source/, or the one named after the .mproject when there are several. Without one it builds the engine's MowoGame target with the project's Source/ modules added. Either way the staged host is named after the product: Binaries/<platform>/<Product>.exe.

mbt package accepts --target Game (the default) and --target Server.

Warning

The installed editor build ships the engine prebuilt in the dev configuration, and mbt builds your game module in that configuration only. Packages made from it are therefore dev packages. A dedicated server package needs the Server target's own engine build, which the installed build does not include yet.

The dedicated server package

mbt package --target Server packages MowoServer, the headless dedicated server. It is a separate product with its own layout:

  • It builds the Server target, whose module set leaves the GPU backends and the scene renderer out.
  • It skips shader compilation and ships no shader archives, no engine content and no PSO cache.
  • The host is Binaries/<platform>/<Product>Server.exe behind a console launcher <Product>Server.exe at the package root.
  • It lands in Saved/Packaged/<Product>Server, beside the game package and never inside it. A configured outputDir gets the Server suffix too.
  • It keeps its content in named archives and a Manifest.txt at its root, because MowoServer mounts by name.
  • It ships no crash reporter and no VC++ redist fallback. Server fleets collect dumps and logs through their orchestrator.
  • Enabled plugins ship with it too, unless a plugin's manifest sets "server": false.
  • It stays modular unless you pass --monolithic.
PowerShell
./mbt.cmd package --project D:/Projects/MyGame/MyGame.mproject --target Server

The server listens on --port (7777 by default) and ticks at --tickrate (60 by default). The editor's packaging window does not build servers.

Monolithic and modular

MonolithicModular
Default forrelease and profile game packagesdebug, dev, debuggame, and every server package
Option--monolithic--modular
Engine codelinked into the host executableone DLL per module beside the host, named after the module (MowoEngine.Core.dll)
Your game modulelinked into the host executablea DLL, listed in the shipped Game.mproject
Engine feature modules (AI navigation, sequencer, destruction, …)linked into the hostDLLs the player loads by name
Enabled pluginscompiled into the host; only their vendor libraries shipone DLL per plugin module, named like the engine modules
Vendor libraries (SDL3, Steam, upscalers)ship beside the hostship beside the host
Crash reporterits own monolithic executableits own executable

The link mode resolves in this order: an explicit --monolithic or --modular, then a server package (modular), then monolithic in the project's Config/Packaging.ini, then the configuration: release and profile are monolithic, everything else modular. Passing both options is an error.

Monolithic mode defines MOWO_MONOLITHIC, builds every first-party library module as a static library and links it into the host, the model Unreal uses for its shipping builds. ThinLTO then optimizes across what would otherwise be dozens of DLL boundaries. Your project's C++ modules link the same way, with their whole archive forced in so their reflection registrations survive. The engine's feature modules, which the player loads by name in a modular build, are linked in too. Which plugins and feature modules go in is read from your project's Config/Plugins.ini, whether or not the project has C++ of its own, so a content-only game that enables SteamPlatform gets Steam in its executable.

Some third-party libraries ship in two editions: the Steam SDK and GameNetworkingSockets are both Valve's networking code. In a monolithic build they share one executable, so the engine keeps their symbols apart (see Transport and encryption); a library you add yourself must not define the same external names as one the engine links, or the linker silently keeps one of them.

Which one to pick

Ship monolithic. Choose modular for a test package you want to rebuild quickly, or when you need to swap one module's DLL.

In the editor, the Monolithic row of the packaging window passes --monolithic when it is enabled and --modular when it is disabled, so the row always decides.

The packaging window's profile with Release selected on the toolbar and the Monolithic row set to Enabled.

The import table check

A monolithic build that quietly kept a dynamic dependency on an engine DLL would pass on your machine and fail on a player's. So after staging, the packager reads the shipped host's PE import table. If it still imports a first-party DLL, or any DLL whose name starts with MowoEngine or the shared build environment's prefix, the package fails:

Text
Monolithic verification FAILED: MyGame.exe still imports first-party DLLs: MowoEngine.Core.dll
The engine did not link statically — rebuild without --skip-build.

The usual cause is --skip-build reusing a modular build. On success the log reports how many DLLs the executable imports, none of them first-party. The check runs when packaging on a Windows host.

Engine sources

This page describes behavior implemented in these files of the engine repository, checked against commit a6697f089.

  • Templates/TP_Coop/Source/TP_Coop.Target.cs

Page feedback

Was this page helpful?