Halo 4 and 5 use a project developed “in house” at Microsoft called Orleans. Roughly speaking it is similar to Akka. It’s an actor based distributed system which attempts to hide the implementation of distributed networking. In essence, each match and each player get their own “network attached“ object (a “grain” in Orleans terms.) So:
var player = new Player(123);
is actually instantiated _somewhere_ on the network (not necessarily locally on the calling server.) Then operating on that object, such as:
await player.FireWeapon();
tells the server (“silo” in Orleans terms) which owns that player instance to invoke that method on it.
In this way, it is very easy to quickly update game state without obsessing over the throughput of a single machine.
Orleans provides higher level abstractions than Akka. It is literally a plug 'n play distributed application kit and consequently very opionated.
It took me quite some time to shift my mental model and decide I prefer it over Akka. It's also worth noting that Orleans is open source. There is also an excellent operational dashboard named OrleansDashboard.
The dashboard is visually great but misleading in functional usefulness. Much like any distributed computing framework, it’s marginally useful, at best, to view a single computation’s flow or result. The dashboard shows grain (actor) success/failure calls but as there can be any number of typographical arrangement of grain execution calls it really is mostly an aesthetic dashboard.
I’m only pointing this out because it’s easy to spend a lot of time trying to use the dashboard as a dev tool instead of focusing on good logging techniques. There has been a lot of great work put into the dashboard and I certainly don’t want to take away from that.
We used Orleans for our service framework for Breach, a 4v1 asymmetric action RPG built with Unreal Engine 4. While all the real-time simulation was implemented authoritatively as part of an Unreal Engine 4 server, we used Orleans/SignalR for the service backend. Services included: matchmaking, (voice)chat, character/account persistence, quests, microtransactions, customer service, and friends among others.
It's a great framework and I hope others adopt it for backend services. My only complaint, and it isn't particular to Orleans, is that there isn't a lot of examples that demonstrate best practices for building large applications with it. There is definitely a "right" and wrong way to build with Orleans and it can take you a while, and a lot of refactoring, to discover that.
> which attempts to hide the implementation of distributed networking
To be fair, this is precisely what Akka doesn't do, often citing A Note on Distributed Computing (1994) which explains why that approach is problematic.
In this way, it is very easy to quickly update game state without obsessing over the throughput of a single machine.