Every measurement in this post was taken on 21 November 2026 from one machine, over a fast, unthrottled connection with the browser cache disabled. Akamai serves each visitor from its own edge servers and Rockstar can redeploy at any time, so treat the figures as a snapshot and re-run the checks before relying on them.
GTA VI came out on 19 November 2026 on PS5 and Xbox Series X|S, and Take-Two calls it the biggest entertainment launch ever. This post looks at how Rockstar built the official site, a marketing page made mostly of video and imagery that gets a lot of visitors around a launch like this. The launch-week outages that made the news were PlayStation Network login problems.
The measurements were taken on 21 November 2026: the homepage and five subpages fetched with curl, the 37 JavaScript chunks and 59 stylesheets the homepage references downloaded, and the page loaded in headless Chrome 157 through the Chrome DevTools Protocol (a 1440×900 desktop viewport, 390×844 mobile emulation at 3x, and one run with prefers-reduced-motion: reduce). The video files went through ffprobe. The first two sections are mostly measurements. In each lesson after that, the measurements come first and my opinions follow.
What the site is built on
| Layer | What shows up | Where it shows |
|---|---|---|
| Framework | Next.js 16.2.4, App Router, built with Turbopack | window.next version string, self.__next_f RSC scripts, a turbopack-*.js chunk |
| Rendering | Static prerender, client router stale time of 300 s | x-nextjs-prerender and x-nextjs-stale-time headers |
| Styling | vanilla-extract with an in-house design system | hashed atomic classes, CSS @layer foundry_… |
| Interaction | React Aria, GSAP 3.12.5 with ScrollTrigger, Lenis 1.3.17 | data-react-aria-pressable attributes, version strings in the bundles |
| State and monitoring | Jotai 2.18, Sentry | package paths and Sentry calls in chunks |
| Delivery | Akamai CDN and image resizing | akamai-grn header, ?imwidth= image URLs |
| Third parties and polyfills | OneTrust, Google Tag Manager, FingerprintJS (open-source build), core-js 3.38.1 | <head> tags and chunk contents |
The homepage response headers, trimmed:
HTTP/2 200
x-nextjs-prerender: 1
x-nextjs-stale-time: 300
cache-control: max-age=0, no-cache
content-encoding: gzip
content-length: 122544
vary: Accept-EncodingMy reading: the HTML comes from a prerender, so no request waits for React to render the page, and no-cache plus an ETag make the browser check with the server on every visit. x-nextjs-stale-time is the value Next's client router uses to decide how long prefetched data stays fresh, so it doesn't say how often the server regenerates the page. For a page facing launch traffic, keeping React rendering off the request path is the boring and correct setup.
Page weight
Desktop at 1440×900, cache disabled, about 12 seconds after navigation, before any scrolling:
| Bucket | Requests | Transferred |
|---|---|---|
| HTML document | 1 | 124 KB gzip (1.47 MB decoded) |
| First-party JS | 50 | 901 KB |
| First-party CSS | 59 | 94 KB |
| Fonts | 6 | 347 KB |
| First-party images | 30 | 1.98 MB |
| GTM and gtag | 2 | 335 KB |
| OneTrust | 12 | 214 KB |
| Total | 184 | about 4.0 MB |
Scrolling the whole 13,359 px page brought it to 194 requests and 4.29 MB. Mobile emulation went from 201 requests and 4.27 MB to 246 requests and 4.67 MB after scrolling. Time to first byte was 176 ms and load fired at 466 ms, which says more about the test connection than about a phone on mobile data.
1. Let the CDN pick the image format
Every image URL in the markup ends in .jpg or .png, and the Accept header decides what comes back. For the poster at imwidth=1440:
| Request | Response | Size |
|---|---|---|
Accept: image/avif,… | AVIF | 190,882 B |
Accept: image/webp,… | WebP | 231,942 B |
Accept: */* | JPEG | 281,595 B |
| Original file, no resize parameters | JPEG | 875,851 B |
In headless Chrome, all 35 first-party raster images arrived as AVIF. The markup comes from next/image, with a srcset of 17 widths from 360w to 3840w that points at Akamai's resizer instead of Next's own /_next/image endpoint.
If your CDN or image service can negotiate formats, a custom loader hands it the work:
import type { NextConfig } from "next";
const nextConfig: NextConfig = {
images: {
loader: "custom",
loaderFile: "./lib/image-loader.ts",
},
};
export default nextConfig;import type { ImageLoaderProps } from "next/image";
export default function cdnLoader({ src, width }: ImageLoaderProps) {
const url = new URL(src, "https://images.example.com");
// set() replaces an existing imwidth instead of appending a second query string
url.searchParams.set("imwidth", String(width));
return url.toString();
}I used set() because of /VI/only-in-leonida, where 75 image URLs have two query strings glued together (…imwidth=3840?akim=1&imdensity=1&imwidth=1280). It looks like the loader ran twice on the same URL. With two query strings, the 1x and 2x candidates can't select different files. In the one case checked, every variant returned the same 43 KB AVIF, so nothing was wasted there, but the bug is easy to miss.
The caching is less convincing. Resized images come back as private, no-transform with a max-age between 15,000 and 80,000 seconds (a different value per response) and no Vary header, while the original file is public with a max-age of about a year. My guess is that private is deliberate: without Vary: Accept, a shared cache could hand an AVIF to a browser that asked for JPEG. The source filenames are content-hashed, so if you control the headers, I'd let shared caches keep the variants:
Cache-Control: public, max-age=31536000, immutable
Vary: Accept2. Art-direct by aspect ratio and write sizes for the rendered box
The homepage has 31 <picture> elements, and their <source> media queries use aspect ratio as well as width: (max-aspect-ratio: 0.6), (min-aspect-ratio: 0.6) and (max-aspect-ratio: 1), (min-aspect-ratio: 2.25), plus portrait and landscape variants below 768px. A tall phone and an ultrawide monitor each get a crop made for them.
The launch trailer hero uses sizes="calc(100vw * (16/9))". In the 390×844 3x emulation, the browser picked the 2560w candidate of a 2160×2160 square crop, 218 KB as AVIF. That fits an image covering a full-height portrait box, where the rendered width follows the viewport height.
With object-fit: cover, the browser scales the image until it fills its box and crops the overflow. The width sizes has to describe is that scaled image, which can be much wider than the viewport, and it depends on the viewport's shape. Splitting the sources by aspect ratio lets each one state its width exactly:
<picture>
<!-- portrait: a square crop covering the screen is as wide as the screen is tall -->
<source
media="(max-aspect-ratio: 1)"
srcset="hero-square.jpg?imwidth=1080 1080w, hero-square.jpg?imwidth=2160 2160w"
sizes="100vh"
/>
<!-- between 1:1 and 16:9, a 16:9 image is cropped at the sides -->
<source
media="(max-aspect-ratio: 16/9)"
srcset="hero-wide.jpg?imwidth=1920 1920w, hero-wide.jpg?imwidth=2560 2560w, hero-wide.jpg?imwidth=3840 3840w"
sizes="calc(100vh * 16 / 9)"
/>
<img
src="hero-wide.jpg?imwidth=1920"
srcset="hero-wide.jpg?imwidth=1920 1920w, hero-wide.jpg?imwidth=2560 2560w, hero-wide.jpg?imwidth=3840 3840w"
sizes="100vw"
alt=""
style="width: 100%; height: 100dvh; object-fit: cover"
/>
</picture>3. Pack scroll sequences into short videos
The scroll-driven sequences ("scrollmation" in the site's Sentry span names) are short MP4 files with a lot of keyframes:
| Clip | Resolution | Frames | Keyframes |
|---|---|---|---|
| port-gellhorn | 1920×1280 | 60 in 1.0 s at 60 fps | AV1: 30 of 60. H.264: 15 of 60 |
| ultimate-edition | 2112×1188 | 300 in 10 s at 30 fps | H.264: every 4th frame. AV1: one keyframe plus periodic intra-only frames |
Each clip has an AV1 source first and H.264 second, chosen with codec strings in the type attribute (the bundle also defines a VP9 type but never uses it). The bundle references 263 MP4 URLs. Folder names like libsvtav1/ and libx264/ name the encoders, and the files carry ffmpeg's Lavf encoder tag. The videos are imported through the bundler, so they get content-hashed names under /_next/static/media/ and the same one-year max-age as the JavaScript.
AV1 is not automatically smaller. For ultimate-edition at 1920, AV1 was 10.3 MB against 16.3 MB for H.264. For port-gellhorn, AV1 was 3.9 MB and H.264 1.5 MB, so AV1 came out 2.6 times larger, with twice as many keyframes. The H.264 ultimate-edition file also carries a 2.3 kbps AAC audio track, although the <video> is muted.
A short keyframe interval keeps seeks cheap, and -an drops audio nobody will hear. Encode both and compare sizes before choosing which source goes first:
# H.264, keyframe every 4 frames
ffmpeg -framerate 60 -i frames/%04d.png -c:v libx264 -g 4 -pix_fmt yuv420p \
-an -movflags +faststart scrub-h264.mp4
# AV1 with SVT-AV1, same keyframe interval
ffmpeg -framerate 60 -i frames/%04d.png -c:v libsvtav1 -g 4 -pix_fmt yuv420p \
-an -movflags +faststart scrub-av1.mp4
ls -l scrub-*.mp4The site's scrub code sets currentTime to the clip's duration times the scroll progress, inside requestAnimationFrame. GSAP ScrollTrigger is in the bundle and can supply that progress value. The version below needs no dependency and uses the site's codec strings:
<video muted playsInline preload="none" aria-hidden="true">
<source src={av1Url} type='video/mp4; codecs="av01.0.04M.08"' />
<source src={h264Url} type='video/mp4; codecs="avc1.4D401E"' />
</video>export function bindScrub(video: HTMLVideoElement, section: HTMLElement) {
let raf = 0;
const update = () => {
raf = 0;
const rect = section.getBoundingClientRect();
const distance = rect.height - window.innerHeight;
const progress = distance > 0 ? Math.min(1, Math.max(0, -rect.top / distance)) : 0;
if (video.duration) video.currentTime = video.duration * progress;
};
const onScroll = () => {
if (!raf) raf = requestAnimationFrame(update);
};
window.addEventListener("scroll", onScroll, { passive: true });
return () => {
window.removeEventListener("scroll", onScroll);
cancelAnimationFrame(raf);
};
}4. Buffer on desktop, stream on mobile
The video loader branches on device type. On desktop it fetches the whole file, turns it into a Blob and gives the <video> an object URL, so seeks never wait on the network. On mobile it sets src directly and lets the browser stream. In mobile emulation, the 450px-wide AV1 file arrived as 39 range requests totalling 80 KB during a scroll. Loads go through an AbortController, so a section can cancel its download.
One caveat: in the desktop runs the homepage videos never got a src and the page showed posters instead. The cause wasn't found, so the desktop path comes from reading the code.
export async function loadScrubVideo(video: HTMLVideoElement, src: string, signal: AbortSignal) {
if (matchMedia("(max-width: 767px)").matches) {
video.src = src; // stream with range requests
return () => {};
}
const res = await fetch(src, { signal });
if (!res.ok) throw new Error(`Video request failed: ${res.status}`);
const objectUrl = URL.createObjectURL(await res.blob());
video.src = objectUrl;
return () => URL.revokeObjectURL(objectUrl);
}I'd only do the full download for clips of a few megabytes. A 10 MB blob stays alive until you revoke its object URL, and that adds up on a cheap laptop with many tabs open.
5. Ship a capability tier
A function in the bundle sorts every visitor into "hifi" or "lofi". It returns "lofi" when Save-Data is on, the browser is offline, the user prefers reduced motion, or the browser or device matches a list: legacy Edge, IE, the Google Search app, iOS Safari 15 or older, any Firefox, consoles, smart TVs, wearables and embedded devices. Everyone else gets "lofi" with fewer than 4 logical cores, or with less than 4 GB of device memory, except that the memory check is skipped in Safari and Firefox. The result becomes a vanilla-extract recipe variant, and the same inputs go to Sentry.
Safari and Firefox implement neither navigator.deviceMemory nor saveData, so the memory exception probably keeps a missing value from counting as low memory. The blanket Firefox rule is harder to explain from the outside, and I wouldn't copy it. A version built on feature checks:
export type Experience = "hifi" | "lofi";
export function getExperience(): Experience {
const nav = navigator as Navigator & {
deviceMemory?: number;
connection?: { saveData?: boolean };
};
if (nav.connection?.saveData || !nav.onLine) return "lofi";
if (matchMedia("(prefers-reduced-motion: reduce)").matches) return "lofi";
if (nav.hardwareConcurrency < 4) return "lofi";
// deviceMemory is Chromium-only, so "unknown" counts as capable
if (nav.deviceMemory !== undefined && nav.deviceMemory < 4) return "lofi";
return "hifi";
}Render the lofi version on the server and upgrade on the client, so a slow phone never downloads the heavy version only to discard it:
"use client";
import { useEffect, useState } from "react";
import { getExperience, type Experience } from "@/lib/experience";
export function Hero() {
const [experience, setExperience] = useState<Experience>("lofi");
useEffect(() => setExperience(getExperience()), []);
return experience === "hifi" ? <ScrubVideo /> : <Poster />;
}6. Respect reduced motion in CSS and skip the intro
On desktop, screenshots show a dark loader with a faint Rockstar logo from 0.8 s to 2.6 s, the VI logo zooming over the poster at about 4.0 s, and the final poster with navigation at about 5.5 s. With prefers-reduced-motion: reduce, the zoom is gone and the final poster is there at 4.0 s, but the same loader still sits on screen until about 2.6 s. The 59 stylesheets contain no prefers-reduced-motion media query. The preference is read only in JavaScript, in the tier function and in a React hook.
I'd add a CSS safety net that works before any JavaScript runs. Beyond that, I'd send reduced-motion users straight to the final frame and start smooth-scroll libraries like Lenis only for users who haven't asked for less motion.
@media (prefers-reduced-motion: reduce) {
*,
*::before,
*::after {
animation-duration: 0.01ms !important;
animation-iteration-count: 1 !important;
transition-duration: 0.01ms !important;
scroll-behavior: auto !important;
}
}7. Don't judge an intro by LCP alone
Two identical desktop runs gave very different Largest Contentful Paint results. In the first, LCP was poster_full.jpg at 8.8 s. In the second, it was an <h2> at 1.47 s and then the trailer image at 1.7 s, while screenshots at 1.6 s and 2.6 s showed only the dark loader. The browser had painted that image underneath the intro overlay, and LCP counted it. CLS stayed between 0.003 and 0.012 in every run.
Rockstar also measures media directly: Sentry spans named scrollmation <src> wrap the video loads, and Sentry receives connection round-trip time and device memory too.
If your page has an intro, record the moment the hero is actually visible, and compare it with the filmstrip in the DevTools Performance panel:
function onIntroFinished() {
const mark = performance.mark("hero-visible");
navigator.sendBeacon("/api/rum", JSON.stringify({ name: mark.name, value: mark.startTime }));
}8. Check what the server actually sends
The site serves no Brotli. A request that accepts only br gets the HTML uncompressed, 1,467,299 bytes. With gzip in the Accept-Encoding list, it returns 122,544 bytes of gzip. The JavaScript behaves the same way.
Decoded, the HTML is 1.47 MB, and only 367 KB of that is markup. The other 1.09 MB is the inline React Server Components payload. About 394 KB of it is 8,965 repeated chunk paths: every client component reference lists its JavaScript chunks again, so each chunk filename shows up around 400 times. Gzip squeezes the payload to 90 KB, but the browser still parses all 1.47 MB. The 37 script files add up to 917 KB gzipped and 3.06 MB uncompressed.
Two commands are enough to check your own site:
# Does the CDN serve Brotli? No content-encoding line means no.
curl -s -o /dev/null -D - -H 'Accept-Encoding: br' https://example.com/ | grep -i content-encoding
# Transferred vs decoded size of the HTML
curl -s -H 'Accept-Encoding: gzip' https://example.com/ | wc -c
curl -s --compressed https://example.com/ | wc -cSince each client component reference carries its own chunk list, I'd expect fewer, larger "use client" boundaries to mean fewer copies. I can't build Rockstar's code, so that is untested here.
What I wouldn't copy
These cost bytes or accessibility, and from the outside I couldn't see what they buy:
- About 1.47 MB of the 1.98 MB of initial image bytes on desktop belonged to images more than two viewports below the fold, all marked
loading="eager". A merch card at y=11,575 downloaded before any scroll. - Six fonts are preloaded: five WOFF files instead of WOFF2, plus an OTF, 347 KB in total. Two of them weren't used on the first screen. The metric-matched fallbacks from
next/font(size-adjust,ascent-override) are worth copying, and probably part of why CLS stayed around 0.01. - FingerprintJS (56 KB uncompressed) and global core-js polyfills load with the initial scripts, next to about 550 KB of tag manager and consent code.
- There is no
<h1>on the homepage or on the five subpages checked. The "Skip to Main Content" link points at#main, and no element has that id. The viewport meta includesuser-scalable=no, and the home link is an<a>withrole="button".
The part I'd study is the media pipeline: format negotiation behind plain image URLs, scrub videos encoded for seeking, and a tier that decides who gets them. Most of the weight comes from things the design doesn't need, like the RSC payload inlined in the HTML and eager images far below the fold. Both show up within minutes in curl and the Network panel, so I'd check for them on my own pages before a launch.