How one Chrome flag made GPU-less WebGL screenshots 4× faster

• Our servers have no GPU. WebGL still has to render somewhere.
• Chrome's default software path (SwiftShader) took ~24s per 3D page.
• Pointing ANGLE at Mesa llvmpipe (--use-angle=gl) dropped it to ~6s.
• The one-line flag is the easy part. The display, the from-source Mesa, and proving it stays on the fast path are the rest of the story.

Our fleet has no GPU, on purpose

ANGLE picks the renderer, not Chrome

• It JITs to native code. LLVM compiles the live shader and GL state into real x86-64, with no interpreter loop.
• It is tiled and multi-threaded. It spreads the work across every core on the node.

The diff is one line

- '--use-angle=swiftshader',
+ '--use-angle=gl',

• --disable-gpu forces SwiftShader on again. It is the most-copied flag in every headless tutorial.
• --in-process-gpu kills the GL surface ANGLE needs.

Without an X display, WebGL falls back to flat 2D

We build Mesa from source

meson setup build \
  -Dbuildtype=release -Dgallium-drivers=llvmpipe -Dvulkan-drivers= \
  -Dllvm=enabled -Dshared-llvm=enabled

browserless.report() reads the live GL context

const browserless = require('browserless')
const report = await browserless.report()
console.log(report)

• type is software / llvmpipe here. swiftshader would mean we fell back, and hardware would mean a GPU appeared.
• mesa is read from the loaded libgallium-<ver>.so, not from dpkg, which reports the stale package version under our side-load.
• simdWidth: 256 means llvmpipe is using AVX2, which explains most of its speed.

Benchmarking took weeks, the code took one line

• Dev machines lie. A real GPU renders pages that come back black on prod, so every number had to come from prod-shaped hardware.
• Single runs lie. Cold JIT, first-paint races, and shared cores skew results. The fastest-looking result was sometimes the wrong one: the flat fallback shipped ~1s quicker.

Production numbers: ~4× isolated, ~2× under load

microlink https://threejs.org/examples/webgl_animation_skinning_blending&screenshot.animated

curl -G "https://api.microlink.io" \
  -d "url=https://threejs.org/examples/webgl_animation_skinning_blending" \
  -d "screenshot.animated=true"

import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://threejs.org/examples/webgl_animation_skinning_blending', {
  animated: true
})

import requests

url = "https://api.microlink.io/"

querystring = {
    "url": "https://threejs.org/examples/webgl_animation_skinning_blending",
    "screenshot.animated": "true"
}

response = requests.get(url, params=querystring)

print(response.json())

require 'uri'
require 'net/http'

base_url = "https://api.microlink.io/"

params = {
  url: "https://threejs.org/examples/webgl_animation_skinning_blending",
  screenshot.animated: "true"
}

uri = URI(base_url)
uri.query = URI.encode_www_form(params)

http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true

request = Net::HTTP::Get.new(uri)
response = http.request(request)

puts response.body

<?php

$baseUrl = "https://api.microlink.io/";

$params = [
    "url" => "https://threejs.org/examples/webgl_animation_skinning_blending",
    "screenshot.animated" => "true"
];

$query = http_build_query($params);
$url = $baseUrl . '?' . $query;

$curl = curl_init();

curl_setopt_array($curl, [
    CURLOPT_URL => $url,
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "GET"
]);

$response = curl_exec($curl);
$err = curl_error($curl);

curl_close($curl);

if ($err) {
    echo "cURL Error #: " . $err;
} else {
    echo $response;
}

package main

import (
    "fmt"
    "net/http"
    "net/url"
    "io"
)

func main() {
    baseURL := "https://api.microlink.io"

    u, err := url.Parse(baseURL)
    if err != nil {
        panic(err)
    }
    q := u.Query()
    q.Set("url", "https://threejs.org/examples/webgl_animation_skinning_blending")
    q.Set("screenshot.animated", "true")
    u.RawQuery = q.Encode()

    req, err := http.NewRequest("GET", u.String(), nil)
    if err != nil {
        panic(err)
    }

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()

    body, err := io.ReadAll(resp.Body)
    if err != nil {
        panic(err)
    }

    fmt.Println(string(body))
}

import createClient from 'microlink.io'

const microlink = createClient()

const data = await microlink.screenshot('https://threejs.org/examples/webgl_animation_skinning_blending', {
  animated: true
})

Heavy shader heroes can still come back black