Project files

The .mproject manifest, the project folder layout, the configuration files under Config/ and how the INI layers combine.

Last updated Nov 2, 2026Edit this pageVersion 1.0.0

A project is a folder with a .mproject manifest. The layout follows Unreal's: Content/, Config/, Source/ and Plugins/ are the project and go into version control; Saved/ and Intermediate/ are per machine and are ignored.

Folder layout

Text
MyGame/
  MyGame.mproject        JSON manifest
  Content/               assets: levels, meshes, textures, materials, audio, Visual Scripting graphs
  Config/                project configuration (INI)
  Source/                the game module and MyGame.Target.cs
  Plugins/               project plugins
  Saved/                 per user, not committed
    Logs/  Crashes/  Autosaves/  SaveGames/
    Config/Editor/       editor layout, viewport and other per-user state
    Config/<Platform>/   the user layer of the INI configs
    Cooked/              cook output
    Packaged/            package output
  Intermediate/          disposable, not committed
    AssetRegistry.mdfb   the asset index, rebuilt when missing
    DerivedDataCache/  ThumbCache/  CookedAssets/

FProjectLayout owns every one of these names; code never spells them itself. FProjectLayout The rule is: Intermediate/ nobody opens, Saved/ only its own user opens, and everything else the team commits. A package lives under Saved/ because a person hands it to someone, even though it can be rebuilt.

A new project's .gitignore keeps the transient folders out of version control: Intermediate/, Saved/, and the build/ and .mbt-cache/ folders a project that is its own build root writes.

The .mproject manifest

The manifest is JSON, read by the project serializer. Sections and keys:

KeyMeaning
project.name, project.versionThe project's name and version
project.uuidThe project's identity
project.engineVersionThe engine version the project was made with
project.engineAssociationOptional: which installed engine opens the project, a release version or a source tree's id
project.startSceneThe level the game opens, as a Content/ path
project.gameModeClassThe MCLASS name of the game mode spawned at scene start
project.assetFormatThe asset package format version
project.created, project.modifiedISO 8601 timestamps
build.outputName, build.packAssetsThe packaged executable name; whether content is packed into an archive
graphics.defaultWidth, defaultHeight, defaultFullscreen, defaultVSync, resizableThe game window's defaults
player.productName, companyName, copyright, description, iconPathWhat the packaged executable reports
platform.steamEnabled, discordEnabled, mowoOnlineEnabled, mowoProductId, …Online platform settings, read by the platform plugins
layers.namesThe 32 named collision and render layers
MyGame.mproject
{
  "project": {
    "name": "MyGame",
    "version": "1.0.0",
    "engineVersion": "1.0.0",
    "startScene": "Content/Scenes/Main.mmap",
    "gameModeClass": ""
  },
  "graphics": {
    "defaultWidth": 1920,
    "defaultHeight": 1080,
    "defaultFullscreen": true
  }
}

The engine you are reading about is version 1.0.0.

The Plugin manifest (.mplugin) is the other JSON file a project carries.

Configuration files

Configuration is INI in Unreal's dialect. Every file name under Config/ is PascalCase:

FileHolds
Engine.ini, DefaultEngine.iniEngine settings: rendering, the graphics backend, console variables, logging
DefaultGame.iniGame settings and class sections
Plugins.iniWhich plugins the project enables
Input.iniInput contexts and actions
Packaging.iniThe committed half of the packaging settings: target platforms, output folders, options
Redirects.iniRenamed properties, classes and asset paths ([CoreRedirects])
DefaultCrypto.iniThe archive encryption and signing keys a release package needs
DefaultScalability.iniPer-level settings of the scalability groups

A project made by an older engine is adopted when it opens: old file spellings are renamed, and legacy MDF configs are converted to INI with the original moved to Saved/MigratedSources/Config/.

Layers

For a base name such as Engine, layers combine from lowest to highest:

LayerFile
EngineEngine/Config/Base<Name>.ini
Engine, per platformEngine/Config/<Platform>/<Platform><Name>.ini
ProjectConfig/Default<Name>.ini
Project, per platformConfig/<Platform>/<Platform><Name>.ini
UserSaved/Config/<Platform>/<Name>.ini

<Platform> is the platform id: win-x64, linux-x64 or osx-arm64. A layer that does not exist is skipped. The project's Config/Engine.ini is read beneath the Engine hierarchy, so DefaultEngine.ini wins over it. Engine/Source/Runtime/Core/Public/Core/ConfigIni.h

Syntax

INI
[Section]
Key=Value
+List=AppendedValue
.List=AppendedEvenIfPresent
-List=RemovedValue
!List=

Key=Value replaces what lower layers set. +Key= appends unless already present, .Key= always appends, -Key= removes that value and !Key= clears the key. Lines starting with ; or # are comments. Values are typed by spelling: True/False, integers, floats, (X=,Y=,Z=) vectors; a quoted value is always text. Nested data uses Unreal's struct form, +Rows=(Key="text",Number=1).

Console variables

Config/DefaultEngine.ini
[ConsoleVariables]
r.VSync=0
mowo.GC.IntervalSeconds=10

[ScalabilityGroups]
sg.ShadowQuality=3

[ConsoleVariables] sets console variables by their full name, and [ScalabilityGroups] sets the sg.* groups. A pinned group level also applies the [<Group>@<Level>] section of the Scalability hierarchy (for example [ShadowQuality@3]). The command line wins over both. See the console variable reference.

Class sections

A section named [/Script/<Module>.<Class>] sets the MPROPERTY(Config) fields of that class, named without its M or A prefix. Super-class sections apply first. Fields without Config are never written, whatever the file says. Bool, integer, float, double, string and string-list fields are supported. FConfigClassBinder

C++
MCLASS()
class MHealthComponent : public MActorComponent {
	MGENERATED_BODY()

	MPROPERTY(EditAnywhere, Config)
	float maxHealth = 100.0f;
};
Config/DefaultGame.ini
[/Script/Mowo.HealthComponent]
maxHealth=250

When a project opens, the Engine hierarchy and then the Game hierarchy are applied to the class default object of every class with a Config field, so a Game section wins. Spawned objects start from the class default, so the value reaches every instance that does not override it. Classes from modules loaded later (the game module, a plugin, a hot reload) get the same pass when they load.

Plugins.ini

Config/Plugins.ini
[enabled]
Combat=True
SteamPlatform=False

See Writing a plugin.

Migrating an old project

Projects from before the Content/, Saved/, Intermediate/ layout (an Assets/ folder, a hidden .mowo/ folder) are migrated when they open: folders move and every serialized Assets/ reference is rewritten to Content/. To migrate without opening the editor, or to refuse:

Shell
MowoGame.exe --migrate-project=MyGame.mproject
MowoEditor.exe --project MyGame.mproject --no-migrate

--no-migrate refuses to open a project that needs migration, so you can back it up first. Migration never overwrites an existing folder and can be run again safely.

Engine sources

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

  • Engine/Source/Runtime/Core/Public/Core/ProjectLayout.h
  • Engine/Source/Runtime/Core/Public/Core/ConfigIni.h
  • Engine/Source/Runtime/Project/Public/Project/Project.h
  • Engine/Source/Runtime/Project/Public/Project/EngineRegistry.h
  • Samples/SampleProject/SampleProject.mproject
  • Samples/SampleProject/Config/Plugins.ini

Page feedback

Was this page helpful?