Software development
How the field of a Game Developer got here: the sourced milestones from every published course of this career, on one axis.
1947 to 2025
189 milestones across 20 courses
The axis stretches toward recent years, where most milestones fall. Bars count milestones per year; dots are single milestones.
17 milestones
1947 Sep 9
Operators found a moth in a relay of the Harvard Mark II and taped it into the logbook with the note "First actual case of bug being found." The incident popularized "bug" and "debug" as the vocabulary for this kind of work.
1974 Dec
RFC 675 documented an early Internet Transmission Control Program with connection state, acknowledgments, windows, and retransmission concepts.
1979
C with Classes began the design path that combined program organization facilities with C efficiency and flexibility.
1980
Each ghost ran mutually exclusive modes such as chase, scatter, and frightened, with chase versus scatter mainly changing the target tile. It remains a fully documented early FSM-style NPC design.
1980
Each ghost's behavior was governed by a small number of mutually exclusive modes — chase, scatter, and frightened — with the only real difference between chase and scatter being the ghost's target tile. It is one of the earliest widely documented examples of state-machine-driven NPC behavior in a shipped game.
1980 Jan
RFC 761 described a DoD standard TCP for reliable host-to-host communication across interconnected packet-switched networks.
1980 Aug
RFC 768 specified the User Datagram Protocol, defining its minimal datagram header and service.
1981 Sep
RFC 793 specified TCP's reliable, in-order byte-stream service and its connection, sequencing, acknowledgment, and control behavior.
1982 Jun
Susan L. Graham, Peter B. Kessler and Marshall K. McKusick present gprof at the SIGPLAN '82 Symposium on Compiler Construction. It extends the existing UNIX profiler by gathering arcs of a program's call graph, so the running time of a called routine is attributed to the routines that called it. The GNU implementation combines an `mcount` call compiled into every function entry with program-counter sampling around 100 times per second, and reports both a flat profile and a call graph — the self-versus-total distinction every profiler has carried since.
1983
The predecessor evolved from C with Classes into C++, establishing the direction that later standardization would formalize.
1983
Douglas E. Smith's Lode Runner included a built-in level editor and shipped community-built levels, an early public example of players authoring spaces separate from engine code.
1984
The first book-length treatment of game design theory, categorizing computer games and proposing design precepts for the craft.
1985
The first commercial release made C++ available beyond its initial development setting and began the early tooling ecosystem.
1987
Reynolds described flocking through local steering rules of separation, alignment, and cohesion, which became the foundation for steering behaviors used under path following in games.
1988
Gilbert, Johnson, and Keerthi published an algorithm for the distance between convex sets, built on the Minkowski difference and a support function. It became a standard narrow-phase test in real-time collision detection.
1988 Apr
Chris Crawford organized the first CGDC in his San Jose living room with about twenty-seven designers attending, the event that grew into the modern Game Developers Conference.
1989 Oct
RFC 1122 documented host requirements for Internet protocols, including TCP and UDP implementation requirements and application responsibilities.
14 milestones
1991
Tim Sweeney's ZZT combined a built-in editor with ZZT-OOP scripting and community contests, training a generation of amateur space authors before commercial FPS mod tools matured.
1992
The first OpenGL specification formalized a cross-platform graphics interface beyond SGI's proprietary IRIS GL. Applications could target a specified pipeline across independent implementations.
1992
Fans reverse-engineered MapEdit for Wolfenstein 3D's tile maps, producing hundreds of custom levels and pressuring later id titles toward clearer mod support.
1992 May
RFC 1323 specified window scaling, timestamps, and protection against wrapped sequence numbers for long-delay or high-bandwidth paths.
1993
Doom's WAD packaging let players load custom levels and assets, catalyzing a mass level-design hobby even though id did not publicly release its internal DoomEd at launch.
1995
DirectX brought a common multimedia API set to Windows software. It became the platform path through which PC games accessed accelerated graphics and related hardware.
1996
QuakeC let Quake's gameplay logic, including AI, triggers, and weapon behavior, be written and compiled separately from the engine and shipped as bytecode, so modders could change game logic without recompiling or exposing engine source. id dropped the approach in the next engine generation in favor of compiled C code as gameplay logic grew more complex.
1996
"Hearts, Clubs, Diamonds, Spades: Players Who Suit MUDs" introduces the four-type, two-axis model of player motivation this course uses to evaluate reward structures.
1998
ISO/IEC 14882 established a published international language and library contract for C++ implementations.
1998 May
Epic Games shipped the original Unreal with UnrealScript, a dedicated scripting language for gameplay code, letting studios add weapons, behaviors, and AI without touching the engine's C++ codebase.
1998 Oct
LucasArts built Grim Fandango's GrimE engine around the Lua scripting language, one of the first commercial games to use Lua for gameplay logic. Its success drew wide attention to Lua across the game industry and helped establish it as a common embedded scripting language for games.
1999
GeForce 256-era hardware moved vertex transformation and lighting from the CPU into a fixed-function GPU stage. Renderer work shifted toward feeding a hardware geometry pipeline efficiently.
1999
The steering behaviors paper and site collected seek, arrive, pursue, evade, wander, and related forces as a reusable movement vocabulary for autonomous characters.
1999 Aug
NVIDIA launched GeForce 256 with integrated transform, lighting, setup, and rendering functions. The product helped establish GPU as the name for a single-chip graphics processor.
50 milestones
2000
Cliff Bleszinski's GDC talk framed level designers as the glue of production and predicted specialization as detail budgets rose, a hinge between auteur mapping culture and modern role splits.
2000 Mar
Version 1.0 of the Havok SDK was unveiled at the Game Developers Conference. Commercial physics middleware became something a game team could license.
2000 Jun
Microsoft announced C# as part of its .NET strategy. The language was positioned with a managed runtime and class library ecosystem from the start.
2001
GeForce3-class hardware exposed a user-programmable vertex engine. Developers could replace fixed transform and lighting with shader programs on shipping consumer devices.
2001
GeForce3 exposed a user-programmable vertex engine within the graphics pipeline. Developers could replace fixed transform and lighting rules with shader programs.
2001
Robin Hunicke, Marc LeBlanc, and Robert Zubek begin teaching the mechanics-dynamics-aesthetics framework at the Game Design and Tuning Workshop at the Game Developers Conference, San Jose, a run that continued through 2004.
2001 Feb
NVIDIA introduced GeForce3 as a programmable GPU. Shader programs began replacing selected fixed-function graphics stages with application-defined operations.
2002
The unofficial Quake 3 community competition emphasized critique, brushwork, and design language among mappers, a high-water mark for level design as a self-aware craft community.
2002
Microsoft introduced HLSL as the C-like language for DirectX programmable shaders. Shader authoring moved from assembly-centric profiles toward high-level stage programs.
2002
NovodeX AG released its real-time physics middleware commercially. The product line later became PhysX.
2002 Feb
C# 1.0 shipped with Visual Studio .NET 2002. It established the language's original object-oriented and managed-programming model.
2002 Jul
Julian Seward released Valgrind 1.0, an instrumentation framework whose Memcheck tool flags an invalid memory read at the instruction that causes it rather than the later crash it produces.
2003
The 2003 revision maintained the ISO standard line while the language continued toward its next major revision.
2003
Katie Salen and Eric Zimmerman's MIT Press textbook treats game design as a unified discipline spanning board, sport, and digital games.
2003 Sep
Valve released the Steam client after the beta ended. Steam became a game-delivery client rather than only a beta service.
2004
Valve's Source-era Hammer toolchain kept layout, lighting, and scripting in a playable construction loop widely cited as a late peak for publicly influential dedicated level editors.
2004
Hunicke, LeBlanc, and Zubek published MDA, giving designers a shared vocabulary for tuning mechanics that produce dynamics and aesthetics, including economy feedback used in balance work.
2004
OpenGL added a C-like shading language for programmable transformation and fragment shading. Shader interfaces became a standard part of application pipeline design.
2004
A second, complementary theory of why games hold attention, connecting play to learning and pattern recognition.
2004
Hunicke, LeBlanc, and Zubek publish "MDA: A Formal Approach to Game Design and Game Research" at the AAAI Workshop on Challenges in Game AI, fixing the framework this course's mental model is built on in print.
2004 Jun
Glenn Fiedler's articles set out the fixed timestep with an accumulator, the spiral of death, and semi-implicit Euler as a game default. They shaped how engines separate rendering from simulation.
2005
Monolith's F.E.A.R. used goal-oriented action planning so enemies could combine operators into novel tactical sequences instead of only scripted branches, and later articles documented the approach for other teams.
2005
Bungie AI programmer Damian Isla presented "Handling Complexity in the Halo 2 AI" at GDC 2005, describing an architecture for managing NPC decision-making complexity that became a major influence on the adoption of behavior trees as a game AI technique.
2005
Damian Isla's GDC 2005 proceeding on handling complexity in the Halo 2 AI became a major influence on behavior-tree adoption for NPC decision-making in games.
2005
Unity Technologies launched the first version of Unity as a Mac OS X game engine at Apple's Worldwide Developers Conference, the starting point for what later became a cross-platform editor.
2005 Jun
Unity Technologies released Unity 1.0 at Apple's WWDC as a Mac OS X game engine aiming to make professional game-development tooling, including its GameObject/component workflow, accessible to small teams rather than only large studios.
2005 Oct
IBM announced its custom PowerPC-based processor for the Xbox 360, three cores at over 3 GHz with two hardware threads each. Engines targeting the console had to distribute per-frame work across multiple cores instead of relying on one fast core.
2005 Nov
C# 2.0 introduced generics, iterators, nullable value types, and partial types. Generic collections could then preserve type information without casts.
2006
Shader Model 4 pipelines added a geometry stage that could emit new primitives from assembled geometry. Authors gained a programmable step between vertex processing and rasterization.
2006
Chen's thesis connected Csikszentmihalyi's flow channel to player-centric dynamic difficulty, arguing for self-tuning challenge across different skill bands.
2006 Jan
Joe Hewitt released Firebug 0.2, the first tool to let developers inspect, edit, and debug HTML, CSS, and JavaScript directly inside the browser rather than through separate editors and alert statements.
2006 Sep 19
Python 2.5 adds cProfile, "a C implementation of the existing profile module that has much lower overhead", contributed by Armin Rigo. Deterministic profiling — monitoring every function call, return and exception with precise interval timing — becomes available by default in a mainstream language, along with the documented limits that come with it, including the distortion of Python-versus-C timing comparisons.
2006 Nov
NVIDIA introduced CUDA so computational workloads could use GPU parallelism without being expressed through a graphics API.
2006 Nov
Sony launched PlayStation 3 in North America powered by the Cell processor, a heterogeneous design combining one general-purpose core with multiple specialized Synergistic Processor Elements. Performance-critical code had to be hand-scheduled across those elements, each with its own local memory rather than a shared cache.
2007
Intel purchased Havok Inc., the physics middleware company founded in 1998. Microsoft acquired Havok in 2015.
2007 Nov
C# 3.0 added query expressions, lambda expressions, extension methods, and implicitly typed local variables. These features made LINQ sequence pipelines part of ordinary C# code.
2008
NVIDIA acquired Ageia, the owner of PhysX. PhysX moved from dedicated physics processors toward GPU acceleration.
2008
Jesse Schell's lens method gave production teams a portable way to interrogate experience problems that show up as pacing or balance failures in playable spaces.
2008
Jesse Schell publishes the book that introduces the "lens" as a named design tool, the diagnostic technique this course teaches for questioning a struggling design.
2008 Jan
Valve announced Steamworks as publishing and development services for developers and publishers. Distribution became coupled with updates, authentication, and community features.
2008 Feb 1
Git 1.5.4 added "git bisect skip" for revisions that cannot be tested, refining the binary-search algorithm Linus Torvalds had built into git bisect.
2008 Mar
Unity Technologies announced support for building games for Apple's iPhone, moving the engine beyond desktop development and into mobile for the first time.
2008 Sep
Google Chrome launched with the Elements and Resources panels of WebKit's Inspector built in, starting the browser-native devtools lineage this course's breakpoint material now documents.
2008 Dec 8
Khronos ratified OpenCL 1.0 as an open cross-platform model for parallel programs on GPUs, CPUs, and other processors.
2009
Mikko Mononen's Recast and Detour toolchain made voxel-based navmesh generation and path queries widely reusable across engines and custom runtimes.
2009
Hull and domain shaders made view-dependent surface refinement a programmable pipeline feature. High-detail surfaces could be generated on the GPU from coarse patches.
2009 Apr 23
W3C published the first standalone Server-Sent Events Working Draft, defining an HTTP connection that delivers server notifications as DOM events.
2009 Sep
RFC 5681 consolidated TCP congestion-control behavior, including slow start, congestion avoidance, fast retransmit, and fast recovery.
2009 Sep 9
The kernel gains a performance counter subsystem abstracting the hardware registers that count instructions executed, cache misses and mispredicted branches, together with the `perf` userspace tool providing `perf top`, `perf record`, `perf report` and `perf annotate`. Sampling profiling stops being a per-application feature and becomes a kernel service any process on the machine can be measured with.
2009 Sep 30
NVIDIA announced Fermi as its next CUDA GPU architecture. The design strengthened the GPU's role in scientific and general-purpose computing.
72 milestones
2010
Gang Ren, Eric Tune, Tipp Moseley, Yixin Shi, Silvius Rus and Robert Hundt describe a continuous profiling infrastructure running across Google's data centers in IEEE Micro, reporting stable, accurate profiles at negligible overhead. It establishes that always-on fleet-wide profiling is affordable, and demonstrates analyses that only exist once profiles are collected everywhere, such as measuring application affinity to particular hardware platforms.
2010 Apr
C# 4.0 introduced the dynamic type alongside named and optional arguments. Dynamic binding deferred some member-resolution errors from compile time to runtime.
2010 Nov
Unity Technologies opened the Unity Asset Store at Unite 2010, a marketplace built into the editor for developers to buy and sell reusable assets, launching with about 70 products.
2011
The 2011 revision began the modern sequence of regularly named C++ standard editions used by projects to select language modes.
2011 Jun 24
The Go team documents profiling as part of the language toolchain rather than an external tool, walking through a full optimization session with `go tool pprof`. The runtime samples the executing goroutine's stack about 100 times per second and samples the heap roughly once per half megabyte allocated, and the profile.proto format it emits later becomes the interchange format much of the profiling market stores.
2011 Dec
Brendan Gregg releases the flame graph after working a MySQL performance problem, fixing stack depth on the y-axis and an alphabetically sorted stack population on the x-axis so that identical adjacent frames merge into single wide blocks. Profile output stops being a table to read and becomes a picture to scan, and the format spreads to off-CPU, memory, hot/cold and differential variants.
2011 Dec
The IETF defined the HTTP opening handshake, two-way message framing, masking, control frames, and the origin-based browser security model.
2011 Dec 8
W3C invited implementations of the browser API that lets web pages use the WebSocket protocol for two-way communication.
2011 Dec 22
AMD launched the Radeon HD 7970 with Graphics Core Next. The architecture targeted both programmable graphics and compute workloads.
2012
General compute dispatch joined the graphics API alongside shader storage and image operations. Renderers could schedule non-raster GPU work in the same resource ecosystem.
2012
A collaborative effort between studios, specialists, and academics publishes basic, intermediate, and advanced accessibility guidelines for game developers, the tiers this course's practice reference uses.
2012 Aug
C# 5.0 made task-based asynchronous methods a language feature. The async and await model changed how C# programs express non-blocking input-output work.
2012 Aug
Game Developer profiles Machinations, a visual tool for diagramming and simulating game economies without code, addressing a gap practitioners described as harder to discuss than any other part of game design.
2012 Aug
Valve launched Steam Greenlight for community feedback on game submissions. Store-page media became part of the submission route.
2012 Nov
Unity 4.0 shipped with the Mecanim animation system, DirectX 11 support, and preview publishing to Linux and Adobe Flash, expanding the engine's animation tooling and target platforms.
2012 Dec 11
The EventSource API and event-stream format entered an implementation-testing stage with a published interoperability report.
2013 Mar
Kerbal Space Program became available as an Early Access title. Publishing could support a product that continued changing after initial availability.
2014
Metal gave iOS applications lower-overhead access to graphics hardware and precompiled shaders. Apple-platform renderers gained a native model centered on command submission and explicit resources.
2014
Originally developed as an in-house engine from 2007 by Juan Linietsky and Ariel Manzur, Godot was released publicly under the permissive MIT license in 2014. The license removed royalties and seat fees and set the terms the project still uses.
2014
Unity's NavMesh baking and NavMeshAgent path following became the default movement stack for many teams attaching custom decision graphs above engine navigation.
2014 Feb
Godot's creators released the previously in-house engine as open source. Public contribution became part of its development model.
2014 Feb
RenderDoc launched as a free, open-source, single-frame graphics debugger for Direct3D, Vulkan, and OpenGL. It gave studios without an in-house GPU debugger a way to inspect draw calls and GPU state frame by frame.
2014 Mar
Epic opened the editor and engine source through a subscription. Developers could modify the same native engine used for production.
2014 Mar
Epic launched Unreal Engine 4 with the editor and complete C++ source available to subscribers. The release broadened access to Epic's production engine workflow.
2014 Mar
Epic Games released Unreal Engine 4 with Blueprint visual scripting as a successor to UE3's Kismet, letting designers and artists build gameplay logic such as conditional interactions without writing C++ code.
2014 Mar
UE4 made Behavior Tree and Blackboard assets a first-class AI workflow beside Blueprints, so designers could author NPC tactics in editor-visible graphs.
2014 Mar 26
Robert O'Callahan introduced rr, a Linux record-and-replay debugger built to capture Firefox's intermittent test failures once and replay them with bit-for-bit identical memory and register state on every subsequent run.
2014 Dec
RFC 7413 specified a mechanism for exchanging data during the TCP handshake when a client has a valid cookie.
2014 Dec 15
The first stable version gave the project a supported baseline. It established the node, scene, and signal model that later versions refined rather than replaced.
2015
Khronos published SPIR-V as a portable intermediate representation for graphics and compute shaders. Toolchains could share a common module format across Vulkan and related consumers.
2015 Feb 3
The standalone specification completed the W3C Recommendation process for HTTP server push through DOM events.
2015 Mar
Epic made UE4 available without an access subscription. Distribution remained subject to its commercial license.
2015 Mar
Unity released Unity 5 as a new generation of its multiplatform engine and tools. The release expanded the editor and graphics feature set.
2015 Mar
Unity 5 shipped with real-time global illumination, a 64-bit editor, and a free Personal edition with the full engine feature set, alongside a paid Professional edition for teams needing extra tools.
2015 Jul
Microsoft shipped DirectX 12 commercially with Windows 10, replacing the driver-managed Direct3D 11 submission model with explicit, lower-overhead command lists. Engines gained closer control over GPU work submission and synchronization, along with more responsibility for scheduling it correctly.
2015 Oct 23
rr 4.0.0 was the first stable release with reverse execution enabled, letting a recorded run be stepped backward from a crash to the state change that caused it.
2015 Dec
The IETF standardized extension negotiation for compressing WebSocket messages, including the permessage-deflate extension.
2016 Feb
Godot 2.0 shipped after work focused on usability and 2D rendering. The project described it as a stable release for general use.
2016 Feb
The Khronos Group published the Vulkan 1.0 specification, bringing the same explicit, low-overhead submission model as DirectX 12 to a cross-platform, cross-vendor API. Drivers and SDKs from member companies shipped the same day.
2016 Feb 16
Vulkan standardized cross-platform, low-overhead access with explicit GPU resource and synchronization control. Command generation could scale across CPU cores rather than relying on a stateful driver path.
2016 Feb 16
Khronos released Vulkan 1.0 with explicit queues, synchronization, and resource management for cross-platform GPU applications.
2016 Feb 23
Version 2.0 introduced scene instancing and inheritance improvements that strengthened the composition model, making it more practical to build a game from many reused scenes.
2016 Jun
UE4.12 introduced Sequencer as the successor to Matinee. Cinematic editing gained a nonlinear sequence-based tool.
2016 Jul
Attila Branyiczky's Game Developer article popularized nesting peaks and valleys under an upward difficulty trend as practical guidance for campaign pacing.
2016 Jul
The IETF updated the WebSocket subprotocol registry procedure so new application protocols had clearer registration rules.
2017
The 2017 revision continued the published ISO C++ language and library line that implementations target through explicit compiler modes.
2017
Godot's navigation server, regions, and NavigationAgent nodes gave an open-source engine path for mesh queries and avoidance comparable to commercial navmesh stacks.
2017 Feb
Unity announced that after Unity 5.6, its next release would be called Unity 2017.1, moving from incremental version numbers to a year-based naming scheme.
2017 Mar
C# 7.0 added tuple types, deconstruction, pattern matching, local functions, and other syntax changes. These features made shape-based decisions and small returned values more direct to express.
2017 Mar
RFC 8085 documented requirements and guidance for applications and protocols that use UDP on the Internet.
2017 May 10
NVIDIA launched Volta and the Tesla V100 with Tensor Cores beside general CUDA cores. Matrix operations became a named specialized path within a general GPU architecture.
2017 Jun
Steam Direct became the new submission path as Greenlight closed to new submissions. The route shifted from community voting to a direct developer process.
2017 Jul
Josh Bycer's Game Developer piece crystallized three comparison axes for options, giving level and systems designers a shared language for dominant-choice failures inside encounters.
2018 Jan
Godot 3.0 shipped with a new rendering engine, revised asset workflow, native-code plugins, and C# support. The release broke compatibility to enable broad internal changes.
2018 Jan
The specification extended the well-known URI mechanism to the ws and wss schemes for protocol discovery conventions.
2018 Jan 29
A major update that rebuilt large parts of the engine, added a physically based 3D renderer, and broadened platform support. It moved Godot from a capable 2D engine toward a credible general-purpose one.
2018 Mar
Unity presented a "performance by default" architecture built on an Entity Component System, a C# Job System for safe multithreading, and the Burst compiler, shipping ECS as an experimental preview package in Unity 2018.1. This became the foundation of Unity's later Data-Oriented Technology Stack.
2018 Mar 19
DXR introduced acceleration structures and ray-specific HLSL stages. Real-time engines could combine raster passes with programmable ray generation, closest-hit, and miss shaders.
2018 Mar 19
DXR added acceleration structures, ray dispatch, and ray-specific HLSL shader stages to Direct3D 12. Real-time engines could combine raster passes with hardware-oriented ray queries and traversal.
2018 Jul
UE4.20 added the Niagara effects editor in beta. Artists gained a modular particle-authoring path alongside the older Cascade system.
2018 Sep
Extended CONNECT allowed one HTTP/2 stream to carry a WebSocket connection without the HTTP/1.1 connection-wide Upgrade mechanism.
2018 Sep 14
NVIDIA detailed Turing with streaming multiprocessors, Tensor Cores, and RT Cores. Real-time graphics could combine rasterization, programmable shading, matrix work, and hardware-assisted ray tracing.
2018 Sep 25
JEP 328 moves Flight Recorder, previously a commercial feature of the Oracle JDK, into the open repository and delivers it in JDK 11, which reaches General Availability on 25 September 2018. The stated goal is at most 1% overhead out of the box on SPECjbb2015 and no measurable overhead when disabled. A production-grade recorder of thread samples, lock profiles and allocation ships with the runtime rather than being purchased separately.
2018 Dec
Epic announced the store was live with third-party titles. It added another major PC storefront and publishing relationship.
2018 Dec 3
PhysX was made open source under a 3-clause BSD license for computer and mobile platforms. Teams could read and modify a production engine.
2019
Jesse Schell releases the third edition for the book's tenth anniversary, expanding the catalog of lenses beyond the first edition.
2019 Feb
NVIDIA's DLSS reached players for the first time in Battlefield V and Metro Exodus, upscaling a lower-resolution render using a neural network to reduce native-resolution rendering cost. Both titles required per-game training of the DLSS model at this stage of the technology.
2019 Mar
Godot 3.1 followed the compatibility-breaking 3.0 work with usability improvements and additional features. It marked a shift from the major rewrite toward maturation of that base.
2019 Mar
Unity published a detailed blog post explaining the Data-Oriented Technology Stack and its Entity Component System, an alternative, opt-in architecture aimed at performance-critical code that had already been in public preview.
2019 Mar 13
Focused on usability and workflow, 3.1 improved the editor and scripting experience. It marked the point where day-to-day development in Godot became noticeably smoother.
2019 Apr
UE4.22 exposed beta ray-traced passes alongside rasterization. Projects could evaluate selected ray-traced effects without replacing the whole renderer.
2019 Sep
C# 8.0 added nullable reference types and nullable static analysis. Projects could express and check whether a reference was intended to be null.
36 milestones
2020
C++20 added concepts and modules, expanding the language facilities that modern toolchains and build integrations must support.
2020
Epic demonstrated virtualized geometry and dynamic indirect lighting. The preview outlined new approaches to scene detail and lighting authoring.
2020 May
Epic Games revealed Unreal Engine 5 with a real-time demo showcasing Nanite virtualized geometry and Lumen dynamic global illumination. Nanite aimed to remove manually authored LOD meshes as a required step for static geometry detail.
2020 Sep
Unity Software priced its initial public offering at 52 dollars a share and began trading on the New York Stock Exchange under the ticker U, raising 1.3 billion dollars.
2020 Nov
AMD Instinct MI100 introduced first-generation CDNA for HPC and accelerated computing. AMD separated this compute emphasis from its graphics-oriented RDNA line.
2020 Nov
C# 9.0 added records and top-level statements. Data-centered types and small console programs could use less declaration boilerplate.
2021 May
Early Access let developers test Nanite, Lumen, World Partition, and One File Per Actor. Epic identified the build as intended for experimentation rather than production.
2021 Jun
AMD released FidelityFX Super Resolution, an upscaling technology designed to run on a wide range of GPU hardware rather than requiring vendor-specific AI acceleration hardware. Seven games supported it at launch.
2021 Aug
The beta let developers configure product pages, achievements, pricing, offers, builds, and updates. These release parts moved toward portal-managed configuration.
2021 Oct 8
Polar Signals releases Parca, pairing an eBPF-based profiler that discovers targets through Kubernetes or systemd with storage that identifies profile series by type and key/value labels and queries them with a label selector. Profiles become a queryable time series rather than a file, which is what makes comparing two points in time a query rather than a manual diff.
2021 Nov 8
AMD announced the CDNA 2 based MI200 series with multiple graphics compute dies in one accelerator package. GPU scaling moved inside the package as well as across boards and nodes.
2022 Mar 22
NVIDIA announced Hopper and H100 with a Transformer Engine, newer Tensor Cores, and an expanded NVLink design. Architecture planning increasingly joined compute units, precision selection, and multi-GPU communication.
2022 Apr
The release brought the redesigned editor and UE5 rendering systems into the released engine. Teams could plan migration from existing UE4 projects.
2022 Apr
Epic released Unreal Engine 5 with a redesigned editor and new real-time rendering workflows. Existing Unreal Engine 4 workflows remained supported.
2022 Apr
Unreal Engine 5.0 uses Chaos Physics for simulation in place of PhysX. Behavior differs from PhysX, so projects moving from Unreal Engine 4 had to retune physics.
2022 Jun
The HTTP/2 Extended CONNECT approach was adapted so a WebSocket connection could run over an HTTP/3 stream.
2022 Aug
RFC 9293 replaced RFC 793 as the current TCP specification while retaining the protocol's core byte-stream service.
2022 Aug 23
Registered in the Netherlands as "Stichting Godot," the non-profit foundation was created to administer donations and fund development. It gave the project a stable financial structure independent of any single company.
2022 Dec
Unity released Entities 1.0, the first production-ready version of its data-oriented ECS stack for Unity 2022.2 and later. The stack targets multithreaded, cache-friendly gameplay simulation as an alternative to Unity's traditional component model.
2023
Technical work for C++23 completed in 2023; its ISO publication became ISO/IEC 14882:2024(E), the current published C++ standard.
2023
Fedora accepts adding `-fno-omit-frame-pointer` and `-mno-omit-leaf-frame-pointer` to default C and C++ compilation flags, targeting Fedora Linux 38. The rationale is that stack unwinding via frame pointers is cheap while the DWARF alternative requires copying the full stack from kernel to user space, against a measured cost of about 2.4% on a kernel compile and 2% on a Blender render. A distribution-wide build flag is changed to make profiling work.
2023 Mar
Epic launched tools for developers and publishers meeting store requirements. Direct publishing included responsibility for store presence and release compliance.
2023 Mar
Godot 4.0 shipped after a multi-year core overhaul and engine rewrite. The project positioned the release as a new base for usability and performance work.
2023 Mar 1
The result of a multi-year rewrite. It introduced the Vulkan-based Forward+ and Mobile renderers alongside Compatibility, and added GDExtension for native C and C++ code. It reset the engine's rendering and extension foundations.
2023 Mar 15
Grafana Labs acquires Pyroscope, founded in 2021, and merges it with Grafana Phlare, launched in 2022, under the name Grafana Pyroscope. The open-source continuous profiling field consolidates from two competing databases into one, alongside the framing of profiling as a further observability signal beside metrics, logs and traces.
2023 Apr
Chrome's release made WebGPU available as a modern graphics and compute API in a mainstream browser. Web applications gained explicit pipelines, command encoding, and GPU resource binding behind web validation rules.
2023 Apr
Chrome's WebGPU release made WGSL available as the web platform shading language for modern GPU access. Browser apps gained an explicit shading model under web validation rules.
2023 Jul 6
The first feature release after the 4.0 rewrite, focused on stability, reliability, and workflow fixes. It signaled that the 4.x line had moved from a large migration to steady, incremental improvement.
2023 Sep
Unity announced a new per-install Runtime Fee on top of existing licenses; severe developer backlash followed within days, and Unity revised the policy about ten days later, exempting Unity Personal and narrowing the fee's scope.
2023 Nov
C# 12 added primary constructors for classes and structs, along with collection expressions and other features. Constructor parameters could be placed in a type declaration when that form fits the type's contract.
2023 Nov
Unity announced at its Unite 2023 keynote that its next Long Term Support release would be named Unity 6, returning to a numbered naming scheme after years of year-based release names.
2024 Jun 7
OpenTelemetry accepts Elastic's donation of its eBPF-based continuous profiling agent, which observes code across programming languages and runtimes, third-party libraries, kernel operations and system resources without code instrumentation, recompilation or service restarts, at roughly 1% CPU. Profiling gains a vendor-neutral collection agent and a data model that carries the same attributes as traces and metrics.
2024 Aug 9
Box2D 3.0 was rewritten in C, added multithreading, and introduced the soft step solver and capsules. It reported more than twice the single-threaded speed of v2.4.
2024 Sep
One year after announcing it, Unity canceled the Runtime Fee entirely, confirming it would not apply to any shipped or future version and returning licensing fully to its per-seat subscription model.
2024 Oct
Unity 6 launched as a production-ready Long Term Support release, with end-to-end multiplayer workflows, mobile web build targets, and GPU-focused rendering performance improvements in URP.
2025 Mar 26
Godot 4.4 added Jolt as an alternative to Godot Physics, marked experimental at release. It followed a community Jolt extension in use since late 2022.