Pragma Engine vs Crux (2026): Pricing, Source Access & Fit

If you are comparing Pragma Engine vs Crux, do not start from studio size. Start from the backend you intend to own.

Pragma is designed to become part of your backend engineering environment: run it locally, inspect and modify the source, extend built-in services, build custom services, and then use Pragma-managed environments/support in production. Crux deliberately exposes a much smaller managed contract: authentication, player/project documents, stats and achievements, leaderboards, economy primitives, social/friends, live config, exact-pair matchmaking, server registry, webhooks and SDK/API access. You cannot fork Crux's backend implementation.

Pragma vs Crux at a glance

Decision	Pragma Engine	Crux
Public entry price	30-day trial; Live Service package starts at $6,000/month	Dev $0; Launch $10/month; Scale $79/month; Custom above that
Source ownership	Full engine source access; modify services and build custom services	Managed service; API/SDK contract, no backend source access
Hosting model	Managed hosting is part of the current commercial offer; Pragma also emphasizes local end-to-end development and source-level control	Managed BaaS operated by Supercraft; Runtime game-server execution is a separate capacity-gated closed alpha
Feature breadth	Cross-platform accounts, social, parties, commerce, matchmaking, player data/metagame, live operations, telemetry/analytics, portals and custom services	Auth, documents, stats/achievements, leaderboards, economy primitives, friends, live config, exact-pair matchmaking, server registry and webhooks
Game-specific backend logic	First-class extension model inside the backend engine	Keep custom game logic in your own services/game servers and call Crux over its API
Operator surface	Broad player/operator portals, analytics and live-service tooling	Smaller customer dashboard focused on projects, credentials, data/configuration, usage and BaaS administration
Procurement shape	Sales/support relationship becomes part of production; public starting price is now visible	Self-serve public tiers for the standard BaaS plans

What the $6,000/month Pragma starting point actually includes

The public number is more useful than the old “contact sales, assume enterprise pricing” shorthand. Pragma's current Live Service offer says starting at $6,000/month and bundles:

• full platform/source access;
• managed infrastructure from development through launch;
• analytics and dashboards;
• Standard product support; and
• $1,000/month in cloud credits applied to managed infrastructure costs.

Pragma separately publishes analytics usage pricing: the first 2 million events/month are free, then $25 per million events. Production launches require the support/operations shape Pragma documents for live games, so compare the complete launch package rather than treating $6,000 as a bare API fee.

Crux's public plans are intentionally much smaller: Dev covers 10,000 MAU, Launch 25,000 MAU / 25M API calls, and Scale 500,000 MAU / 500M API calls. Those numbers are not evidence that Crux replaces Pragma at the same functional depth. They describe a narrower service.

Where Pragma is the stronger fit

You want the backend to be part of your codebase

This is the clearest distinction. Pragma exposes the engine source, supports local end-to-end development, lets teams modify existing services, and lets them build custom services within the platform. If a progression system, commerce flow, party workflow or matchmaking policy is product-defining, that extension model can be the reason to choose Pragma.

You need broad cross-platform live-service systems

Pragma's current product surface includes cross-platform accounts/social, parties, commerce/entitlements across major platforms, sophisticated matchmaking, player-data/metagame systems, live operations, telemetry/analytics and player/operator portals. Crux does not currently offer an equivalent party/clan system, commerce-provider abstraction, full operator portal or arbitrary backend-service runtime.

You want launch engineering and 24/7 operational support in the package

Pragma explicitly sells launch readiness, load testing, production monitoring, incident response and higher support tiers. Its professional-services organization can also build custom systems and migrations. For a studio that wants the backend vendor deeply involved in launch operations, that is part of the product rather than incidental support.

Where Crux is the stronger fit

Your backend problem is smaller than a backend engine

If your game needs authenticated players, cloud-save style documents, stats/achievements, leaderboards, basic economy/inventory mutations, friends, live config and a server registry, adopting a source-extensible backend engine may be unnecessary platform surface.

That does not mean “Pragma is overkill for indies” as a universal rule. It means you should compare the features you actually need against the engineering model you want to own.

You want self-serve pricing and a managed API boundary

Crux's standard tiers are visible and can be started without an enterprise procurement process. The tradeoff is exactly the thing Pragma sells as a strength: you do not get Crux's backend source or an in-platform custom-service runtime.

You already own the game-specific logic elsewhere

If your authoritative server or your own application services already own matchmaking policy, progression rules, entitlement decisions and game-specific workflows, a smaller persistence/auth/config layer can be preferable to moving those rules into another backend engine.

Matchmaking is not an apples-to-apples feature

Do not compare both products by checking a “matchmaking” box.

Pragma advertises server-authoritative matchmaking with customizable ranking, drop-in/out, server switching, battle-royale and extraction workflows. Crux currently provides a much narrower matcher built around exact game_mode + region pairing and optional Runtime allocation. It is not a Pragma-style extensible SBMM system.

If matchmaking quality is central to your game, this difference can outweigh the entire price comparison.

Commerce and platform identity are another major difference

Pragma exposes a unified monetization layer across major game platforms and built-in account/platform integrations. Crux has economy primitives, but it does not currently provide a generalized storefront/receipt/entitlement abstraction across Steam, PlayStation, Xbox and Epic.

Crux now has native server-verified Steam ticket login, plus Google/GitHub/Discord OAuth and guest/email auth, but that is still a much smaller identity/commerce surface than Pragma's cross-platform account stack.

Hosting: the old comparison is obsolete

The old version of this page said Pragma was essentially self-hosted while Crux was managed. That is no longer accurate. Pragma's public package explicitly includes managed hosting that grows from development to production. It also retains source access and local-development control.

Crux is managed too, but its BaaS and Runtime are separate products. Crux Runtime is still a capacity-gated closed alpha with a narrow Godot/Linux/EU/ephemeral-session scope. Do not treat it as a general replacement for Pragma's game-session/server orchestration.

A better decision test

If this statement is true...	Start with...
We need to modify backend systems and build custom backend services inside the platform.	Pragma
Parties, cross-platform commerce, rich matchmaking and operator tooling are first-order requirements.	Pragma
We want the vendor involved in launch engineering, monitoring and live operations.	Pragma
We mostly need managed auth/data/leaderboards/config with a small API contract.	Crux
Our game-specific backend logic already lives in authoritative servers/services we own.	Crux is worth validating
We cannot justify a $6,000/month platform starting point for the feature set we need.	Validate a narrower managed BaaS before committing

Do a proof, not a feature-grid decision

For either platform, take one real vertical slice from your game:

1. authenticate the real platform identity you plan to ship;
2. load and mutate one player progression object;
3. run the actual matchmaking/admission path;
4. persist one trusted match result or economy mutation;
5. inspect it from the operator/admin surface;
6. simulate a retry, outage and schema change; and
7. price the expected production workload and support model.

If that exercise immediately requires custom services, party/commerce workflows or sophisticated matchmaking, Pragma's larger platform is doing useful work. If the vertical slice fits inside a smaller managed API and your game-specific rules already live elsewhere, Crux's narrower model may be the better economic and architectural fit.

Bottom line

Pragma and Crux now overlap enough to compare, but they are still different product shapes. Pragma is a source-access backend game engine plus managed production platform. Crux is a narrower managed game BaaS. Pragma's current public starting price makes that tradeoff unusually easy to quantify: pay for the larger extensible platform when you need it; do not buy it merely because your game is “serious,” and do not choose Crux merely because your studio is small.