Keyboard shortcuts

Shortcuts stay out of the way while you type in a field.

Everywhere

Jump to the address bar
/
Show keyboard shortcuts
?

Go to

Go to dashboard
gd
Go to notifications
gn
Go to your pull requests
gp
Go to your issues
gi
Go to your stars
gs
Go to explore
ge
Go to trending
gt
Go to code of this repository
gc
Go to actions of this repository
ga

Repository

Go to a file in the repository
t

Commit scrubber

Scrub to the previous commit
[
Scrub to the next commit
]

Pull request

Open a panel section
12345
Show or hide the panel
i
Refresh the pull request
r
Close the sheet or dismiss the composer
Esc

How it works

Nobody reads the “how” page.

You did. So: the numbers first, red and green, one line each. Then how, for whoever checks. Every number on this page was measured, on a date it names. None of it is a trick, which is the annoying part.

First byte of a pull request page
3.11 s20 msrunner, cold, medians
Scroll through the 656-file diff, forty wheel steps
7.9–13.3 s frozen0.3–1.0 sheadless, 2026-09-19
Read a page while GitHub is not answering
nothing40–341 ms, datedreads failed, 2026-09-16

↓ 20 rows below. One red column, one green, no exceptions.

01 · Every win so far, on one board

Same pages. Same session. One letter apart.

Red is github.com, green is ygithub.com, same account and browser, and a row’s two numbers always come from the same session, dated beside them. The red bar is the full width; the green one is our share of it. Where a row has no two numbers to compare, it says so.

Opening the pull request

  1. First byte of a pull request page

    runner, cold, medians

    3.11 s
    20 ms

    156×

  2. First hunk of a 656-file diff on screen

    runner, cold, medians

    4.54 s
    1.03 s

    4.4×

  3. Page fully loaded

    runner, cold, medians

    5.49 s
    378 ms

    15×

  4. Requests to load that page

    runner, cold

    274
    57

    4.8×

  5. Open the pull request, from the link to the first hunk

    recorded, a person’s pace

    3.46 s
    286 ms

    12×

Inside the 656-file diff

  1. Scroll through the 656-file diff, forty wheel steps

    headless, 2026-09-19

    7.9–13.3 s frozen
    0.3–1.0 s

    7.9×

  2. Longest single freeze on that scroll

    headless, 2026-09-19

    1.9 s
    0.28 s

    6.8×

  3. Jump to the last of the 656 files

    headless, 2026-09-19

    0.2–1.4 s frozen
    under 0.12 s

    1.7×

Moving around

  1. Scrub to the next commit

    recorded, a person’s pace

    1.37 s
    162 ms

    8.5×

  2. Switch to the Files tab of a pull request

    recorded, a person’s pace

    0.60 s
    66 ms

    9.1×

  3. Every further letter typed in the address bar

    bench profile, 2026-09-16

    a spinner, 0.75–2.3 s each
    0 ms

    gone

  4. Open a directory

    recorded, a person’s pace

    471 ms
    32 ms

    15×

  5. Open a pull request from the list

    recorded, a person’s pace

    596 ms
    66 ms

    9×

  6. Open a failed job from its link, to the error in its log

    bench profile, trial address, 2026-09-30

    1.59–2.36 s
    561–857 ms

    1.9×

Without GitHub, or without your PC

  1. Open a pull request on your phone after reading it on your PC

    second device, 2026-09-18

    starts over
    14–17 ms

    no contest

  2. Reload a pull request you had open

    bench profile, 2026-09-16

    3.02 s to the first byte
    218–318 ms to content

    9.5×

  3. Read a page while GitHub is not answering

    reads failed, 2026-09-16

    nothing
    40–341 ms, dated

    no contest

  4. List a directory you never opened, while GitHub is not answering

    switch on, 2026-09-18

    nothing
    525 ms

    no contest

  5. A repository that changed, refreshed for the next reader

    webhook, 2026-09-18

    when they ask
    5 s after the push

    no contest

  6. Where the SQLite that keeps your pages comes from

    Cloudflare, 2026-09-18

    no such thing
    the edge, 171 ms

    no contest

About the 656-file pull request.

github.com built a new files view for pull requests this size, with a virtual list of its own. It is live. It still froze the tab for eight to thirteen seconds on a forty-step scroll, and up to 1.4 s on a jump to the end. Ours: under a second, with a diff library and a tree anyone can install. Modern web standards and open source. That is the whole trick, and it is not even ours.

02 · Four places, one order

GitHub is the last place we look.

A page is looked for here, in this order, and the first place that has it paints. Everything on the board comes from that.

  1. 1first, always

    Your device

    Every page you opened, kept in your browser with the moment GitHub said it. A reload paints from here before anyone is asked.

  2. 2a few hundred milliseconds later

    Our side

    A copy of every page anyone read. Public repositories are shared, private ones stay with the account that read them. Your phone gets what your PC read, live.

  3. 3every request

    This server

    Talks to GitHub for you, keeps its answers for a short while, and streams a page into the document while your browser is still loading scripts.

  4. 4last, and only for what is missing

    GitHub

    The truth. Asked for what is missing, and asked again behind anything served from a copy, so nothing on screen is quietly old.

03 · Six ideas, none of them clever

Boring on purpose.

Each one is a thing the browser already knew how to do. We just did it before you asked. Every page here is built this way, from a diff to trending to an Actions log: the server asks GitHub before your browser does, and a page’s code loads only when you open it.

20 ms to the first byte, not 3.1 s

The document already has the page in it.

The server renders the page and streams GitHub’s answers into it. Your browser hydrates a finished page instead of building one. First byte in 20 ms, not 3.1 s.

a directory opens in 32 ms

The next click is already loaded.

Rest the cursor on a link and what that page opens with is read. The top rows of a list are read before you pick one. A click lands on data the page already holds.

127 ms for a pull request with GitHub off

What you read stays with you.

Your device keeps every page you opened and the whole tree of every repository you visited, for 30 days, dated. When GitHub stops answering, that copy is what you get, and it says how old it is.

14–17 ms on your phone

What anyone read is on our side.

A second device sees copies of the first one’s reads 0.7 s after it lands. Public repositories are shared with everyone; a private one’s copies belong to the account that read them.

5 s after a push

It stays warm without you.

A push or a pull request event refreshes a repository within 5 s. Every 30 minutes the repositories people read most recently are refreshed again, whether or not anyone is looking.

writes wait, your text stays

Nothing is written against a copy.

While GitHub is not answering, comments, reviews and merges wait, and say so. What you typed stays. A copy is for reading.

04 · For whoever checks

The receipts.

Two more tables. Skip them if the board was enough; they are here because somebody will ask.

Three addresses, one pull request, and what the next device gets

headless Chrome on a CI runner in Germany, signed in, 4 rounds of five opens per mode twenty seconds apart, medians of the 20, microsoft/TypeScript/pull/51387/files. The two ygithub hosts ran one after the other on 2026-09-30; github.com as on the front page.

HostFirst byteFirst hunkLoadedWarm hunk
github.comsame day3,106 ms4,538 ms5,487 ms3,522 ms
ygithub.comthe site20 ms1,030 ms378 ms1,167 ms
ctests.ygithub.comthe site plus copies on our side100 ms1,151 ms442 ms1,203 ms

The copies on our side cost nothing on this path: the server writes them after the answer has left. Where they pay is the next device.

GitHub answeringa click paints after

the pull request list
109–407 ms1,042–1,154 ms without copies
a pull request
14–17 ms190–907 ms without copies

GitHub off, device emptyfrom our side

repository front page
1,407 ms
pull request list
515 ms
pull request
779 ms

GitHub off, your devicefrom what it kept

pull request list
87 ms
pull request
127 ms
repository front page
96 ms
directory you opened
341 ms
directory you never opened
525 ms
checks tab
265 ms

05 · So nobody feels tricked

Three things it will not do.

  • It does not make GitHub faster. It asks GitHub less, and earlier.
  • It does not show a copy as fresh. Every copy on screen carries its age, and the banner says when GitHub is not answering.
  • It does not let anyone read a private repository they could not read on GitHub. Private copies belong to the account that read them.

06 · Not yet

What is still coming.

Only what already runs somewhere is named here.

Copies on ygithub.com itself.
They run on this trial address, where every number in the "our side" rows was measured. ygithub.com gets them once they have been boring here for a few days.
A real outage on the record.
The counter on the front page is wired. GitHub has not failed a read here since it started. The switch in the account menu shows what happens when it does.
···
There is more on the list. None of it is public. Each thing goes on this page the day it runs, not the day it is promised.

Switch GitHub off yourself. Open a repository, then pick “Switch GitHub off” in the account menu. Every page you have opened stays readable, each marked with how old it is; writes wait until you switch it back on.

Open microsoft/TypeScript

Back to the letter.