How metaverse is created on Unreal Engine and Unity

Introduction: "the world as a platform"

The metaverse is not a "big game," but a platform of living worlds: a persistent state, scalable scenes, social presence, user-generated content (UGC), an internal economy, and a calendar of events. Unreal Engine and Unity give two mature paths to such a platform: the first - with an emphasis on cinematic picture and a ready-made high-level network stack; the second is for the widest cross-platform, modularity and easy input for UGC tools.

1) High-level architecture

Clients: desktop/console/mobile/VR/AR (Unity - stronger in mobile/VR/AR; Unreal — в PC/console/visual fidelity).

Edge/cloud: authoritarian game servers, real-time gateways (WebSocket/UDP), match/instance services.

Platform services: accounts/profiles, inventory, content catalogs, UGC publishing, moderation, economics/payments, notifications.

Data: telemetry, anti-fraud, compliance reports, event analytics, content indices.

Admin/creator panel: event launch tools, A/B, location management, UGC editors.

2) Unreal vs Unity: When to Choose What

Unreal Engine - "cinema and multiplayer out of the box"

Graphics/render: Nanite/Lumen, high presets, cinematic effects.

Network core: actor/component replication, RPC, prediction, Dedicated Server; convenient for action and "live scenes."

Tools: Blueprints + C++; Sequencer, Control Rig, MetaSounds; Verse/UEFN (for UGC cases based on the Fortnite ecosystem).

Cons: more "heavy" entrance, high requirements for iron; mobile optimization requires discipline.

Unity - "scale, devices, UGC ecosystem"

Cross-platform: strong mobile and XR (AR Foundation), WebGL/WebGPU; quick builds.

Network stack: Netcode for GameObjects, Netcode for Entities (ECS/DOTS) for high load; Transport (UDP/RPC); third-party frameworks (Photon/Fish-Net/Mirror).

Tools: Shader Graph/VFX Graph, Timeline/Cinemachine, Addressables, DOTS for performance, Scriptable Render Pipelines (URP/HDRP).

Cons: out of the box, there are fewer high-level solutions for large shooter scenes; graphics "out of the box" less "cinema," but customizable.

Brief selection logic:

Do a "premium scene," live events, shooter/action with a rich picture - Unreal.
Make a cross-platform metaverse with strong mobile/XR and fast UGC content - Unity.

3) Network design and persistence

World model:

Layered: lobby/social hub (up to hundreds of players), scene instances (20-100), private rooms (2-16).
Sharding: regions/load cases; matchmaker distributes instances by QoS.
Persistent objects: database (NoSQL + cache), event bus (Kafka/PubSub) for world logs.

Key patterns:

Authoritarian server: status/outcomes on the server; clients are "thin."
Replication and LOD networks: rare updates of distant actors; important - more often; crowd aggregation.
Prediction and reconciliation: for movement/gestures; lags masking.
Voice/Spatial-audio: separate media server, prioritization of nearby voices.

4) Content pipeline and UGC

DCC and assets: Blender/Maya/Max → export (FBX/GLB/UDIM), spec for collisions/LOD/materials.

Dev package for creators:

Unreal: Blueprints set/tools + DataAssets; room/scene templates, asset validator, hook to build farm.
Unity: ScriptableObjects, Addressables, URP/HDRP presets, scene stencils assembly (mix, triggers, interactive).

UGC Publishing:

Preliminary validation (polygons, textures, scripts, closed sandbox), scan for prohibited content.
Catalogue and moderation: previews, ratings, complaints, A/B rotation.
Stability: the engine/SDK version is "frozen" for the creators; migration through "version ladders."

5) Gameplay-service layer

Account/profiles/DID: linking social logins/wallets if necessary; privacy.

Inventory and economics: items, skins, accesses; prices, discounts, bundles.

Events and schedule: seasonality, concerts, tournaments, tasks of the week.

Missions/quests: server progress, anti-spam, caps for farm.

Notifications: in-world displays, fluffs, e-mail/chat bot.

6) Graphics and performance

Unreal: Nanite/Lumen (desktop/console), Virtual Shadow Maps; mobile branch - lighting baked + LOD, Mobile HDR, Niagara with budgets.

Unity: URP for mobile, HDRP for premium; GPU instancing, Occlusion, Light/Reflection Probes; DOTS/ECS for crowds.

General principles:

Stable FPS is more important than wow.
Content budgets: polygons/materials/particles/skeletons/texts.
Streaming assets: Addressables/Unreal Streamable Manager; loading by zones.
Fovated rendering (XR): dynamic; post-interest restrained.

7) Audio and sociality

Spatial-audio: source prioritization, quieter/louder zones, private bubbles.

Voice moderation: filters, auto-music, reports; logging of events (in compliance with privacy).

Event mixes: "directing" concerts and shows (Unreal Sequencer/Unity Timeline).

8) Security, moderation, compliance

Anti-cheat/anti-bots: behavioral profiles, device-binding, client verification, server-side authority.

UGC moderation: automatic classifiers + manual revision; blacklists/whitelists of authors.

Policies: 18 +, advertising, data protection, reporting; audit log (who/what changed).

Payments/KYC/AML (if any): onboarding outside the client, sanction filters, limits, "cooling" between replenishments.

Responsible UX: timeouts, pauses, brightness/sound settings, health warnings (XR).

9) Economics and monetization

Digital Goods/UGC Royalties: Cross Scenes, Seasonal Passes.

Events: tickets, VIP zones, sponsorship spaces.

Subscriptions: extended slots, private rooms, early access to locations.

Marketplace: local currency, site taxes, refands; transparent "passport" of the asset (version, author, rights).

Optional Web3: online passports for content, tickets-NFT, split payments - only if compatible with law/policies.

10) Analytics, ML and live ops

Telemetry: inputs/sessions/transitions, heatmap scenes, onboarding funnels, conversion to events.

ML layers: location recommendations, anti-bots, failure prediction, FPS health care.

A/B: rotation of scenes/banners, prices, schedules.

Live panel: status of regions, incidents, deploy/rollback, alerts.

11) Pipeline Produced

Unreal (example):

Perforce/Git LFS → UGS (Unreal Game Sync) → automatic build agents (Cook/Build/Package) → Dedicated Server & client builds → CDN.
Content: DDC (Derived Data Cache), asset validator, automatic LOD/collisions.

Unity (example):

Git LFS/Plastic SCM → Cloud Build/TeamCity/Jenkins → Addressables directories → CDN/directory updates → Crash/Perf collection.
Content: GUID stability, AssetPostprocessor, Addressables validation.

12) Cross-platform and XR

Unity: one project → iOS/Android/Standalone/WebGL targets; AR Foundation для ARKit/ARCore; XR Interaction Toolkit.

Unreal: unified content with platform profiles; VRTemplate, OpenXR; Mobile/VR lighting/shader profiles.

Practice: two Render Pipeline/profiles (mobile "light," desktop "full"), general gameplay layer.

13) Content interoperability

Formats: GLTF/GLB as exchange; general nomenclatures of materials/collisions.

Dictionaries/metadata: unified object schemas, action tags, categories for filtering.

Third-party engines/web: exporting scene presets for WebGL/WebGPU demo login.

14) KPI of metaverse

DAU/MAU, CCU and social density (users per scene).

Activation → First Event/Interaction →

Session Comfort/FPS p95 (especially XR), early exits <5 minutes.

UGC Output: active creators, posts/week, moderation time.

Economy Mix: share of UGC sales/events/subscriptions; ARPPU/LTV.

Safety/Compliance: incidents/1000 sessions, time to close complaints, share of approved creatives.

Uptime/MTTR: stability of regions/instances.

15) Roadmaps (references)

A) Unreal pathway (12-24 weeks)

0-4: vertical slice of the hub (Nanite/Lumen desktop), simple replication, Voice, admin panel of events.

4-8: Dedicated Server, matchmaker, UGC templates (Blueprint), asset validator, CDN.

8-16: mobile profile (baked light), optimization; voice moderation/UGC; tickets/events.

16-24: region scaling, A/B schedules, role accesses, analytics/alerts.

B) Unity-path (12-24 weeks)

0-4: URP hub (mobile-first), Netcode (NGO) + Transport, Addressables, basic UGC import.

4-8: Photon/Fish-Net (if fast scale is needed), Voice, Moderation SDK, Catalog API.

8-16: DOTS for crowds, WebGL demo input, AR Foundation (option), economy/marketplace.

16-24: ML-recommendations of locations, anti-bots, A/B scenes; DevOps-dashboards, rollbacks.

16) Pre-public launch checklist

Network: authoritarian server, replication/prediction; lobby/instances/shards are set up.
FPS/memory: p95 stable; budgets of assets are met; Addressables/Streamable Manager are working.
UGC: validation, sandbox, moderation, reporting; a reference for authors.
Sociality: spatial-audio, private rooms, quick mut/report.
Security: anti-bots/anti-cheats, device-binding, audit logs.
Economy: store/inventory, refands, asset "passport" (version/rights).
Compliance: 18 +, privacy, localization, geo-constraints, RG/health (XR).
Analytics/ops: metrics, alerts, A/B, incident plan, canary releases.

Building a metaverse is systems engineering: a thoughtful network layer, a stable FPS, secure social functions, a scalable UGC pipeline and a predictable economy. Unreal Engine shines where "cinema" and built-in high-end multiplayer are critical; Unity - when platform coverage, XR and UGC speed are important. Teams that build platform-by-design win: clear content budgets, automated pipelines, moderation and an analytical panel. Then the "world as a platform" lives a long time: creators make content, users return, and business scales without loss of quality and trust.