




MetaGravity’s HyperScale Engine: The New Standard for Supermassive Game Development.
The growing demands of large gaming experiences like MMORPGs, digital twins and virtual events, and highlight the limitations of traditional architectures such as zoning, instancing and spatial partioning. They struggle to manage thousands of concurrent users while maintaining responsiveness and immersion, especially in the face of complex AI NPCs, user-generated content, and ever-increasing player counts.
This rigidity stifles creativity and hinders the development of truly boundless, immersive experiences. A new approach is needed to unlock the full potential of the virtual world.
All of the network architectures below share many limitations for the player and the world builder:
Zoning and instancing only allow for clusters of 80-100 concurrent players reducing interactivity, immersion and have huge gameplay and design repercussions. Spatial partitioning creates exponential synchronisation bottlenecks, restricting player concurrency to a few thousand or tens of thousands at a huge cost.
Linear scaling of servers or tiles for zoning and spatial partitioning hikes operational costs with the size and complexity of the world rather than the number of players and is an inefficient use of server distribution.
Users are forced to interact with zones and instances in these experiences, creating disruptions to the immersion and experience.
Single points of failure within zones, instances, or server clusters can disrupt gameplay for large player segments.
Divides the virtual world into discrete, geographically-defined zones, each processed by a dedicated server. Clients switch servers as they move between zones.
Efficiently distributes workload, ideal for large, sparsely populated worlds.
Each zone can only handle up to 100 players therefore limiting the direct interaction between players in different zones and creates artificial boundaries.
Creates multiple, independent copies of popular areas ("instances") to manage congestion. Instances run on separate servers, accessible only to players within them.
Alleviates server strain in high-density areas, facilitates group activities without overcrowding.
Restricts broader player interaction within the instance, can disrupt immersion due to artificial separation.
Divides the world into smaller geometric units (tiles) processed by separate servers. Entities are associated with tiles, enabling parallel processing and localised updates.
Allows for greater concurrency on the basis of much higher bandwidth and power consumption than instancing and zoning.
Limited scalability (typically ~20,000 players) due to synchronisation bottlenecks between tiles. Because it requires linear scaling of tiles, the operational cost increases by a factor of 10-300x (on an average cost per user per month basis) over existing multiplayer networking solutions. As the as the game scales, the data synchronisation burden also grows exponentially, creating huge demands on servers for various game play scenarios. All existing spatial partitioning platforms require games to be rebuilt by studio teams writing lower level code outside of the major game engine development environments.
EVE: Aether Wars (only operational in tech demo), Star Citizen.

MetaGravity HyperScale Engine underpinned by our trademarked Causal Partitioning ™ technology. This novel approach redefines how multiplayer games and interactive virtual worlds can be developed, forging a paradigm shift in player concurrency, cost efficiency and integration with today's game development stack.
In stark contrast to the traditional Euclidean coordinate-based spatial partitioning, MetaGravity HyperScale Engine's Causal Partitioning ™ technology takes a radically different approach by parallelising the virtual world simulation based on the causal relationships between objects. Instead of location, Causal Partitioning ™ focuses on the causal relationships between objects. This means objects are grouped based on how they interact and influence each other, creating dynamic partitions that adapt to real-time events. This gives Metagravity Compute the edge for building digital worlds that have never existed before.
Unlike simplistic measures like “number of total concurrent users”, MetaGravity’s HyperScale Engine has built optimisation by considering key factors impacting all computational needs in a game. The resulting function is called Total Compute Budget.
This approach acknowledges that an immersive supermassive gaming experience depends not just on the number of concurrent users, but also on several crucial factors:
This equation highlights the interdependence of these factors. Using Compute Budget, HyperScale helps developers optimise this equation such as increase density while maintaining fidelity by lowering physics complexity, or support more users with simpler graphics.
With HyperScale, developers gain a more nuanced understanding of their project's needs and can make informed decisions to balance performance and scale effectively.
By decoupling processing from physical location, MetaGravity HyperScale Engine's Causal Partitioning™ technology eliminates the synchronisation bottlenecks inherent in other networking distribution architectures such as spatial partitioning. This opens the door to supporting significantly larger player populations, in the order of millions, within a single virtual world.
MetaGravity HyperScale Engine's novel use of Causal Partitioning ™ technology focuses on processing only the objects and interactions relevant to each player, leading to increased processing efficiency compared to approaches that simulate the entire world for everyone. This translates to lower operational costs.
The MetaGravity HyperScale Engine integrates seamlessly with existing and future game development tools, regardless of the game engine or cloud platform used. This eliminates the need for extensive code rewrites and allows developers to leverage familiar tools and workflows, significantly accelerating the development process.


MetaGravity empowers you to create supermassive worlds with unmatched performance, reliability, and ease of integration.