¶ Core Concepts of Moduverse
To create new content for Moduverse, it’s important to first understand its core concepts. Like most games — especially those built with Unreal Engine 5 — Moduverse is based on a few fundamental building blocks:
Level (World)
A Level represents the scene in which the game takes place. It consists of architectural and environmental elements, lighting, and other visual components that define the overall atmosphere and Level Layout.
Game Rules (GameMode)
The GameMode defines the rules of the game. It determines whether the experience is single-player or multiplayer, whether teams exist, what objectives players have, and many other gameplay-related aspects.
Player (Character)
Each player controls a Character that represents them in the game world. This is the entity that responds to player input and through which interactions with the world are performed.
Objects, Logical-Elements (Spawnables)
Throughout the game world, logical elements are placed to drive gameplay. These may be visible or invisible and include trigger volumes, lootable chests, doors, enemies, weapons and other interactive or systemic objects.
¶ The Moduverse Approach
Moduverse builds upon these established concepts but introduces three key directives:
- Split game elements into isolated, modular, standalone and individually loadable Modules
- Ensure these Modules are compatible with each other, allowing them to be dynamically assembled into a Scenario
- Translate communication between individual elements to enable seamless interaction and compatibility of independently created content
This modular approach allows Moduverse content to be flexible, reusable, and extensible across a wide variety of Scenarios.
This resulted in the introduction of the following Module types:
- World Modules
- GameMode Modules
- Character Modules
- Avatar Modules
- Spawnable Modules
- Content Pack Modules
Each Module type is designed to contain a specific set of elements required for its individual purpose. Together, these Modules form the building blocks of a Scenario and can be combined in a flexible and modular way to create a wide variety of gameplay experiences within Moduverse.
¶ Module Types
Moduverse is built around a modular architecture. Each Module type serves a specific purpose and encapsulates the assets and logic required for that role. This separation allows Scenarios to be assembled flexibly while keeping individual systems clean, reusable, and independent.
¶ World Modules
World Modules contain a single Level and all assets that Level depends on. This includes the world layout, environmental and architectural elements, lighting, atmosphere, and overall visual mood of the scene.
A World Module may optionally include a GameMode. If it does, the World Module can define whether this embedded GameMode is fixed or can be overridden when the World is loaded as part of a Scenario.
If the embedded GameMode can be overridden, or if the World Module does not include a GameMode at all, a separate GameMode Module will be used instead.
World Modules define where the game takes place, but not necessarily how it is played.
See World Modules for further Info.
¶ GameMode Modules
GameMode Modules define the rules and structure of gameplay. They contain a GameMode Blueprint Class and any additional elements required for the GameMode to function correctly.
Within Unreal Engine’s Gameplay Framework, this may include assets such as:
- GameState
- PlayerState
- PlayerController
- HUD
- Additional supporting logic and data assets
The Pawn used for each player can be defined directly within the GameMode Module. However, a GameMode Module may also allow the player character to be provided by referencing Character Modules instead.
This behavior is optional and enables Scenarios to dynamically decide which type of player character is used.
GameMode Modules define how the game is played.
See GameMode Modules for further Info.
¶ Character Modules
Character Modules contain a single Character Blueprint Class (or Pawn) that can be loaded by a GameMode. This allows GameModes to use different player characters depending on the Scenario, without being tightly coupled to a specific implementation.
Character Modules include everything required for the functional gameplay behavior of a player character (or its base Pawn class), such as:
- Movement logic
- Abilities and interactions
- Input handling
- Gameplay-related components
A Character Module may also include the visual representation of the character.
Alternatively, it can be purely functional and rely on an Avatar Module for visual representation.
Character Modules define how the player behaves and interacts with the world, and optionally also determine the player’s appearance.
See Character Modules for further Info.
¶ Avatar Modules
Avatar Modules are used when a Character Module chose not to provide its own visual representation. In this case, an Avatar Module is responsible for representing the player visually as sort of an overlay.
Avatar Modules:
- Are only used if the Character Module explicitly supports Avatars
- Have no influence on gameplay or mechanics
- Exist purely for visual customization and player identity
Each player can individually choose which Avatar they want to use, allowing multiple players in the same Scenario to be represented by different Avatars, even when using the same underlying Character Module.
Avatars define how the player looks, not how they play.
See Avatar Modules for further Info.
¶ Spawnable Modules
Spawnable Modules contain a single spawnable Actor-based Blueprint Class, such as:
- Objects
- Weapons
- Tools
- Vehicles
- Enemies
- Interactive, visual or logical gameplay elements
They are designed to extend or modify existing Worlds, provide Scenario-specific context, or enrich Levels with additional gameplay or visual detail.
A Spawnable Module packages an individual Actor together with all assets it requires, making it easy to reuse and spawn consistently across different Worlds and Scenarios.
Spawnable Modules define what can be placed or spawned into a World.
See Spawnable Modules for further Info.
¶ Content Pack Modules
Content Pack Modules are collections of reusable Unreal Engine 5 assets.
Unlike other Module types, they are not limited to a single type and may contain:
- Static or skeletal meshes
- Materials and textures
- Niagara Special Effects
- Sound Effects and Music Assets
- Animations and other assets
Their primary purpose is to provide shared content that can be reused across multiple Scenarios and Modules, reducing duplication and keeping scenarios maintainable.
Content Pack Modules define shared building blocks used throughout Moduverse.
See ContentPack Modules for further Info.
¶ Prerequisites for Creating Modules
To create new content in the form of Modules for Moduverse, you will need the following:
- Unreal Engine 5.7.3
- Moduverse SDK
It is important to note that the required Unreal Engine 5.7.3 must be the official, first-party binary version distributed through the Epic Games Launcher.
So far, the SDK has been tested and developed exclusively for Microsoft Windows systems (Windows 10 or later).
Its functionality on macOS or Linux has not been tested and may not work correctly, or at all.
¶ Moduverse SDK
The Moduverse SDK is an Unreal Engine 5.7.3 project preconfigured with the specific project settings required for Moduverse to function correctly.
It also includes the tools necessary to:
- Package individual Content Plugins into Moduverse-compatible Unreal Engine Content Packages (
.PAKfiles) - Generate Module Files (
.modulefiles)
Because of this, it is critical not to modify the project configuration or what plugins are active of the provided Moduverse SDK.
Changing these settings may cause content to fail or behave incorrectly inside Moduverse.
You can download the Moduverse SDK project here:
Moduverse SDK 2026.02
Next, depending on the type of Module you want to create, refer to the corresponding page:
- Creating World Modules
- Creating GameMode Modules
- Creating Character Modules
- Creating Spawnable Modules
- Creating Avatar Modules
- Creating ContentPack Modules