Riot Games

The Art of Spell Casting, Part 2

Riot engineers describe the design and implementation of Hwei’s spellcasting: they tried a server-side spell-slot queue but encountered client/server state mismatches (targeting, cast paradigms, flub handling). They pivoted to a client-driven "Spellbook Override" that fakes the first input client-side, sends a single validated spellcast to the server on the second input, and uses client-side prediction and server validation to balance responsiveness, correctness and anti-cheat concerns. The post covers tradeoffs, debugging/logging needs, and reuse potential for other champions.

The Art of Spell Casting, Part 1

Riot Games engineers describe the problem of making Hwei's two-step spell-casting map cleanly onto LoL's existing input/buffering systems. They explore prototypes (client-side input queue, server-side spell-data queue, expanding the postponed-spell buffer) and explain why many approaches fail due to server-authoritative validation, mutable spell data, and legacy assumptions. They landed on a server-side "spell slot" queue prototype that improved responsiveness in playtests; Part 2 will examine remaining issues and the final implementation.

Reviving Nexus Blitz

Riot Games engineer describes the process of reviving the Nexus Blitz game mode: rebuilding outdated UI ViewControllers and converting old JSON/data links to the modern game-data system, addressing gameplay/server issues (e.g., jungle pets causing crashes), and making design tradeoffs for sustainability and future maintenance.

re:Presenting at AWS re:Invent

Bug Blog: Esports Trade Issue

Riot’s backend team investigated an esports-only Champion trade failure on the legacy monolithic Champ Select (Platform). High server-side latencies were traced to very large serialized game objects stored in an in-memory data-grid (player inventories + observers + inefficient serialization). The team reduced cache entry size (structural changes and data cleanup) and added a tournament-shard config to disable inventory verification, yielding ~10x smaller cache entries and ~100x lower latencies for trade operations.

Getting into the Guts of Berserk

A technical post detailing how Riot's engineers implemented Renata Glasc's Berserk ultimate by changing AutoAttack flow, propagating a Berserk instigator ID through Spell Origination, centralizing targeting checks in TargetHelper, adding flags like NeverSelf, and refactoring the crowd control system and designer tooling (AICCBehaviors) to support designer-driven authoring and correct kill attribution.

Bug Blog: TFT Bugs and Patches

A Riot Games developer blog describing how Teamfight Tactics manages full patches vs micropatches across server and client, the engineering challenges and refactor to support safe micropatching of Lua scripts and GDS data, and QA/mobile deployment considerations illustrated by two bug examples (a decimal damage bug fixed via micropatch and a mobile art-asset issue requiring a full app store redeploy).

Leveling Up Networking for A Multi-Game Future

Riot Direct explains how Riot’s global backbone was adapted from a League-only design to support multiple games by expanding PoPs, using anycast and NAT to reduce latency and IPv4 pressure, leveraging PNIs/peering and BGP routing for better paths, and soaking DDoS traffic at the edge — with IPv6 support planned to reduce CGNAT-related latency.

The Legends of Runeterra CI/CD Pipeline

Technical walkthrough of the Legends of Runeterra CI/CD pipeline: how the team uses Jenkins (scripted & multibranch pipelines), a hierarchical branch workflow, computed build plans, and a CDN-backed patcher to speed large Git LFS monorepo syncs; how they split fast Iteration builds vs full Merge Readiness builds; automated testing practices (C# xUnit, pytest, headless clients, in-game HTTP hooks) and test infrastructure (Docker Swarm, AWS EC2 nodes); and failure/observability tooling (JSON failure metadata, New Relic, Slack, Sentry). The post also covers developer ergonomics (LoRST GUI built with Python/PySide2) and ongoing considerations (ephemeral nodes, linux-based Unity builds).

Strategies for Working in Uncertain Systems

Practical guidance for making client code more robust against unreliable third-party services: use unit tests with static responses during development, isolate third-party interactions behind adapter/strategy patterns, implement retry/backoff and scheduling to mitigate outages, and proactively test and communicate when documentation or APIs change.

Improving the Developer Experience for Operating Services

Riot's RDX:Operability team built Console — a unified web application that consolidates logging, metrics, alerting, and other operational features into a single context-aware UI to simplify triage and decrease tooling friction. Console's backend is implemented in golang (exposes rest apis and a proxy), and the frontend is a react + typescript app using ant design and templates to let teams integrate features consistently. Future plans include efficiency scoring, personalization, and dependency correlation.

Keeping Legacy Software Alive: A Case Study

Post-mortem of a multi-hour EU West outage caused by a hardware failure of a non-critical database primary combined with implicit system coupling (shared thread pool across connection pools and a single JVM leading to long garbage-collection pauses). Poor observability and alert noise slowed triage; mitigations included moving the DB to its secondary and cluster reboots. The team plans to increase DB fault-tolerance, isolate shared resources, and improve incident response. A later bonus incident showed an automatic failover completing in 68 seconds on another shard.

Engineering Tools for Designers with Legends of Runeterra

Riot engineers replaced an earlier League block-based card-authoring system with a Python-based scripting system (via IronPython) that lets designers write per-card scripts interacting with the C# game engine. They added tooling (generated stubs and a VS Code plugin), empowered designers to build libraries (history, Puffcap functions), handled migration pitfalls (build-node contamination), and solved performance issues (Puffcap distribution) using statistical techniques.

Scalability and Load Testing for VALORANT

Riot's Core Services team built a Go-based load test harness and mock game servers, deployed across Docker containers scheduled with Apache Mesos on AWS EC2, to simulate two million concurrent VALORANT players. They validated scalability through iterative load tests, horizontal data segmentation, stateless microservices, caching and load balancing, and extensive monitoring with New Relic and Grafana.

Leveraging Golang for Game Development and Operations

Riot engineers describe how they use Golang across backend microservices and operational tooling — from a global deployment tool backed by MySQL to a high-throughput monitoring pipeline and the VALORANT backend. The article highlights Go language features (goroutines, channels, interfaces, gofmt, modules), integrations with Docker/Kubernetes/AWS, observability (New Relic), and community practices around Go at Riot.

How Riot Games Uses Slack

Riot describes how it integrates Slack across its game development lifecycle: using Slack apps and integrations to surface Jenkins + Docker build/deploy status, reduce MTTR, and notify developers (public channels and direct messages). For operations they integrate Sentry and PagerDuty into Slack for crash analytics and incident routing. Riot builds many custom Slack apps (e.g., Pinned Buttons, GBaD, PoroBot) using @slack/bolt and Express, deployable in Docker, AWS Lambda, or Google Cloud Functions (Firebase). PoroBot uses NLP/ML (spaCy, Prodigy, CNNs) with middleware, Redis (short-term) and PostgreSQL (long-term) to classify and triage support requests.

Technology Interns in 2020: League of Legends, TFT, & VALORANT

The Riot internship program helps technical players drive their professional growth by embedding them on tech teams and having them contribute to impactful,...

Technology Interns in 2020: General Game Tech & Tooling/Infrastructure

The Riot internship program exists to help players drive their professional and personal development. This is the second post in the 2020 intern series - be...

VALORANT's 128-Tick Servers

Riot engineer Brent Randall describes how VALORANT achieved free 128-tick servers by reducing server frame time from ~50ms to sub-2ms through code optimizations (RPCs vs UE4 replication, animation throttling), telemetry-driven budgets (ValSubsystemTelemetry + Analytics Platform), load testing, and extensive OS/hardware tuning (NUMA, Linux scheduler, caches, C-states, hyperthreading, clocksource). Collaborations with Intel and careful measurement were key to reaching performance goals.

Peeking into VALORANT's Netcode

Riot Games engineers explain VALORANT's netcode design to improve competitive integrity by reducing peeker's advantage, minimizing simulation divergence, and ensuring reliable hit registration. Key approaches: a server-authoritative model, client-side prediction, fixed 128 Hz simulation timesteps, tight network buffering and move-queueing, server-side rewind for hit registration, global servers and Riot Direct to cut latency, and client performance monitoring. Experiments show small latency deltas (tens of ms) materially affect high-level competitive play.