Core concepts

The mental model behind Mowo: modules and targets, the object model, reflection, actors over an ECS, data files, Visual Scripting and Arc UI.

Last updated Oct 26, 2026Edit this pageVersion 1.0.0

Mowo borrows its shape from Unreal Engine 5, so most UE knowledge carries over. This page gives you the handful of ideas the rest of the documentation builds on. Each section is short and points to where the topic goes deeper.

Modules and targets

The engine is a set of modules, each a shared library with a <Module>.Build.cs file that tells mbt how to compile it. The engine's modules come prebuilt with the editor; the API reference covers the 43 that game code and editor extensions program against. A module's category says where it may go: Runtime modules can ship in a game, Editor modules never reach one.

A target (<Name>.Target.cs) is a program you can launch: the editor MowoEditor, the player MowoGame, the dedicated server MowoServer and the Project Launcher.

Your game is one more module: a shared library in your project's Source/ folder, plus a target named after your project. Optional features games opt into, such as Steam or the Combat kit, are plugins, enabled per project in Config/Plugins.ini. The engine ships 7 plugins.

Read more in Build tool and Programming.

MObject and garbage collection

MObject MObject is the root of the managed object model, Mowo's UObject. An object has a name, an outer (its owner) and an MClass MClass descriptor, and it registers in a process-wide object array when it is created. A mark-and-sweep collector starts from a set of roots and keeps every object reachable through the outer chain and through reflected MPROPERTY pointers. Everything else is reclaimed. The collector can run incrementally, spread across frames Engine/Source/Runtime/Core/Public/Core/FMObjectArray.h.

Hold object references with the smart pointers in Core/TObjectPtr.h: TObjectPtr<T> TObjectPtr for reflected properties, TWeakObjectPtr<T> TWeakObjectPtr for references that must not keep the target alive.

Warning

Never store a raw T* to an MObject in an MPROPERTY. The incremental collector sees stores through TObjectPtr's write barrier; a raw pointer written while it is marking can hide a live object from it Engine/Source/Runtime/Core/Public/Core/TObjectPtr.h.

Reflection

A few macros in your headers drive serialization, the Details panel, garbage collection and Visual Scripting at once. During the build, the header tool reads annotated headers and writes the class descriptors and GC trace functions into your module Engine/Source/Runtime/Reflection/Public/Reflection/ReflectMacros.h. This is a player class from the First Person template:

Public/TP_FirstPerson/AFirstPersonPlayer.h
#pragma once

#include "Game/AFirstPersonCharacter.h"

#include "AFirstPersonPlayer.generated.h"

namespace Mowo {

MCLASS()
class AFirstPersonPlayer : public AFirstPersonCharacter {
public:
	MGENERATED_BODY()

	AFirstPersonPlayer() = default;

	void Tick(float deltaSeconds) override;

	MPROPERTY(EditAnywhere)
	MCATEGORY("Locomotion")
	float standEyeHeight = 1.65f;

	MPROPERTY(EditAnywhere)
	MCATEGORY("Locomotion")
	float crouchEyeHeight = 1.0f;
};

} // namespace Mowo

Add a field like crouchEyeHeight and it is saved with the level and editable in the Details panel, with no editor code. The last include, AFirstPersonPlayer.generated.h, is written by the header tool during the build.

Actors over an ECS

Gameplay code works with actors and components. AActor AActor is a placeable object that owns a tree of components; MWorld MWorld holds and ticks the actors. The lifecycle follows UE: OnConstruct, BeginPlay, Tick and EndPlay. Components are created in the constructor with CreateDefaultSubobject<T>().

Underneath, every actor has a backing entity in a data-oriented entity-component system, and its components mirror onto ECS components. Engine systems such as rendering and the transform update iterate those components in bulk through the ECS World World.

  1. Main.mmap
  2. Load
  3. Actors + components
  4. ECS entities
  5. Systems (render, physics)
Loading a level: the file becomes actors; actors mirror onto ECS entities that the engine's systems iterate.

The rule of thumb: write gameplay against AActor and components, and let the engine's performance-critical systems work on the ECS. You rarely touch the ECS directly.

Read more in Gameplay.

Data files and config

Game data is stored in MDF, the Mowo Data Format, with one API over two encodings: text you can read and diff, and a compact binary form the cooker writes for shipping. Every asset type has its own extension, listed in one table, FFileTypes FFileTypes: levels are .mmap, materials .mat, prefabs .prefab, Visual Scripting graphs .vscript, UI screens .ui, and binary bulk data such as meshes and textures has its own extensions too.

Settings are INI files in the Unreal dialect (Config/Engine.ini, Config/Input.ini), and the project manifest .mproject is JSON. See Reference for every file type and Content pipeline for importing and cooking.

Visual Scripting

Visual Scripting is Mowo's Blueprint: node graphs saved as .vscript files, in the MowoEngine.VisualScripting module Engine/Source/Runtime/VisualScripting/Public/VisualScripting/VisualScriptGraph.h. Graphs can be classes that subclass actors, with functions, macros and event dispatchers, hot reload and a debugger. Every MFUNCTION in C++ appears as a node without registration. The First Person template's sliding door is a Visual Scripting class with no C++ behind it.

Read more in Visual Scripting.

Arc, the UI framework

Arc is a retained-mode UI framework in the spirit of Slate, and the only UI framework in the engine: the editor, the launcher and game UI all use it. ArcUI is the game-UI layer on top, the way UMG sits on Slate, with .ui screens, themes, bindings and world-space widgets.

Read more in UI.

How it fits together

When you press Play, the editor copies the level and runs the copy. The level's actors are MObjects described by reflection; the collector traces them through their MPROPERTY fields; their components mirror onto ECS entities that rendering and physics iterate; and every one of those systems lives in its own module, built by mbt.

Where to go next

Engine sources

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

  • Engine/Source/Runtime/Core/Public/Core/MObject.h
  • Engine/Source/Runtime/Core/Public/Core/TObjectPtr.h
  • Engine/Source/Runtime/Core/Public/Core/FMObjectArray.h
  • Engine/Source/Runtime/Core/Public/Core/FileTypes.h
  • Engine/Source/Runtime/Reflection/Public/Reflection/ReflectMacros.h
  • Engine/Source/Runtime/Game/Public/Game/AActor.h
  • Engine/Source/Runtime/Game/Public/Game/MWorld.h
  • Engine/Source/Runtime/ECS/Public/ECS/World.h
  • Engine/Source/Runtime/VisualScripting/Public/VisualScripting/VisualScriptGraph.h
  • Templates/TP_FirstPerson/Source/TP_FirstPerson/Public/TP_FirstPerson/AFirstPersonPlayer.h
  • Templates/TP_FirstPerson/Config/Plugins.ini

Page feedback

Was this page helpful?