ModuleSystem

ModuleSystem is the unofficial name of Nintendo EPD's latest game engine, based on the name of the singular sead::Task at the heart of the mainloop. It's actor system appears to be a sequel in design to KingSystem, the engine created for The Legend of Zelda: Breath of the Wild. ModuleSystem appears to have replaced both ActionLibrary and LunchPack2 as the new primary engine for Nintendo EPD's and NST's game development teams. While each game shares a common set of engine features, each series appears to have a custom fork extending the engine with varying degrees of game specific functionality.

Games

Name	Extension/Differences summary
Nintendo Switch Sports	Graphics Module contains a Mii data manager.
Splatoon 3	ModuleSystem is extended to thunder::ModuleSystem, notably adding the ability to run the CPU side of the mainloop multiple times per frame. Omits gamedata for a custom save system.
The Legend of Zelda: Tears of the Kingdom	Major version up from Splatoon 3 and Nintendo Switch Sports. Some engine namespaces were updated between version 1.0.0 and 1.1.0. Includes the TerrainModule and LODModule, while most other games only contain references to these systems.
Super Mario Wonder	Some libraries are newer than Tears of the Kingdom, some are older.
Mario Vs Donkey Kong	Appears to be slightly behind version of Tears of the Kingdom. IActor has a new Stasus state used when swapping actors between "combined scenes". Replaces physics handling with a custom 2d physics engine, yet leaves the PhysicsModule with an unused version of the phive library implemented on top of PhysX instead of Havok.

Namespaces

The top level namespace for ModuleSystem is engine. Sub-namespaces typically include a module wrapping a system for a dedicated purpose, whether unique to the engine or contracted out to an external library. Interfaces to the system are typically provided to Actors or Scenes.

Namespace	Description
actor	Implements the actor system.
ai	Wraps the ai library. Integrates with PreActors through ActorAIGroups, ActorBase through the AIComponent, and IScene through the SequenceComponent.
as	Wraps the as library. Integrates with ActorBase through the RetargetScaleComponent, ASInfoComponent, ASOptimizeComponent, and ASComponent.
bake	Wraps the bake library.
banc	Implements BancEntities via the BancModule. Banc handles the parsing of map units into PreActors, actor ai groups, rails, placement groups, far delete groups, and custom game extensions.
bb (Unofficial)	Wraps the bb library, responsible for managing bb::Blackboards. Integrates with ActorBase through BlackboardComponentActor and IScene with BlackboardComponentScene.
camera	Implements a camera system. Integrates with ActorBase via the CameraComponent.
component	Houses all engine components from the other namespaces for engine::actor::ActorBase and engine::scene::IScene.
controller	Implements a controller manager.
debug	Stubbed in retail. Seemingly implements a debug menu called "ClickMenu".
effect	Wraps shaft::effect for managing effect resources.
erepo (unofficial)	Wraps the erepo library for PlayReport management.
event	Implements an event system on top of the evfl library for Event Flows and Timelines, and the sdk movie library for prerendered video. Integrates with ActorBase through the BeforehandLoadEventComponent, EventMemberComponent, and EventPerformerComponent.
framework	Implements a minor extension to sead::GameFrameworkNx, and the SpStepRateMgr.
gamedata	Wraps the gmd library for managing a global, computable, and savable hash map of game data.
graphics (unofficial)	Wraps the gsys library, which extends the agl library. Integrates with ActorBase through the ModelComponent and ModelBindComponent.
lod	Implements a level of detail system. Integrates with ActorBase through the LODComponent.
lua	Stubbed in retail. Provides lua support for debugging purposes.
module	Implements the ModuleSystem sead::Task, as well as the IModule interface.
physics	Wraps the phive library. Integrates with ActorBase through the PhysicsComponent.
rail	Implements the RailMgr, manages rails parsed from banc.
reaction	Implements a system for triggering reactions through reaction actors and XLink commands somehow (unknown at time of writing). Integrates with ActorBase via the ReactionComponent.
resource	Wraps the ares library and implements ares::IApplicationImpl to provide asynchronous file resource management through ResourceBinders. Also wraps the pp library and implements pp::GfMgrCallback to provide a general parameter system via hierarchical Documents.
rsdb	Wraps the pp::rsdb sub library. Manages a set of engine as well as game extended resource databases.
rumble	Implements a rumble call system to allow sending vibrations to controllers.
scene	Implements the scene system.
sound	Wraps the alto library, which extends the aal library, which extends the aal::atom sub library.
system	Implements the RomConfigMgr and PauseMgr
terrain	Wraps the tera library. Provides terrain management.
transceiver (unofficial)	Implements a transceiver based message systems. Messages can be sent to directly to a destination, or to a whole set of listeners.
ui	Wraps the eui library, which in turn extends nn::ui2d. Provides ui processing and resource management through a layout category based system.
xlink	Wraps the xlink2 library. Implements an XLink PreActor Manager. Integrates with ActorBase through the ELinkComponent, SLinkComponent, XLinkComponent, and XLinkSubComponent.

Non-Canon Namespaces

These are engine namespaces, that for one reason or another, appear to be game specific extensions.

Name	Game(s)	Description
coll2d	Mario Vs Donkey Kong	Implements a 2d collision system the game uses instead of phive.
level	Mario Vs Donkey Kong
message	Mario Vs Donkey Kong
move2d	Mario Vs Donkey Kong	Implements a 2d movement system.

Main Loop

The mainloop is implemented as a single sead::Task in the standard sead::GameFrameworkNx mainloop. The mainloop consists of 4 sead::DependencyJobGraph's submitted and ran in a sead::DependencyJobWorkerMgr in succession. These are unofficially called as of writing BeforeActor, AfterActor, GSys, and GSysCalcGpu.