Why GTA Online took 6 minutes to load: sscanf, strlen and an accidentally quadratic loop

What happened to GTA Online's loading screen on PC

GTA Online is the multiplayer mode of Grand Theft Auto V. By 2021 its PC version was known for loading slowly: on the PC of a player who goes by t0st (an AMD FX-8350, 16 GB of DDR3, a budget SATA SSD and a GTX 1070), story mode took about 1 minute 10 seconds to load and online mode about 6 minutes. A poll he found suggested most players were at least mildly annoyed, and the folk explanations were the game's size or its peer-to-peer networking.

He showed it was neither. In a post on 28 February 2021 he traced most of the wait to two pieces of code running on one CPU core, both doing far more work than the data needed. Rockstar confirmed the finding was real, shipped its own fix on 16 March 2021 and paid him $10,000. This page walks through how he found it, what the two bugs were, and why the pattern behind them, often called accidentally quadratic, is worth recognising in your own code.

Everything here is about the PC version of GTA Online in 2021. It says nothing about GTA 6, which Rockstar lists for 19 November 2026 on PS5 and Xbox Series X|S.

Step one: watch what is busy

Before reaching for anything clever, t0st opened Task Manager while the game loaded. For the first minute every resource moved, roughly the same work story mode does. After that the picture changed: disk reads stopped, network traffic fell to almost nothing apart from the rotating info banners, the GPU sat at zero and memory use was flat, while one CPU core stayed maxed for about four minutes.

That pattern rules a lot out. A game waiting on its servers, its disk or a peer-to-peer handshake looks idle. A game pinning one core while nothing else moves is computing, in its own code, on one thread. His old CPU had eight cores but weak single-thread performance by 2021 standards, which explains why his machine suffered more than a fast one, but not why the work existed at all.

One caution if you look at his screenshot: its overall CPU graph reads about 61% on an eight-core chip, which does not match one core alone. The video uses his own description ("max out a single core"), which the profile that follows supports.

Step two: sample where the time goes

A profiler tells you which code is using the time. Many profilers instrument the program, which needs its source or debug symbols, and he had neither. So he used a sampling profiler: it pauses the running process at intervals, records where it was (the instruction pointer, plus the call stack), and moves on. Count enough of those snapshots and the hottest code stands out, with no source needed. He had four minutes of a single hot thread, so precision did not matter.

The tool he used was Luke Stackwalker, an old free profiler for Windows. Without symbols it could only report raw addresses, so he grouped neighbouring addresses by eye. Two clusters held the samples on the busy thread, roughly 55% and 45%: two separate bottlenecks rather than one.

Step three: read only the hot code

The game's shipped code is obfuscated against reverse engineering, so the instructions on disk are not the ones that run. The protection has to undo itself before code executes, so he dumped the process's memory while it was loading and read the machine code at the two hot addresses from that dump. One address carried a recognisable label, strlen; one frame up was a function labelled vscan_fn, and he was "fairly confident" the caller was sscanf. Stepping through it in a debugger showed what it was parsing: about 10 MB of JSON, a "net shop catalog" with some 63,000 entries, apparently every item and upgrade you can buy in GTA Online.

The video names the method, not the tools, and so does this page beyond the profiler. It also leaves out how he tested the fix, which involved loading his own code into the running game.

Bug one: measuring 10 MB before every number

A C string does not store its length. It is a run of bytes ending in a zero byte, so the only way to know its length is to walk every byte until that zero. That is what strlen does.

sscanf reads values out of a string. As t0st notes, most sscanf implementations call strlen on their input first. On a short string that costs nothing. The parser here kept one pointer into the 10 MB buffer and called sscanf at that pointer for each value. To C, the "string" at that pointer runs all the way to the end of the catalogue, so every call measured the whole remaining text before reading a few bytes. The shape, as an illustration (this is not Rockstar's code):

const char *p = catalogue;          /* ~10 MB of JSON, one '\0' at the very end */
while (find_next_number(&p)) {
    int value;
    sscanf(p, "%d", &value);        /* many C libraries call strlen(p) here:   */
                                    /* a walk to the end of the whole buffer   */
    p += digits_in(value);
}

Each call is linear in what remains, and the number of calls grows with the size of the text, so the total is quadratic: double the catalogue and this loop does about four times the work. The video draws each call as a tape measure running to the far end, and the runs stack into a triangle.

The obvious fixes all remove the repeated measurement: parse with a function that stops at the end of the value (strtol reports where it stopped), track the buffer's end once and pass lengths around, or use a JSON library built for large inputs. His proof of concept was blunter: it remembered the start and end of the one long string the first time strlen measured it, and answered later calls inside that range with end - p.

Bug two: checking for duplicates in a list that had none

The second hot spot ran right after each item was parsed. Items were stored in an array of entries, each holding a hash of the item's key and a pointer to the item. Before storing a new item, the code walked the whole array comparing hashes, to make sure the item was not already there.

The first item checks nothing, the hundredth checks 99, and the last checks about 63,000. t0st's arithmetic for about 63,000 items is (n² + n) / 2, which comes to 1,984,531,500 comparisons. Two details made it pure waste: the array was empty before loading began, and every item in the catalogue was unique, so no comparison could ever find a match. The code even had a separate function that inserts without checking.

The usual fixes: keep the entries in a hash map so a lookup is one probe instead of a walk, or, when the input is known to be unique, insert directly. That second option is what his proof of concept did.

The fix, and what the numbers measure

His measurements, all on his own PC, timed from the Rockstar logo to being in the game:

• Original online load: about 6:00
• Only the duplicate check removed: 4:30
• Only the strlen measurement cached: 2:50
• Both: 1:50, which he computes as a 69.4% improvement

Those are single runs on one older machine. Faster PCs he found were already loading in about two minutes, and he wrote that the fix "won't solve everyone's load times", since other systems might have other bottlenecks.

Rockstar's statement to PC Gamer said t0st "did, in fact, reveal an aspect of the game code related to load times for the PC version of GTA Online that could be improved". It did not describe the mechanism or publish numbers, and no source says Rockstar used his patch; it shipped its own changes in the 16 March 2021 title update, whose notes thank t0st "for his contributions around this part of today's title update". t0st reports Rockstar paid him $10,000 through its bug bounty programme "as an exception", since bounties usually cover security issues, and Rockstar confirmed to PC Gamer that the payment was being made. On the same hardware after the update, his stopwatch read 1:54.88. PC Gamer timed its own PC at 3 minutes 15 seconds before the update and 2 minutes after.

How to spot the same pattern in your own code

Both bugs are a step that looks constant-time but scans the whole input, sitting inside a loop over that same input. Joel Spolsky called this Shlemiel the painter's algorithm in 2001, after a painter who walks back to the paint can for every dash he paints; a long-running blog collects real cases under the name accidentally quadratic. Common hiding places:

• strlen, strcat or sscanf on a long C buffer inside a loop
• list.contains, array.includes, indexOf or x in some_list inside a loop; a set or map turns each check into one lookup
• building a string with repeated concatenation where the language copies on every append
• a "check it isn't already there" step before every insert, on data that is unique by construction

Two habits catch it. Time the operation at one size and at double the size: linear work roughly doubles, quadratic roughly quadruples. And when something takes minutes that should take seconds, profile before guessing, the way t0st did: look at what is busy, sample where the time goes, then read only that code. Sampling profilers exist for most stacks (perf on Linux, Instruments on macOS, py-spy for Python, the performance panel in browser dev tools).

Terms

C string

A sequence of bytes ending in a zero byte ('\0'). It carries no length, so finding the length means walking to the zero.

strlen

The C standard library function that returns a C string's length by counting bytes up to the terminating zero. Its cost grows with the length of the string.

sscanf

The C function that reads formatted values, such as an integer with "%d", out of a string. Many implementations measure the input with strlen before parsing.

Sampling profiler

A profiler that pauses a running program at intervals and records where it is. The functions that appear in the most samples are where the time goes. It needs no source code.

Instruction pointer

The CPU register holding the address of the next instruction to run. A sampling profiler records it, which is why it can work on a program with no symbols.

Quadratic time, O(n²)

Work that grows with the square of the input size: twice the input, about four times the work. A linear step inside a linear loop is the usual cause.

Accidentally quadratic

An informal name for code that is quadratic by mistake, usually because a cheap-looking call scans the whole input.

Hash map

A structure that finds an entry by its key in roughly constant time, instead of comparing against every entry.

Obfuscation

Transforming shipped code so it is hard to read. In this case the code had to be read from memory while the game ran.

Bug bounty

A programme that pays outsiders for reporting problems, usually security flaws. Rockstar paid t0st through its programme as an exception.

Questions

// further reading

• How I cut GTA Online loading times by 70% ↗: t0st's full write-up, with the profiler output, the timings and the two updates
• Rockstar thanks GTA Online player who fixed poor load times ↗: PC Gamer, 15 March 2021, with Rockstar's statement and the bounty
• GTA Online load time fix released ↗: PC Gamer, 16 March 2021, with the patch notes and its own before and after timings
• Back to Basics ↗: Joel Spolsky on C strings, `strcat` and Shlemiel the painter's algorithm