What Is Metaplay?

Metaplay is a fully-programmable platform for building, operating, and scaling server-authoritative live-service games. It combines:

• A C# game server and Unity SDK with a deterministic shared-code execution model.
• A data-driven config system with over-the-air updates and validation pipelines.
• A LiveOps Dashboard for operating your game at scale.
• Production-grade infrastructure, tooling, and optional managed hosting.

Metaplay is designed for top-grossing mobile F2P development, and scales to hundreds of millions of players while letting your team move fast without compromising engineering quality.

Core components:

• Game Client - A normal Unity project using the Metaplay SDK.
• Game Server - Horizontally scalable C# backend executing authoritative game logic.
• LiveOps Dashboard - Extensible web app for operating your live game.
• Infrastructure - Terraform + Kubernetes + managed MySQL (AWS first), with options for managed or self-hosted deployment.

Who Is It For?

• Teams building server-authoritative games of any genre, from prototype to global launch.
• Studios that want source access and first-class programmability — not a black box backend.
• Organizations operating multiple titles that need shared tooling, workflows, and reliable LiveOps.

Develop efficiently

Build complex, cheat-proof games quickly with deterministic shared code, data-driven pipelines, and serious engineering tools.

Shared Code Programming Model (Deterministic Execution)

Traditionally, multiplayer/server-authoritative games maintain separate client and server codebases, creating sync bugs and slowing iteration. Metaplay’s deterministic model lets you write game logic once in C# and run it on both client and server:

• Predict on client, validate on server: instant feedback for players, cheat-proof results on the backend.
• Same logic, same outcomes: deterministic numerics (fixed-point), seeded RNG, stable collection iteration.
• Gameplay programmers naturally build backend logic while writing gameplay, enabling large teams and complex features.

Data-Driven Development Engine

Live games need rapid iteration across complex economies and content:

• Author configs in your tools of choice (e.g., spreadsheets, CSV, JSON); ship updates over-the-air—no client rebuilds.
• Built-in pipelines for validation, diffing, and A/B testing; ingest nested and structured data with custom parsers.
• Make your entire game data-driven: economies, localizations, live events, offers, and more.

Programming Power Tools

Engineering quality-of-life is first-class:

• One-command local server: dotnet run — no Docker or database installs required.
• First-class IDE support: run and debug server code from Visual Studio or Rider.
• Embedded mock backend: develop in offline mode for fast inner-loop iteration.
• Test harnesses and load testing: simulate resource usage and validate behavior at scale early.

Fully-Programmable Platform

Not a black box — Metaplay ships with source for the C# game server, Unity SDK, and LiveOps dashboard:

• Extend cleanly using base classes and public APIs; don’t hack around undocumented internals.
• Build on top of our server and grow into custom services, third-party integrations, or bespoke systems over time.
• Treat the game server like any C# project: full control when you need it.

Operate effectively

Run your live game with tools built for entire game teams — not just engineers.

Metaplay LiveOps Dashboard

A purpose-built, source-available dashboard that scales with your game and team:

• Player support: inspect player state/behavior; apply changes safely.
• Game operations: manage matchmakers, guilds, and game-specific features.
• LiveOps tooling: A/B tests, segmentation, events, offers, configs, and localizations.
• Customize anything: add game-specific admin actions, pages, and workflows as your needs grow.

Live-Service Feature Framework

Ship faster with high-quality building blocks:

• Essentials: customer support tools, web shop integration, and more.
• Advanced features: guilds, leagues, event calendars, and more — available out of the box.
• Extend with your own features using the same platform primitives.

Metaplay Managed Platform

Focus on your game; we’ll run the backend:

• Multiple environments (dev, stable, staging, production).
• Pre-configured observability, logging, access control, and operations tooling.
• Premium support options to work directly with core engineers (e.g. pre-launch readiness).
• For the biggest titles, self-hosting is available so you can own the entire stack.

Troubleshooting & Incident Response

Designed for resiliency and rapid triage:

• Kubernetes-based, self-healing architecture with robust observability and alerting.
• Advanced debugging tools: client error reports, player state inspection, analytics event history, timeline debugger.
• Export player states from production to local for deep debugging.
• Incident response workflows and support plans to resolve issues fast.

Scale confidently

Operate at massive scale without losing control of quality or productivity.

Battle-Tested Infrastructure

Proven to handle tens of millions of DAU and millions of CCU:

• Horizontally scalable services, automated load testing, built-in observability.
• Identify issues early with diagnostics and self-healing systems.

Frameworks for Managing Complexity

No top-grossing game is simple:

• Patterns and frameworks for guilds, leaderboards, and social systems.
• CI, automated tests, and Bot Client at scale to catch regressions early.
• Design for testability: ship with confidence through every update.

Cross-Team Collaboration

Make routine operations self-serve:

• CS can triage and link deep error reports to engineering.
• Designers ship new configs independently from client cycles.
• Analysts manage A/B tests; LiveOps teams schedule in-game events.
• Run multiple environments; move data safely across them.

Long-Term Business Protection

Protect your business and roadmap:

• Source available and contractually structured to avoid vendor lock-in or “rug pulls.”
• Self-host when you need full autonomy and performance tuning.
• Freely programmable platform supports new business models (e.g., third-party IAP stores) without waiting on vendor features.

Customize everything

Bring your own code, features, and infrastructure. Metaplay won’t box you in.

Designed to be Extended

• Clear APIs for integrating external services and building custom functionality at any layer.
• Build with good engineering practices, not brittle workarounds.
• A “distributed monolith” architecture: trivial to run locally, straightforward to scale in the cloud.

Bring-Your-Own-Anything

• Treat built-in features as reference implementations; build your own with the same primitives.
• Anything you can do in C# can run on Metaplay.
• Optionally lean on Metaplay Support for design reviews and future SDK compatibility.

Centralized Tech for Multiple Games

• One platform across a portfolio: shared infra, unified tooling, consistent workflows.
• Game teams can tailor features while sharing LiveOps best practices.
• DevOps teams benefit from unified environments, CI pipelines, and observability.

Own Your Infrastructure

• Migrate from managed to self-hosted when you’re ready.
• Kubernetes + Terraform on AWS (primary) with portable designs familiar to infra teams.
• Full control and ownership of databases and operations.

What It’s Not (and When to Consider Alternatives)

• FPS-style games needing full physics-based authoritative hit detection out of the box: Metaplay doesn’t ship a physics engine. You can still use it for meta-game, matchmaking, and orchestration — and simpler physics-driven 2D games are feasible.
• Pure client-authoritative P2P games: Metaplay is server-authoritative by design to prevent cheating and protect revenue.
• Massive shared-world MMOs with thousands of concurrent entities in a single shard: dedicated MMO engines are likely a better fit, though simpler MMO-like 4x strategy games work well.

Next Steps

• Learn by Playing - Explore a live demo of a real game built with Metaplay.
• Integrate the Metaplay SDK - Integrate the Unity SDK, connect to a local server, and ship your first feature.
• Tutorial: Game Logic - Follow a hands‑on tutorial and build a Wordle‑style game with real Metaplay patterns.