A detailed comparison of Metaplay and Pragma Engine: architecture, engine support, LiveOps, economy, matchmaking, pricing, and when each backend is the right fit.
Metaplay vs Pragma at a glance
Metaplay and Pragma are both server-authoritative game backends that hand you the source code. They differ in engine focus and the game shape each is built around, not in authority model.
Pragma is built for Unreal-based competitive multiplayer games: shooters, MOBAs, and battle royales that use synchronous skill-based matchmaking, parties, dedicated-server integration, and console commerce. Metaplay is built for Unity live-service and free-to-play games, with game logic written once in C# that runs on both client and server, packaged LiveOps tools, and published self-serve pricing. The rest of this comparison sets out what each one does across the same categories.
Quick comparison of Metaplay and Pragma
| Category | Metaplay | Pragma |
|---|---|---|
| Client engines | Unity (primary); WebGL; consoles via custom integration | Unreal and Unity SDKs; engine-agnostic |
| Architecture | Server-authoritative; shared C# client/server logic | Server-authoritative; JVM/Kotlin services, MySQL |
| Source access | Full C# server, Unity SDK, Vue dashboard in every paid tier | Full engine source, built from source (Enterprise) |
| Deployment | Metaplay Cloud (managed on AWS); self-host via Private Cloud | Your cloud, self-hosted, or Pragma managed services |
| LiveOps | A/B testing, OTA configs, segments, events, offers, guilds | Live monitoring and alerts, telemetry, admin and player portals |
| Economy | Server-authoritative currencies, inventory, IAP validation | Virtual currency, entitlements, fulfilments, platform certs |
| Matchmaking | Async MMR matchmaker | Synchronous skill-based; parties, drop-in/out, battle royale |
| Identity | Device, email, social logins; cross-device recovery | Cross-platform accounts, cross-play, cross-progression |
| Target studio | Unity mobile, F2P, and live-service teams | AAA and competitive multiplayer studios |
| AI and developer tooling | Metaplay Agent (public preview) + Docs/Portal MCP servers; no in-product ML | No AI dev tooling documented; FirstLook does AI-assisted player feedback |
| Pricing | Public tiers from €195/month | Two published tiers + 30-day trial; full engine is custom Enterprise |
What Pragma and Metaplay are
Pragma calls itself a backend game engine. It was founded in 2020 by Chris Cobb (a former Riot Games engineering lead) and Eden Chen, and has raised funding (including a $12.75M round) from backers such as Square Enix, Upfront, Greylock, and Insight (GamesBeat). Its team includes engineers who worked on live-service platforms behind games like League of Legends and Plants vs. Zombies.
Pragma targets studios building online and live-service games, supports both Unreal and Unity through client SDKs, and powers titles including Predecessor, Stormgate, Seekers of Skyveil, People Can Fly's projects, and Gardens.
Metaplay was founded in 2019 by people with backgrounds in the game and software industries. It ships as full source code and is hosted by default on Metaplay Cloud, a managed service Metaplay operates on AWS: game logic is written once in C# and runs on both the Unity client and the .NET server, with the server holding authority over all state. Self-hosting in your own AWS account is available through the Private Cloud plan. Studios using Metaplay include Metacore, Trailmix, and Lessmore.
Both are server-authoritative and both give you the source. What separates them is engine focus, which features sit behind a sales conversation versus a published price, and the kind of game each one is shaped for.
Pragma is engine-agnostic with strong Unreal support; Metaplay is Unity-first with shared client/server logic. A Pragma deployment assumes a competitive multiplayer title with dedicated servers. A Metaplay deployment assumes a Unity live-service game tuned through configs.
Architecture: shared C# logic versus Kotlin services
| Aspect | Metaplay | Pragma |
|---|---|---|
| Server language | C# (.NET) | Kotlin (JVM) |
| Client SDKs | Unity (C#) | Unreal and Unity |
| State authority | Server-authoritative | Server-authoritative |
| Custom logic | Direct C# modification | Kotlin plugins and custom services |
| Data store | Aurora MySQL (cloud), SQLite (local) | MySQL |
| Hosting | Metaplay Cloud (managed on AWS); self-host via Private Cloud | Your cloud, self-hosted, or Pragma-managed |
How Pragma's architecture works
Pragma runs on the JVM with Kotlin and uses MySQL as its only datastore. Its documentation is explicit that it needs nothing else: "Pragma requires only the JVM and MySQL to run. There are no other dependencies such as key-value stores, distributed caches, message queues, etc." (Pragma architecture). That keeps the production dependency list short for a platform team to operate.
Services run on Pragma nodes split into two operating modes: Social nodes handle cross-platform accounts, authentication, and session signing across multiple titles, while Game nodes run game-specific services like matchmaking, inventory, and progression. Gateways accept WebSocket and HTTP traffic encoded as protobuf or JSON. For local development the whole stack packages into a single executable; in production it runs as a standard microservice topology across nodes (Pragma architecture).
Customization is layered: configure ready-made features, write Kotlin plugins that inject code into Pragma's own services, or author entirely new services from scratch. Game-specific data attaches through a typed extension-data mechanism that the engine stores and retrieves without inspecting the fields.
How Metaplay's architecture works
Metaplay compiles game logic for both Unity (client) and .NET (server). When a player takes an action it runs locally on the client for responsiveness, then the server validates and persists it. If client and server state diverge, the server wins (Metaplay execution model).
A rule written once behaves identically in both places. That removes a class of client/server sync bugs and makes client-state tampering harder. The shared-logic model is built around Unity and C#. A game on Unreal or a custom engine can talk to a Metaplay server over its protocol, but it does not get the shared-logic benefit, which applies to Unity teams. Pragma's services are agnostic to what your client logic is written in.
AI and developer tooling
AI appears in two places here: tooling that helps your team build (assistants, MCP servers, codegen), and ML that runs inside your live game (churn prediction, ML matchmaking, moderation). Metaplay has shipped developer AI tooling in public preview. Pragma markets neither category as a core feature.
| Dimension | Metaplay | Pragma |
|---|---|---|
| Developer AI tooling | Metaplay Agent (public preview): SDK "skills" for Claude Code, Cursor, and similar, plus Docs and Portal MCP servers and the MetaplayGPT docs chatbot | No AI coding assistant, MCP server, or code generation documented |
| In-product AI / ML | None built in; matchmaking, segmentation, and A/B testing are rules- and config-based; analytics stream to your own warehouse | None documented; the FirstLook product offers AI-assisted player-feedback analysis (social listening and surveys) |
Metaplay's AI investment is in developer and operator tooling. The Metaplay Agent installs SDK skills so a coding agent works like a Metaplay developer, and the Docs and Portal MCP servers expose documentation, SDK source, and live infrastructure to AI tools.
Because you own the source, an agent reads the system it is changing instead of working from an API surface alone. It is a public preview, so its capabilities are still expanding.
Pragma is built around competitive-multiplayer infrastructure rather than AI tooling. It does not document a developer AI assistant, an MCP server, or in-product ML; the closest reference is AI-assisted feedback analysis in its FirstLook product.
LiveOps: packaged tooling versus build-your-own
| Feature | Metaplay | Pragma |
|---|---|---|
| A/B testing | Config-variant experiments with audiences | Not a packaged feature; build via configs and services |
| Remote config | Game Configs from Google Sheets/CSV, OTA | Configuration-driven services |
| Scheduled content | Calendar scheduling for events, offers, broadcasts | Build via custom services |
| Player segmentation | Segments by player properties | Build via custom services |
| Live monitoring | Grafana infrastructure dashboards | Built-in monitoring and alerts |
| Telemetry | Analytics events to S3/BigQuery | Live dashboards, custom metrics, big-data pipeline |
| Dashboard | Customizable Vue.js LiveOps Dashboard | Studio and player web portals |
Pragma's LiveOps tooling is centred on operating the backend: built-in monitoring, alerting, telemetry dashboards, a big-data pipeline, and a managed-services option that can run dev ops for you, including custom backend work, with 24/7 coverage on its Premium support tier (Pragma engine). Content tuning works differently. Experiments, segmented offers, and scheduled events are things you assemble from Pragma's services and configuration rather than turn on as a feature.
Metaplay ships those content-tuning tools as packaged features: A/B testing with audiences and rollout percentages, game configs driven from Google Sheets or CSV and published over the air without a client update, live events with scheduling and phases, in-game offers, and player segmentation.
The Vue.js LiveOps Dashboard ships as source, so you can add game-specific pages and actions. Metaplay gives you the tuning toolkit ready to use and hosts and operates the backend for you on managed Metaplay Cloud (with Grafana dashboards), rather than running a managed dev-ops desk that does custom backend work on your behalf; self-managed AWS operation is the Private Cloud option.
Player management and identity
| Feature | Metaplay | Pragma |
|---|---|---|
| Device / anonymous auth | Yes | Yes |
| Email / password auth | Yes | Yes |
| Social and platform login | Google, Apple, Facebook, Steam | Cross-platform account integration |
| Cross-platform identity | Yes | Yes (cross-play, cross-progression) |
| Player profiles | PlayerModel, fully customizable | Account and player data services |
| GDPR tooling | Built-in export and deletion | GDPR and platform compliant |
| Support tooling | LiveOps Dashboard player tools | Admin and customer-support tools |
Pragma's accounts service is built for cross-platform play across consoles and storefronts, with cross-play and cross-progression, friends, and presence handled as first-class services and shared across multiple titles in one deployment (Pragma engine). A studio shipping a multi-platform title across PlayStation, Xbox, Switch, and PC at once gets that consolidation built in.
Metaplay handles authentication with anonymous device login, social logins (Google Play Games, Apple Game Center, Facebook, Steam), and cross-device recovery. Player state lives in a customizable PlayerModel, and the dashboard includes player search, state inspection, action history, mail and rewards, banning, and GDPR export and deletion.
Console-specific auth flows (Xbox, PSN, Nintendo) are a custom integration rather than a built-in connector. Pragma ships those connectors as first-class services; with Metaplay, console identity is a custom integration.
Economy: mobile monetization versus console commerce
| Feature | Metaplay | Pragma |
|---|---|---|
| Virtual currencies | Multiple types, server-authoritative | Virtual currency support |
| Inventory | PlayerModel collections, data-driven | Inventory, loadouts, instanced items |
| Entitlements / DLC | Via game logic | Entitlements, fulfilments, content grants, DLC |
| IAP validation | Apple, Google Play, Steam (server-side) | Platform commerce integration and certifications |
| Transaction authority | Server-authoritative | Server-side |
| Source access | Yes (all paid tiers) | Yes (Enterprise) |
Pragma's commerce layer is designed around platform storefronts: entitlements, fulfilments, content grants, consumables, permanents, and DLC, with built-in integration to major game platforms and help with platform certification (Pragma engine). Inventory extends to loadouts and instanced items, which suits gear-driven shooters and competitive titles where what a player owns and equips is part of the gameplay.
Metaplay's economy is server-authoritative by default. Currencies and inventory are PlayerModel state managed through validated player actions; items are defined in game configs for data-driven balancing.
IAP validation runs server-side for the App Store, Google Play, and Steam, and offers combine IAP products with rewards, placements, segment targeting, and schedules. Its commerce features are oriented toward mobile free-to-play monetization; Pragma's are oriented toward console DLC, entitlements, and platform storefronts.
Multiplayer and matchmaking
| Feature | Metaplay | Pragma |
|---|---|---|
| Matchmaking | Async, MMR-based | Synchronous, skill-based |
| Real-time / synchronous match flow | Not built in | Yes |
| Parties | Guild framework | Parties with invites, shared state, loadouts |
| Game server integration | Multiplayer Entities (custom servers) | Dedicated and peer-to-peer server integration |
| Drop-in/out, battle royale | Build via Multiplayer Entities | Supported match modes |
| Voice chat | Integrate third party | Integrate third party |
This is where the two backends target different kinds of game. Pragma's matchmaking is server-authoritative and skill-based, with parties (invites, shared state, loadouts), drop-in/drop-out, and battle-royale modes, plus integration for dedicated and peer-to-peer game servers. That set of features is built for competitive shooters, MOBAs, and battle royales.
Metaplay's matchmaker is asynchronous, using MMR buckets for fast opponent lookup. That fits turn-based, async PvP, and progression-based matching, not synchronous real-time matches.
For custom real-time entities like battles and sessions, Metaplay provides the Multiplayer Entities system, but there is no built-in synchronous matchmaker and no built-in physics for FPS-style authoritative hit detection. Real-time competitive matchmaking is therefore handled by Pragma's services and not by Metaplay's. Neither platform ships voice chat; both expect a third-party integration.
Pricing: published tiers versus a per-day DAU model
This is one of the larger differences, and the two backends publish their numbers differently.
Pragma pricing
Pragma publishes pricing for two packaged tiers, with the full engine sold as a custom Enterprise deal. From its pricing page:
| Plan | Price | Includes |
|---|---|---|
| Accounts & Social | $1,499/month + $0.35 per 100 DAU | Accounts, social, sessions |
| Accounts, Social & Commerce | $2,499/month + $0.70 per 100 DAU | Adds the commerce stack |
| Enterprise | Custom | Adds matchmaking, player data, telemetry, plugin hosting, full source, custom MSA |
| Trial | Free, 30 days | Evaluate before committing |
The published tiers cover accounts, social, and commerce. Matchmaking and player data sit in the Enterprise tier, which is quoted custom and starts with a demo, so the entry point to Pragma's competitive-multiplayer features is a sales conversation rather than a self-serve sign-up.
The 30-day trial lets you evaluate the packaged tiers first. The figures above are a snapshot; pragma.gg/pricing is the authoritative source and prices change.
Metaplay pricing
Metaplay publishes its full pricing. Every tier includes every feature, and the source code comes with all paid tiers.
| Tier | Price | Includes |
|---|---|---|
| Free | €0 | Local development, full SDK |
| Starter | €195/month | 1 mini environment, 5 DAU cap |
| Pre-Launch | €995/month | 2 small environments, 100 DAU cap |
| Production | €1,985/month + €2.95 per 1,000 DAU | Staging + production, first 5,000 DAU/day included |
| Private Cloud | Custom | Self-hosted, built for >1M DAU |
Source: Metaplay pricing.
The €2.95 per 1,000 DAU on the Production tier is a daily licence fee, billed every day and added up across the month, not a flat monthly charge. The first 5,000 DAU each day are included.
So for a game holding 100,000 DAU every day of a 30-day month: daily billable DAU is 100,000 − 5,000 = 95,000, the daily licence fee is 95,000 ÷ 1,000 × €2.95 = €280.25, and the monthly licence fee is €280.25 × 30 = €8,407.50. Add the €1,985 base and the total is €10,392.50/month. At a steady 50,000 DAU the same maths gives about €5,967.50/month; at 500,000 DAU, about €45,792.50/month. The worked example on the pricing page covers the calculation, and per-day billing changes the total at scale.
To put €10,392.50/month in context, that is roughly the fully loaded cost of one experienced backend engineer. The alternative to a managed platform is building and operating these systems in-house, which means staffing a full backend and DevOps team for the life of the game. Among the options here, Metaplay is the only one that delivers a source-available backend as a managed service, so a studio gets those systems without building that team and without lock-in. Metaplay's own analysis puts an in-house backend build at around $21M over a typical multi-year build: The true cost of building your own backend.
The units differ, so a direct comparison takes some conversion. Pragma bills per 100 DAU on its published tiers and quotes the rest custom, while Metaplay bills per 1,000 DAU per day with a published formula. Metaplay's full production cost is published and can be modelled from the formula; Pragma's matchmaking and player-data features are priced through an Enterprise quote.
Engine support
| Aspect | Metaplay | Pragma |
|---|---|---|
| Unity | Full support (shared C# logic) | SDK available |
| Unreal | Protocol access only | SDK available |
| Custom engines | Protocol access | Possible via SDK / integration |
| Shared client/server logic | Yes (Unity/C#) | No (backend services model) |
Pragma is engine-agnostic with first-class Unreal support, which fits AAA and console multiplayer projects built on Unreal. Metaplay is Unity-first and trades engine breadth for the shared C#/Unity logic model. For a game on Unreal, Pragma provides a dedicated SDK; Metaplay offers protocol access only.
Source access and deployment
| Aspect | Metaplay | Pragma |
|---|---|---|
| Source provided | Yes, all paid tiers | Yes, Enterprise tier |
| Deployment | Metaplay Cloud (managed on AWS); self-host via Private Cloud | Your cloud, self-hosted, or Pragma-managed |
| Data ownership | You own it | You own it |
| Managed dev ops | Metaplay Cloud | Pragma managed services |
Both give you the source code and no lock-in: you can read, modify, fork, and migrate it. They diverge at where source sits in the pricing: Metaplay includes it in every paid tier, while Pragma's full source comes with the Enterprise tier.
By default Metaplay hosts and operates the backend for you on managed Metaplay Cloud, which Metaplay runs on its own infrastructure on AWS (not GCP or Azure); self-hosting in your own AWS account is the Private Cloud plan. Pragma additionally offers a fully managed dev-ops service that can run your backend end to end, including custom work.
When each platform fits
| If you need... | Consider |
|---|---|
| Unreal Engine or an engine-agnostic backend | Pragma |
| Unity with shared client/server logic | Metaplay |
| Synchronous, skill-based competitive matchmaking | Pragma |
| Async or progression-based matchmaking | Metaplay |
| Console-first cross-play and cross-progression | Pragma |
| Mobile F2P live-service with fast config iteration | Metaplay |
| Parties, loadouts, drop-in/out match modes | Pragma |
| Packaged A/B testing, OTA configs, segmented offers | Metaplay |
| Public, self-serve pricing from a low entry point | Metaplay |
| A AAA platform team that wants managed dev ops | Pragma |
| Source access at a low tier | Metaplay |
| Entitlements and DLC-heavy console commerce | Pragma |
Pragma is built for Unreal-based AAA and competitive multiplayer games: shooters, MOBAs, and battle royales where synchronous matchmaking, parties, dedicated-server integration, and console commerce are core requirements, delivered through an Enterprise engagement that can include managed dev ops. Metaplay is built for Unity live-service and free-to-play teams that want shared C#/Unity logic, packaged LiveOps tuning tools, and published self-serve pricing.
The dividing lines are engine (Unreal versus Unity), matchmaking shape (synchronous versus async), and how the engine is bought (Enterprise quote versus self-serve tiers).
To talk through which side of those lines your game falls on, get a demo.
Frequently asked questions
Does Pragma have free pricing or a trial?
Pragma offers a 30-day free trial. It does not publish a permanently free tier; after the trial you move to one of its paid plans (Accounts & Social, or Accounts, Social & Commerce) or to a custom Enterprise quote (Pragma pricing). Metaplay's free tier is permanent for local development with the full SDK, and paid tiers start at €195/month.
What games use Pragma?
Pragma powers titles including Predecessor, Stormgate, Seekers of Skyveil, projects from People Can Fly, and Gardens. Spectre Divide also ran on Pragma but was sunset in April 2025, so it is no longer a current example. The common thread is competitive and live-service multiplayer, which matches what the engine is built for.
Is Metaplay or Pragma better for a mobile game?
It depends on the mobile game. For a Unity mobile free-to-play game, Metaplay provides shared C#/Unity logic, server-side IAP validation for the App Store and Google Play, data-driven game configs published over the air, and packaged offers and segmentation aimed at mobile monetization. Pragma's synchronous matchmaking, console commerce, and cross-platform parties are built for competitive multiplayer and console titles, including a mobile game that is a real-time PvP title rather than a progression or economy game.
Can Metaplay be used with Unreal Engine?
Metaplay is designed for Unity. A game can connect to a Metaplay server over its protocol, but the shared client/server logic feature requires Unity and C#. Pragma provides a dedicated Unreal SDK for Unreal titles.
Is Pragma open source?
No. Pragma provides full engine source to Enterprise customers and is built from source like a game engine, but it is a commercial, source-available product, not open source (Pragma engine). Metaplay is likewise source-available rather than open source: the C# server, Unity SDK, and Vue.js dashboard ship as source in all paid tiers.
Which has better matchmaking?
It depends on the game. Pragma offers server-authoritative, skill-based, synchronous matchmaking with parties and match modes for competitive titles such as shooters and MOBAs. Metaplay's matchmaker is asynchronous and MMR-based, which suits async PvP and progression-based matching such as turn-based and progression games, but not synchronous real-time matches.
How much does each platform cost?
Metaplay publishes tiers from €195/month, with a Production tier at €1,985/month plus €2.95 per 1,000 DAU charged per day (first 5,000 DAU/day included), so a 100,000-DAU game runs about €10,392.50/month (Metaplay pricing). Pragma publishes two tiers, Accounts & Social at $1,499/month plus $0.35 per 100 DAU, and Accounts, Social & Commerce at $2,499/month plus $0.70 per 100 DAU, along with a 30-day trial, while the full engine with matchmaking and player data is a custom Enterprise quote (Pragma pricing).
Can I self-host either platform?
Yes. Metaplay's Private Cloud plan provides Terraform modules and Helm charts for self-hosted AWS deployment. Pragma can run self-hosted, in your own cloud, or on its managed services. Both keep your data in your control.
Related comparisons
- Metaplay vs AccelByte: another AAA and cross-platform backend, compared head to head.
- Metaplay pricing: the full per-day DAU model with a worked example.
- Get a demo: talk through your engine, game type, and which backend fits.
Last updated: June 2026. Pricing and features may change. See Metaplay pricing and Pragma for current information, or get a demo to talk through your project.
