Topology, Project Layout & Module Split

V5 is one Unreal Engine 5.5 LTS project that hosts an entire open-world narrative-action universe rather than a single game: six ruleset "cells" — Urban Crime, Period Drama, Frontier, Monster Hunter, Sci-Fi, and the Brave New World Steampunk Detective DLC — plus a cross-cell Mind Palace deduction meta-layer, all under one shared roster, one shared AI-perception model, and one online backbone. The architectural bet that makes that universe tractable is the inverse of a fat monolith: all of the frame-critical mechanics live in shared C++ engine modules, and each playable mode-variant is a hot-swappable content GameFeature plugin layered on top of them. This is not slideware — it is wired through the repository. The project at V5/ue/V5.uproject sets "DisableEnginePluginsByDefault": true, declares 74 C++ modules (69 Runtime, 5 Editor), and force-enables a curated set of 32 engine plugins; under V5/ue/Source/ those 74 module directories each carry a real *.Build.cs and a Public//Private/ split, totalling 328 .cpp + 341 .h (669 source files). Five *.Target.cs files define the runtime topology, and 29 V5Mode_* GameFeature plugins under V5/ue/Plugins/ carry the per-cell content roots.

This page is the orientation map for how those pieces fit at runtime, on disk, and by concern. As with the rest of this set, the reason to read the code rather than the architecture monolith's prose is that the two have drifted in a handful of load-bearing places — most importantly, the monolith's glossary lists 48 engine modules where the disk has 74, and it markets the cells as code-bearing plugins where the disk ships them as content-only GameFeature roots. Where the .uproject, the Build.cs files, and the on-disk plugin tree disagree with the monolith, this page treats the compiler's view as authoritative and labels the monolith as the aspirational spec. The full section index for the catalogue is ../V5_ARCHITECTURE.md.

What ships, honestly#

Real and on-disk (the compiler agrees). All 74 module directories named in the .uproject Modules array exist under V5/ue/Source/, each with a *.Build.cs, a Public//Private/ split, and (in 73 of 74) a Private/Tests/ spec directory. The depth is concentrated where the universe needs narrative reasoning: V5MindPalace is the deepest at 18 .cpp/18 .h, followed by V5Melee and V5Investigation (11 each), V5Interrogation (10), and V5StarMap, V5Squad, and V5Combat (9 each). Many modules are leaner — roughly 3 .cpp/3 .h (a <Module>.cpp implement, a <Module>Systems, a <Module>Types.h, and a Tests/ spec) — but none is a bare three-file .cpp/.h/.Build.cs stub. Testing is genuine and distributed: 73 modules hold their own automation specs, and the dedicated V5Tests module adds a 5,804-line V5TestsAutomation.cpp carrying thousands of real UE IMPLEMENT_*_AUTOMATION_TEST / TestEqual / TestTrue assertions. The EV5Cell enum in V5/ue/Source/V5Core/Public/V5Types.h carries 7 values (Urban, Period, Frontier, Hunter, SciFi, Steampunk, MindPalace), exposed through GetAllV5Cells() — datasets and per-cell tests must size against that call, not a literal 5 or 6.

Modeled as data, not binary art. Like V4, V5's content is a logic-and-data skeleton: a tree-wide search finds 0 binary .uasset and exactly one .umap (Content/V5Core/Maps/BootMap.umap), against 393 .json descriptors under ue/Content/ plus 62 .json content manifests inside the GameFeature plugin roots. So the logic and data of every cell are real and version- controlled, while the hand-authored meshes, MetaHumans, audio, and cooked levels are not in-tree. Where a claim depends on that art, this page says so.

Spec-only or mislabelled drift, found by reading the disk. Six items are worth naming up front because the deep pages reference these names:

1. The glossary's "Engine Modules" table is incomplete. It lists 48 modules; the disk has 74. The 26 it omits are the thin V5 composition root (which the Project Layout does name), three cross-cutting modules (V5Accessibility, V5Localization, V5Compliance), four editor authoring modules (V5MissionEditor, V5HeistAuthor, V5CaseAuthor, V5WorkshopEditor), and eighteen per-cell-variant composition modules (V5UrbanHeistCity, V5HunterWitchersPath, V5FrontierOutlawTrail, …).
2. The cells are content-only plugins, not code plugins. Every V5Mode_* .uplugin declares "EnabledByDefault": false, "CanContainContent": true, "BuiltInInitialFeatureState": "Installed", and zero source modules (0 .cpp/0 .h). This is the exact inverse of V4, whose ruleset plugins each shipped a runtime C++ module.
3. The plugin count is off by one. The monolith's Project Layout lists 28 V5Mode_* plugins; the disk has 29 — the extra is V5Mode_Steampunk_Detective, the DLC cell.
4. The V5Mode_* plugins are not force-enabled in the .uproject. Its Plugins array enables 32 plugins, all of them engine plugins — none of the 29 V5Mode_* features. They are discovered as project plugins and activated at runtime by V5Modes instead. One stray entry leaks across products: V8_Ariadne_CaseClient (a V8 plugin) is enabled in V5's .uproject.
5. No determinism is stamped by the build. No target or Build.cs sets DETERMINISM, /fp:strict, -fno-fast-math, or bUseUnityBuild=false; authority and determinism live one level down in V5Netcode. See netcode, authority & determinism.
6. No cross-language footprint. There is no libs/v5, no libs/contracts/src/v5, and no apps/v5; V5 is self-contained under V5/, with contracts expressed in UE C++ types and in the TypeScript service structs.

Everything below is grounded in those files; where a claim is the monolith's intent rather than shipped code, it is labelled.

Runtime topology: five targets over one shared core#

The monolith renders the runtime as a single "one shippable executable per platform" block. In code the topology is richer: five *.Target.cs files, two of which do real work the prose understates.

The honest contrast with V4 is the dedicated-server target. V4's tournament server stripped nothing; V5's V5DedicatedServer.Target.cs actually DisablePlugins the entire presentation stack — Niagara, Metasound, MetaHumanRuntime, CommonUI, ModelViewViewModel, the animation set (MotionWarping, AnimationWarping, PoseSearch, Mover, Chooser, IKRig), the Chaos cloth/flesh/geometry set, PCG, and WorldPartitionHLOD — producing a genuine headless build. That stripping is .Target.cs-driven, which is the whole point of putting the rest of the genre stack behind force-enabled engine plugins. What no target does is stamp determinism flags, so the per-cell netcode story (dedicated-server authoritative vs. rollback-emulated vs. offline deterministic) is realized inside the V5Netcode module, not by the targets.

The Mind Palace is, as the monolith puts it, a side-car to all cells: each cell pushes evidence events into V5MindPalace, whose UI overlays the cell-of-the-moment but operates on its own deduction graph and syncs through the mindpalace-cloud-sync service.

The cell-hosting model: content plugins over a shared core#

The single most important structural fact about V5 — and its cleanest departure from V4 — is how a cell becomes active. In V4 each ruleset plugin carried its own runtime C++ module that composed a cell-mechanic module. In V5 the mechanics all live in the 74 shared modules, and a mode-variant is expressed twice: as a content-only GameFeature plugin (V5Mode_Urban_HeistCity, a Content/ tree of JSON manifests under a .uplugin with no source) and as a C++ "cell-variant composition module" (V5UrbanHeistCity) whose Build.cs wires the shared mechanic modules that variant needs. V5FrontierOutlawTrail, for example, depends on V5DeadEye, V5Honor, V5HorseAI, V5Hunting, and V5Squad; V5HunterWitchersPath on V5Alchemy, V5Melee, V5MonsterHunt, V5Signs, and V5Squad; V5SciFiGalacticSquad on V5Dialogue, V5Spaceship, V5Squad, and V5StarMap. Each such module is real code (a *Systems.cpp plus a *Types.h with ten-plus USTRUCTs), not a stub.

The runtime that fuses content plugin to composition module is V5Modes. Its public surface is a set of UBlueprintFunctionLibrary registries: UV5_Mode_Registry (DiscoverInstalledGameFeaturePlugins, DiscoverEnabledGameFeaturePlugins, EnumerateEnabledGameFeaturePlugins(... EV5ModeBuildTarget)), UV5_Mode_PerCellHUDRouter (BuildHUDRoute(EV5Cell, FName ActiveModePlugin)), UV5_Mode_RulesetGate, UV5_Mode_OnlineLobby_BureauHQ, and UV5_Mode_ArcadeCabinet. This is the concrete mechanism by which selecting a cell discovers its installed GameFeature plugin and routes the correct per-cell HUD — the monolith's "mode registry, per-cell ruleset gating" expressed as code.

Above that sits a deliberately empty root. The module named simply V5 (V5/ue/Source/V5/, 1 .cpp/1 .h) is the only module all five targets name via ExtraModuleNames.Add("V5"), yet its Build.cs depends on engine modules only (Core, CoreUObject, Engine, InputCore) and its V5.cpp is nothing but IMPLEMENT_PRIMARY_GAME_MODULE(FV5Module, V5, "V5") with empty StartupModule/ShutdownModule. It hosts no subsystems at all — even thinner than V4's bootstrap root. The fusing happens entirely through the modular-plugin layer and V5Modes, never through a fat composition root.

Project layout: where V5 actually lives#

V5 is self-contained under V5/. The engine project and the off-engine planes sit side by side.

• V5/ue/ — the one UE5.5 project: 74 Source/ modules, 5 targets, a Config/ set, a Content/ tree with per-cell roots (V5Urban, V5Period, V5Frontier, V5Hunter, V5SciFi, V5MindPalace, V5Shared, …) so a "no-frontier" SKU can ship without dragging that cell's asset budget, a Platforms/ overrides tree, and Plugins/ holding the 29 content-only V5Mode_* GameFeature roots. The 32 force-enabled engine plugins read like a bill of materials for a multi-genre universe: GameplayAbilities, EnhancedInput, CommonUI + ModelViewViewModel, the animation stack (MotionWarping, AnimationWarping, PoseSearch, Mover, Chooser, IKRig), Niagara, the Chaos set (ChaosCloth, ChaosFlesh, GeometryCollectionPlugin, ChaosVehiclesPlugin), Metasound + AudioModulation + AudioGameplayVolume, MetaHumanRuntime, PCG, MassEntity, the networking set (Iris, NetworkPrediction, ReplicationGraph), and GameFeatures + ModularGameplay (the basis of the whole cell-hosting model).
• apps/v5/ — the online backbone, here a TypeScript tree (each service ships a package.json, vitest.config.ts, and contract.test.ts), with the directories the monolith promises: auth, friends, parties, matchmaking, leaderboards, replays, telemetry, anti-cheat, crash-reporting, companion-app-bridge, mindpalace-cloud-sync, workshop, compliance-dsar, live-service-calendar, balance-ledger, faction-rep, plus service-shared, k8s, and a verify-services.mjs gate. (Note the language contrast: V4's backend was a Rust workspace; V5's is Node/TS.)
• Data-authoring & ops trees — balance/ (per-cell spreadsheets + a period-auth/ era-bundle set), loc/ (16 languages, source-of-truth), tools/ (140 entries — far richer than the layout's seven categories), legal/, docs/, release/, security/, audio/, cinematics/, companion/, crossplay/, community/, and live-service/ — all JSON/Markdown authoring and ops data, not compiled code.
• apps/v5/web/ — the Next.js marketing surface.

The module split, by concern#

The 74 modules group into eight concerns. The dependency notes below are the verified Build.cs edges. V5Core is the universal sink — it depends on no V5* module — and every edge points toward more-foundational code, so the graph resolves cleanly into a directed acyclic graph. The cross-cell shared modules forbid any per-cell dependency (one-way enforcement, declared in the Build.cs files).

• Foundation (2). V5Core (engine subsystems, save game, the EV5Cell/GetAllV5Cells registry, dev cheats) and the thin V5 bootstrap root. Both link engine modules only.
• GAS spine & engine subsystems (~11). V5Gameplay (→ V5Core) is the ability-system layer; V5Animation, V5Input, V5Netcode, V5Modes, V5Persistence, V5Telemetry, V5Cinematics sit beside it. V5UI (→ V5Core, V5Modes) is the CommonUI/MVVM front-end; two presentation edges the monolith's split prose omits are real here: V5VFX → V5Signs (sign FX is first-class) and V5Audio → V5RadioTV (the in-world radio mix feeds the audio module).
• AI stack (3). V5Perception (the unified sight/hearing/suspicion model) → V5Crowd → V5Schedules, with the surprising real edge V5Crowd → V5Honor (civilian panic reads the honor/reputation axis). Every NPC in every cell reads stimuli through this one chain.
• Shared cell-mechanic modules (~24). The genre cores reused across cells: V5Combat, V5Melee, V5Vehicles, V5Open, V5DeadEye, V5Honor, V5Hunting, V5Wanted (→ V5Honor), V5Heist (→ V5Combat, V5Vehicles), V5Alchemy, V5Signs, V5MonsterHunt, V5Spaceship, V5StarMap, V5Squad, V5FaceCapture, V5PeriodAuth (→ V5Crowd), plus the engine-only leaf mechanics V5CardGame, V5HorseAI, V5Karaoke, V5LockpickHack, V5Parkour, and V5RadioTV (these six link no V5* module at all).
• Cross-cell narrative layer (4). V5MindPalace (the deepest module, → V5Investigation), V5Investigation, V5Interrogation, and V5Dialogue — the deduction/evidence/interrogation spine that every cell pushes into.
• Cell-variant composition modules (18). One per mode-variant, mirroring the GameFeature plugins: the urban trio (V5UrbanHeistCity → V5Wanted; V5UrbanStreetTriad → V5Melee, V5Parkour; V5UrbanOnline), the period pair (V5PeriodMadeMan, V5PeriodViceSquad), the frontier pair (V5FrontierOutlawTrail, V5FrontierOnline), the hunter trio (V5HunterWitchersPath; V5HunterContractBoard → V5HunterWitchersPath; V5HunterCardGame → V5CardGame), the sci-fi trio (V5SciFiGalacticSquad, V5SciFiHardVacuum → V5Spaceship, V5SciFiPvP), the two detective variants, and V5SpecOpsCoop/V5HordeDefense/V5RoguelikeHunterRun.
• Online & data (4). V5OnlineServices (→ V5MindPalace — the cloud-sync edge), V5Persistence (→ V5MindPalace), V5Telemetry, V5Procgen.
• Editor, cross-cutting & tests (8). Five Editor-type authoring modules (V5Editor, V5MissionEditor, V5HeistAuthor, V5CaseAuthor, V5WorkshopEditor), the cross-cutting V5Accessibility, V5Localization, V5Compliance, V5Hub, and the V5Tests harness atop everything.

Where to go next#

This page is the orientation hub; three sibling pages take the topology apart:

• Promise & glossary — the fixed vocabulary, the full 74-module map, and the module/plugin/service reconciliation.
• GAS, animation & input — how V5Gameplay, V5Animation, and V5Input carry the shared combat-and-traversal spine the cell modules ride on.
• Netcode, authority & determinism — why determinism lives in V5Netcode rather than the build targets, and how each cell selects its replication strategy.
• The full catalogue: ../V5_ARCHITECTURE.md.