Blizzard's Timothy Ford explains in this 2017 GDC session how Overwatch uses an Entity Component System architecture for layered gameplay. He also covers its server-authoritative netcode with client-side prediction and how they keep the game responsive and fair.
Why Hacker News points people here: HN treats it as the best real-world AAA example of ECS and game netcode, and cites it constantly in discussions of data-oriented design.
“This Overwatch GDC talk is the best breakdown/example of data-oriented ECS in a AAA game that I know of”HN comment, 2021
“Blizzard's GDC talk about it is really good if you want an explanation of how to make a game feel responsive and fair”
Explains server-authoritative netcode making games responsive and fair
Full comment
Overwatch allows none of that and seems to have some pretty well-designed netcode. Clients only send their controller inputs and the server has full authority of what actually happens. Blizzard's GDC talk about it is really good if you want an explanation of how to make a game feel responsive and fair without giving clients authority over everything [1]. Ofc this does not eliminate aimbot or wallhacks, but it gets rid of pretty much all other forms of cheating. [1] this video (Netcode talk starts at 22:22)
Strongly recommendsDecoPersonSep 2020
“I can highly recommend it as a good resource to learn about ECS”
Good resource to learn about ECS from the Overwatch team
Full comment
Entities are a collection of component instances and nothing more. Components in ECS are data-only. Systems in ECS are logic-only. If you follow this strictly, then you cannot support encapsulation or data-hiding. There is no sole definition of OOP, but it is widely accepted that the ability to do encapsulation, including data-hiding, is a key part of OOP. Therefore, ECS is not OOP. QED If you’ve not seen the Overwatch team’s talk in which they discuss ECS, I can highly recommend it as a good resource to learn about ECS: this video There may be models commonly used in those languages you mentioned that are similar to ECS, but you seem to be implying that ECS is a form of OOP; it is not. Even if you implemented OOP using Structs of Arrays, a thread per object, or whatever you like, you cannot strictly conform with ECS’s requirement that “components have no logic” while also strictly conforming with OOP’s requirement that “objects should not know about each others’ internals” (object hierarchy).
Strongly recommendsnightskiJan 2021
“There is a fantastic GDC video about Blizzard's use of ECS in Overwatch”
How ECS made Overwatch's interacting subsystems easier to understand
Full comment
There is a fantastic GDC video about Blizzard's use of ECS in Overwatch and how it made it far easier to understand the system due to all of the interacting subsystems. this video
Strongly recommendsBekwnnJun 2021
“This Overwatch GDC talk is the best breakdown/example of data-oriented ECS in a AAA game that I know of”
Best breakdown of data-oriented ECS in a AAA game
Full comment
> The components on the entity define not only it's data but also it's behavior by the set of systems that act on the corresponding components. And you can take these object definitions and inherit them to add additional behavior or change the existing behavior by adding more components to the new definition. This seems to miss what ECS actually is, unless you're just referring to the old-school way of doing entity components and not the data-oriented way. Data-oriented ECS way of doing things is to separate state and behaviour. Entity components essentially become structs where their only behaviour is potentially some getter/setter utilities. Behaviours are then state-less systems (just functions, essentially) which act on a set of components. For example, a PhysicsUpdateBehaviour might take in a RigidBodyComponent and a HealthComponent to perform a physics update and apply physics/fall based damage. The main benefit of ECS (imo) isn't even really performance. It makes code in complicated game projects much easier to manage by clarifying the game loop and by making it much more obvious how and when entity state is being modified. It's the kind of thing that potentially complicates a smaller project, but makes larger more complex projects easier to manage. This Overwatch GDC talk is the best breakdown/example of data-oriented ECS in a AAA game that I know of: this video
Strongly recommendsadampkSep 2021
“My favorite resource to explain ECS + NetCode”
Favorite resource explaining ECS and netcode in Overwatch
Full comment
this video "In this 2017 GDC session, Blizzard's Timothy Ford explains how Overwatch uses the Entity Component System (ECS) architecture to create a rich variety of layered gameplay." (My favorite resource to explain ECS + NetCode)
Strongly recommendsbcrosby95Dec 2023
“There's an awesome talk by someone in the overwatch team in youtube.”
ECS talk with useful networking tips
Full comment
There's an awesome talk by someone in the overwatch team in youtube. It's about ECS but it has a big section on networking that had some useful tips. Edit: here it is - this video
RecommendsendgameApr 2019
“it really seems like you have to go against your OO instincts to create larger simulations”
Shows why large simulations need to depart from OO instincts
Full comment
> running a simulation (what OOP was invented for) I used to believe that. I no longer do. Among other things, I watched this talk about Overwatch's architecture and it really seems like you have to go against your OO instincts to create larger simulations: this video
RecommendsmtsrMay 2020
“this video has a great general overview”
General overview of Overwatch netcode, light on technical detail
Full comment
Since you generally want to keep a set number of time steps the commonly used data structure for this is a ring buffer. No garbage and all you do is increment the index (with wraparound) every step. Not a lot of technical details, but this video has a great general overview this video
RecommendsMirioronMay 2020
“Here is a talk by Timothy Ford about Overwatch's netcode (it's really fascinating)”
Talk on Overwatch netcode and client prediction with server authority
Full comment
The important two points are that the client must react immediately to a user's input, but at the same time the server has to have the authoritative game state. One way of doing that is that the server runs the authoritative simulation and the clients send input to the server, but the clients also run their own simulations. In some games the client will try to predict what the server will do. If there's a conflict with what the client simulates compared to the server then the client gets rolled back to the server's state. This usually happens when there's a second player that interferes in some way. Here is a talk by Timothy Ford about Overwatch's netcode (it's really fascinating): this video
RecommendsrcxdudeJul 2020
“Here's an interesting presentation on Overwatch's ECS system”
ECS design makes safely parallel parts of the system easy to identify
Full comment
Here's an interesting presentation on Overwatch's ECS system, though he doesn't go into great detail in terms of multithreading, he points out how the design makes it easy to identify what parts of the system can be safely run in parallel. this video
Recommendsnikki93Sep 2020
“I think this talk on how an ECS actually reduced coupling in the case of Overwatch would be a good concrete real world example to look at.”
Concrete real-world example of ECS reducing coupling in Overwatch
Full comment
this video I think this talk on how an ECS actually reduced coupling in the case of Overwatch would be a good concrete real world example to look at. It enabled some architectural benefits for implementing replay cameras or for networking code in their game through actual reduced coupling between input ->commands and commands->simulation.
RecommendsmilesvpFeb 2021
“the parts talking about the netcode are quite amazing”
ECS architecture separating data and functions, plus impressive netcode prediction
Full comment
Your comment made me feel compelled to mention a Blizzard talk I came across recently on the ECS (Entity Component System) architecture they used for Overwatch. It looks suspiciously like a function first architecture in that they don't allow mixing of data and functions. I'm not sure how purely functional it is, but it certainly strikes me as the kind of architecture that Carmack would appreciate in dealing with complexities that lead him to a more functional programming style. This talk is 3 years after release, and includes all the hindsight they gained from that. Also, the parts talking about the netcode are quite amazing, and the precision of their predictors that they attribute to using ECS. this video
RecommendsmathgladiatorFeb 2021
“The explanation for how the net-code behind Overwatch is a good explanation”
Good explanation of Overwatch netcode and client-side prediction
Full comment
This is a next step for my project as I'm trying to figure out how to generalize client side predictions in a sane way. Basically, I'm happy with my latency (for board games) which I hope to migrate closer to people as more edge compute offerings emerge. However, I'm wondering what the path is to find some of these ideas in more latency sensitive applications. The explanation for how the net-code behind Overwatch is a good explanation: this video and I'm just trying to figure out how to build the reactive tree in a way to support it sanely.
RecommendsjonhermansenFeb 2021
“For anyone curious to know more about usage of ECS in Overwatch, check out this GDC talk from one of the developers”
Overwatch developer explains their use of ECS
Full comment
For anyone curious to know more about usage of ECS in Overwatch, check out this GDC talk from one of the developers: this video
RecommendsRd6n6Sep 2021
“here’s a great tech talk about overwatch.”
Example of ECS tech talk predating Unity's patent
Full comment
Isn’t there a ton of prior art? I’ve seen tech talks about ecs implementations for years. From the top of my head, here’s a great tech talk about overwatch. this video Here’s a tech talk by Bob Nystrom (the game programming patterns guy) that mentions ecs from years ago link Edit: letsInvalid in another thread above linked to an article from 2013: link
RecommendsdkbrkNov 2025
“it provides a nearly complete schematic of the game's architecture”
Nearly complete schematic of Overwatch's architecture when watched frame by frame
Full comment
Have you seen the presentation from GDC 2017 on the architecture of Overwatch [0]? If you watch the video in detail -- stepping through frame-by-frame at some points -- it provides a nearly complete schematic of the game's architecture. That's probably why the video has since been made unlisted. [0]: this video
Cites itsetrJan 2021
Example of ECS used in industry by Blizzard
Full comment
It's definitely been around but I think Unity's (never-finishing) ECS + Rust gamedev community's focus on it has really spiked its popularity/interest lately. Otherwise pretty much every recommendation/engine is OOP-based, with a few straggling extensions/libraries for ECS here and there. No idea about usage in industry though, but it comes up randomly e.g blizzard: this video
Cites itpphyschJul 2021
Cited as support that ECS suits large projects
Full comment
I'm seeing Godot mentioned a lot: one major distinction between O3DE and Godot is that O3DE is "ECS-based" while Godot is "OOP-based" [1][2]. This makes little difference for the hobbyist gamedev, but it has ramifications for large projects with many interacting systems. Proper ECS architecture better supports the latter case [3]. [1] - link [2] - link [3] - this video
Cites itFrostKiwiJul 2024
Example of big-budget project embracing ECS
Full comment
Flecs implements a relatively new programming paradigm "ECS". For context, here is a big budget project, Blizzard's Overwatch embracing ECS [1]. [1] this video
Cites ityayitsweiOct 2024
“here's a talk about Overwatch's netcode”
Comparison point for Overwatch netcode tradeoffs
Full comment
For comparison, here's a talk about Overwatch's netcode: this video Overwatch has a long time-to-kill, interesting to compare tradeoffs.
