As a backend game developer, I instinctively analyze the technologies and strengths of every game I encounter. One recurring observation is that even “large-scale” game worlds are often constrained to limited player interactions within a single shard, with battles typically supporting only a few hundred participants.
Challenges like latency in cross-shard operations, inconsistent data management, and deadlocks under high concurrency have long deterred developers. Many abandon cross-shard features entirely due to the overwhelming complexity.
“Is the dream of a truly infinite world with massive real-time interactions beyond our reach?”
Driven by this question, I participated in an internal competition at IGG (I Got Games). I showcased a prototype that allowed tens of thousands of units to engage in real-time battles in an SLG environment. The technical capacity of the solution earned me first place.
Encouraged by this recognition, I embarked on a deeper exploration of a comprehensive solution, eventually developing an object-based distributed collaboration framework that addresses these longstanding bottlenecks.
Challenges of Traditional Shard Architectures
In traditional shard systems, each shard operates on separate threads or physical servers. This approach creates two critical challenges:
Latency and Performance Wastage in Cross-Shard Operations Blocking mechanisms cause severe delays, while non-blocking methods require significant effort to ensure data safety and consistency. The high-frequency interaction requirements of games exacerbate these issues.
Risk of Deadlocks Under High Concurrency Game logic operations often face resource contention, leading to deadlocks. Developers are forced to avoid real-time cross-shard interactions altogether.
These limitations result in isolated gameplay regions within shards, significantly restricting player interactions. Overcoming these challenges became the focus of my efforts.
The Solution: Object-Based Distributed Collaboration Framework
To tackle these challenges, I developed a new architecture that shifts the constraints from spatial limitations to task and object count. Here’s how the framework works:
- Distributed Object Management
Game objects are distributed across multiple logic servers. Each object’s autonomous behavior and player interactions are transformed into discrete tasks. These tasks operate within a virtual space called AccessSpace, ensuring consistency and security across servers through linear data spaces. - Parallel Task Execution
Tasks are executed concurrently on logic servers, which dynamically scale using a technology we developed called BitChain. This scalability is akin to web services, preventing latency issues caused by insufficient computational resources. - Low-Latency Data Synchronization
Changes to object states during task execution are streamed to proxy servers and propagated to nearby clients. This process, similar to CDN-like data distribution, significantly reduces latency. - Simplified Development Logic
Developers can focus on building in-game objects by inheriting a basic Entity Interface to define object attributes. Using flexible combinations of Components (attributes), Controllers (behavior), and Functions (operations), they can create a wide range of game elements.
Performance Testing: Exploring the Possibility of Infinite Worlds
We conducted a large-scale performance test simulating 60,000 players interacting in real-time within the same space: Watch the Demo
Test Environment: GCP, 61 Servers
- Logic Servers: 10 machines (2C4T each)
- Proxy Servers: 25 machines (2C4T each)
- Bot Simulators: 25 machines (4C8T each)
- Database Server: 1 machine (4C8T, MongoDB)
Performance Highlights: With processes running 3 network I/O threads and 4 logic services, a single logic server achieved 180,000 RPCs per second. The number of supported players is no longer bound by spatial constraints but instead by the number of objects affected by tasks.
For example, a task impacting 180 objects would take just 1 millisecond to execute on a single logic server.
Unlocking New Possibilities for Game Design
This technology allows developers to design gameplay without avoiding cross-shard interactions, making infinite-world games achievable. Although large-scale abilities like AOE still require task splitting, I am confident that ongoing optimizations will further minimize such constraints.
Reflection: A Decade of Innovation
The journey from concept to prototype spanned ten years. Many times, I considered keeping the technology to myself, thinking, “It’s too complicated to make it usable for others.” But my desire to advance backend technology pushed me forward. With support from Taiwan’s SBIR grant, I finally consolidated scattered components into a unified prototype.
I hope this technology inspires game developers to rethink the possibilities of shardless, infinite virtual worlds. I’m eager to collaborate with more developers to push the boundaries of what’s possible.
Let’s build the future of infinite worlds together!