How performance standards are made
Follow Long Animation Frames from an explainer to a W3C draft: the Web Performance Working Group, origin trials, browser positions, Interop, and how to give feedback.
- 01Follow an API from idea to standardName each step: the explainer, incubation, Chrome's intents and origin trial, the working drafts, Candidate Recommendation and Recommendation.
- 02Read where an API standsCheck a spec's stage, Chrome's chromestatus entry, each engine's standards position, and what each engine really supports.
- 03Give feedback that gets acted onPick the right place for a design idea, a browser bug or a request, and write a report with a minimal test case.
Who decides what a browser can measure?
Ravi looks after the Leaf and Kettle shop's code. In Long Tasks and Long Animation Frames, he found why Asha's tap on Add to cart waited. A chat widget's timer had the main thread. A long animation frame entry named the file: chat.js.
Now Ravi reads that data from all his visitors. Chrome visitors send long animation frames. Firefox and Safari visitors send none. Not a single one.
So Ravi has questions. Who decided that Chrome would have this API? Why don't the others have it? Could he ask for it? And who designs these APIs in the first place? This lesson follows one API, Long Animation Frames, from an idea to a web standard. It answers each question on the way.
First, ask each browser what it can measure. An entry type is one kind of record a browser can write, like event or long-animation-frame. Each browser lists the types it can write in PerformanceObserver.supportedEntryTypes, as The performance timeline showed. The course asked three engines:
// Does this browser write long animation frame entries?const types = PerformanceObserver.supportedEntryTypes;console.log(types.includes("long-animation-frame"));- Line 1 is a comment.
- Line 2 reads the list of entry types this browser can write.
- Line 3 prints
trueiflong-animation-frameis on the list, andfalseif it isn't.
In Chrome 157, it printed true. In Firefox 159 and WebKit 27.2, it printed false. WebKit is the engine inside Safari. Press Edit & run to ask your own browser.
Why it matters: an API that only one browser has tells you about that browser's visitors only. Ravi can see why Chrome users wait. He can't see why Firefox and Safari users wait.
So how did the API get into Chrome? It took several steps, on two roads at once. One road is the standard: a written description that any browser can build from. The other road is Chrome's own: its code, and its choice to turn the API on. Here are both roads in one picture:
A Leaf and Kettle cook has an idea for a new dish. She writes down why customers want it. She serves it at her own counter for a few weeks, and customers fill in feedback cards. Then the chain's recipe group writes the official recipe card, so every shop can make it the same way. Each other shop says what it thinks. A taster visits them all, to check the dish tastes the same.
- In real life: The cook's note about why customers want it
- In JavaScript: An explainer
- In real life: Serving it at one counter, for a few weeks
- In JavaScript: An origin trial in Chrome
- In real life: The chain's recipe group
- In JavaScript: The W3C Web Performance Working Group
- In real life: The official recipe card
- In JavaScript: The specification
- In real life: Each other shop's reply
- In JavaScript: Mozilla's and WebKit's standards positions
- In real life: A taster who visits every shop
- In JavaScript: Shared tests, and the Interop project
A web API becomes a standard in steps. Someone writes down the problem. One browser tries a solution on real sites. A working group writes the specification and publishes it in stages. Other browser makers say what they think, and build it. Shared tests show when they all agree. Most of it happens in public, so anyone can follow it and take part.
How the course recorded it:
- The three answers come from the Mint tea page, opened in Chrome 157 and in Playwright's builds of Firefox 159 and WebKit 27.2, one at a time. Playwright is a tool that drives real browsers from a script.
- Chrome's versions come from chromestatus.com, Chrome's public list of features, through its JSON API, and from the emails it links to.
- Each spec's stage comes from the W3C's own API. Each engine's view comes from its public GitHub repository.
The Web Performance Working Group
Start with the people who write the standard. The W3C, the World Wide Web Consortium, is one of the places where web standards are written. Browser makers, other companies and experts work on them there, together.
The W3C splits its work among groups. A working group is a team with a written plan, called a charter. The charter says which specifications the group writes, and until when. One of these teams is the Web Performance Working Group, or WebPerf WG for short.
Its charter gives its mission: "to provide methods to observe and improve aspects of application performance of user agent features and APIs." A user agent is a browser. In plain words: give developers ways to see how fast their pages are, and to make them faster. The charter splits the work into three parts:
- Measurement: APIs that time loading, rendering, responses to taps, memory, CPU use and errors.
- Scheduling: APIs that help a page plan its work, so the important parts go first.
- Adaptation: APIs that help a page fit the visitor's device, settings and network.
It also names one thing it won't do: "performance data analysis techniques or algorithms". The group decides what browsers report. How you study the numbers is up to you.
Many APIs in this course come from its specs. Navigation Timing, from The navigation timeline, is one. Paint Timing, Largest Contentful Paint and Event Timing are others. So is Long Animation Frames.
Who takes part, and how does the group work?
- W3C members send people. The group can also invite outside experts, called Invited Experts.
- Two chairs lead the group, and a W3C staff contact helps with the process. The group's page lists them.
- It holds a call about every two weeks. Once a year, it meets face to face, in the W3C's week of meetings called TPAC.
- Its minutes, the notes of each meeting, are public. Anyone can read what was said.
- It does its technical work on GitHub, with one repository per spec. The charter says "The public is invited to review, discuss and contribute to this work."
The group decides by consensus. Someone makes a proposal, and the group talks it over until nobody objects strongly. There's little voting. To make a decision final, the chairs send a call for consensus, or CfC. The group then has between one week and ten working days to object.
The neighbours on a street meet every two weeks to agree on shared rules. Anyone can read the notes on the board outside. Before a rule is final, someone asks: "Any objections by Friday?" If nobody objects, the rule stands.
- In real life: The neighbours who meet every two weeks
- In JavaScript: The working group's members
- In real life: The notes pinned on the board
- In JavaScript: The public minutes and GitHub issues
- In real life: "Any objections by Friday?"
- In JavaScript: A call for consensus
- In real life: The rules the street agreed on
- In JavaScript: The group's specifications
The group also stops work. Its newest charter drops the Long Tasks API, the one Ravi used before long animation frames. The reason it gives: Long Tasks "is only implemented in a single browser engine". Chrome 157 still has it. But work on its spec goes back to incubation, which the next section explains.
Several groups take part in a new API, and each decides something different. Read each row across:
| Who | Who can take part | What it decides |
|---|---|---|
| WICG | Anyone who signs the W3C's contributor agreement. | Which new ideas get a repository and editors, before any working group. |
| The Web Performance Working Group | People from W3C members, and invited experts. Anyone can comment on GitHub. | What a spec says, and when it moves to its next stage. |
| Chrome's API owners | Chromium engineers listed in Chromium's API_OWNERS file. | Whether Chrome may run an origin trial, and whether it may turn a feature on for everyone. |
| Mozilla's and WebKit's positions repositories | Anyone can ask. Each engine's own people answer. | What that engine thinks of a spec. Not whether it will build it. |
| The Interop team | People from companies that work on browser engines, such as Apple, Google, Microsoft and Mozilla. | Which features every engine works on together this year, measured with shared tests. |
Why it matters: you don't have to be a member to follow the work, or to join in. The minutes, the specs and the discussions are all open.
From explainer to specification
Now follow long animation frames from the start. Every web API starts as a problem someone can't solve. For this one, it was Ravi's problem. Long tasks said how long the main thread was busy, but not who kept it busy.
Chrome's record of the API lists four ways Long Tasks fell short. Two of them: they "don't contain the rendering phase", and they're "missing details about what made the task long". The first public step was an issue on GitHub, in the Long Tasks repository. The next one was an explainer.
The explainer comes first
An explainer is a short document, usually in Markdown. It says what problem a feature solves, who has the problem, and how the API might look. Chromium's guide to launching features says to write one first, about "use cases and scenarios", and to put it at a public address. It's written for people, not for computers.
A family wants a new kitchen. Before any drawings, they write a list: "We cook together, so we need room for two. The kids do homework here." The architect reads it and asks questions. Only then does she draw the plans, down to every pipe, so any builder can follow them.
- In real life: The family's wish list
- In JavaScript: The explainer: the problem and its use cases
- In real life: The architect's questions
- In JavaScript: Comments from browser makers and developers
- In real life: The detailed plans
- In JavaScript: The specification, exact enough to build from
- In real life: The builders
- In JavaScript: Each browser engine's engineers
Long animation frames' explainer sat next to the Long Tasks spec, in the WebPerf WG's own GitHub. Most new ideas start somewhere else: in WICG.
WICG, where ideas incubate
WICG, the Web Platform Incubator Community Group, is a W3C group made for new ideas. Its charter calls it "a lightweight venue for proposing and discussing new web platform features." Anyone can join. Members sign the W3C's contributor agreement, which covers the rights to what they share.
To propose an idea, you open an issue in WICG's proposals repository. You state the problem, and a rough solution. If browser makers show interest, WICG's chairs give the idea its own repository and editors. Working on an idea there, before it's a standard, is called incubation. When it's ready, it moves to a working group.
The WebPerf WG's charter sets a clear bar for taking an incubated API in. It must be "implemented and available in at least one major browser", and have "support from one more". Layout Instability, the API behind CLS, is still incubating in WICG. So is scheduler.yield().
Chrome's side: four emails and some approvals
Meanwhile, Chrome builds the API. Four steps of Chromium's launch process start with a public email to a mailing list called blink-dev:
- Intent to Prototype: "we're starting to build this." The code goes in behind a flag, a switch that's off unless you turn it on yourself.
- Ready for Developer Testing: developers can turn the flag on and try it.
- Intent to Experiment: a request to run an origin trial on real sites. It needs one LGTM, "looks good to me", from Chrome's API owners.
- Intent to Ship: a request to turn the API on for everyone. It needs three LGTMs.
Each step leaves a record. chromestatus.com links them all. Here are three numbers from the API's entry there:
// Three numbers from LoAF's entry on chromestatus.com.const loaf = { trialFirst: 116, trialLast: 123, shipped: 123 }; console.log(`Origin trial: Chrome ${loaf.trialFirst} to ${loaf.trialLast}`);console.log(`On for everyone: Chrome ${loaf.shipped}`);- Line 1 is a comment.
- Line 2 holds three Chrome versions from the entry.
- Line 4 prints
Origin trial: Chrome 116 to 123. - Line 5 prints
On for everyone: Chrome 123.
The Intent to Ship got its three LGTMs, and the API shipped in Chrome 123. Its spec was still being written. That's allowed. Chromium's guide says: "There's no requirement that a working group adopt the feature before Chromium ships it".
Why it matters: "shipped in Chrome" and "a web standard" are different things. Check both before you count on an API in every browser.
Working drafts, then a Recommendation
Back to the standard. Long animation frames began inside the Long Tasks spec. Later, it got its own spec and its own repository. The copy on GitHub is the Editor's Draft: the group's working copy, which changes often.
To publish a version on the W3C's site, the group runs a call for consensus. Its minutes record one for this API. Then the W3C published it as a First Public Working Draft: the first official stage.
From there, a spec climbs the W3C's maturity stages. The W3C Process Document defines them:
- Working Draft (WD): published for anyone to review. It doesn't have to have the group's full agreement yet. The first one is the First Public Working Draft.
- Candidate Recommendation (CR): complete, widely reviewed, and now gathering implementation experience: browsers building it. A CR Snapshot is a fixed version. A CR Draft collects the changes since the last snapshot.
- Recommendation (REC): endorsed by the W3C and its members. The W3C recommends it "as standards for the Web".
The WebPerf WG's charter adds a rule for leaving CR. Each feature needs "at least two independent interoperable implementations". In plain words: two different browser engines build it, and pass the same tests.
An author shares drafts with friends, chapter by chapter, and rewrites as they comment. When the book is complete, the publisher prints proof copies. Reviewers read them and report problems. Only then does the book go to print.
- In real life: Drafts shared with friends
- In JavaScript: Working Drafts
- In real life: Proof copies for reviewers
- In JavaScript: A Candidate Recommendation
- In real life: Reviewers' reports
- In JavaScript: Implementation experience: engines building it and passing tests
- In real life: The printed book
- In JavaScript: A W3C Recommendation
Here is where the group's specs stand, from its publications page. Read each row across:
| Stage | What it means | The group's specs here |
|---|---|---|
| Recommendation (REC) | Endorsed by the W3C and its members, as a standard for the web. | Navigation Timing (its first level), User Timing Level 2, High Resolution Time Level 2. |
| Candidate Recommendation Draft (CRD) | Complete, widely reviewed, and gathering implementation experience. | Resource Timing, User Timing, Performance Timeline, Beacon. |
| Working Draft (WD) | Published for review by anyone. Still changing. | Navigation Timing Level 2, Paint Timing, Largest Contentful Paint, Event Timing, Server Timing. |
| First Public Working Draft (FPWD) | The first Working Draft the W3C publishes. | Long Animation Frames. |
Why it matters: many APIs in this course are still Working Drafts, yet browsers ship them. A stage tells you how far the document has come. It doesn't tell you whether you can use the API.
Origin trials: trying an API on real visitors
A flag is fine for testing on your own computer. But Ravi's visitors won't turn on flags. To learn whether an API works on real sites, Chrome runs an origin trial.
Chrome's origin trials guide says they "give you access to a new or experimental feature, so that you can test this feature and offer it to your users, for a limited time." When the trial ends, Chrome decides whether the feature ships. It works like this:
- A site registers for the trial. It gets a token: a long string made for that site's origin.
- The site sends the token with every page. It can use a
<meta http-equiv="origin-trial">tag, anOrigin-TrialHTTP header, or a script. - Chrome checks the token. If it's valid, the feature turns on for that page, for every Chrome visitor. No flags.
- The site sends feedback: in private, through the trial's form, and in public, usually on the feature's GitHub.
Leaf and Kettle tries a new iced mint tea. It goes on the specials board for six weeks, only at shops that sign up. Each shop gets a card that names the shop, the dish and the last day. Customers get a feedback slip. After six weeks, the chain reads the slips. The dish joins the menu, changes, or goes away.
- In real life: The specials board, for six weeks
- In JavaScript: An origin trial, for a set range of Chrome versions
- In real life: The shop's sign-up card
- In JavaScript: The token: which site, which feature, until when
- In real life: Only shops that signed up
- In JavaScript: Only pages that send a valid token
- In real life: The feedback slips
- In JavaScript: The trial's feedback form, and GitHub issues
- In real life: Joining the menu
- In JavaScript: Shipping: on for everyone
What's inside a token? Chromium's trial_token.cc defines the format. Here is a real token from Chromium's own tests, made for a test feature called Frobulate:
const token = "A9+2NjaYsaFkwtULzbWjcsSJiXD0LuoOgma9fET8hq1uEqVcNyqjGH4ExpF7mYUk" + "ireYovWqOwsZEyiX6eodfw4AAABveyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l" + "eGFtcGxlLmNvbTo0NDMiLCAiaXNUaGlyZFBhcnR5IjogdHJ1ZSwgImZlYXR1cmUi" + "OiAiRnJvYnVsYXRlIiwgImV4cGlyeSI6IDE0NTg3NjYyNzd9";const bytes = Uint8Array.from(atob(token), (letter) => letter.charCodeAt(0));const detailsLength = new DataView(bytes.buffer).getUint32(65);const details = JSON.parse(new TextDecoder().decode(bytes.slice(69)));console.log(`version ${bytes[0]}, ${bytes.length} bytes, ${detailsLength} in the details`);console.log(`feature: ${details.feature}, for ${details.origin}`);console.log(`third party: ${details.isThirdParty}`);- Lines 1 to 5 hold the token. It's base64: bytes written with letters, digits, + and /.
- Line 6 turns it back into bytes. Byte 0 is the token's version. Bytes 1 to 64 are a signature: a seal made with a secret key. Chrome checks it with the matching public key, so nobody can change the token without breaking the seal.
- Line 7 reads bytes 65 to 68. Together they give the length of the details.
- Line 8 reads the details, from byte 69 on. They're JSON.
- Line 9 prints
version 3, 180 bytes, 111 in the details. - Line 10 prints
feature: Frobulate, for https://valid.example.com:443. - Line 11 prints
third party: true.
So a token names one feature and one origin. That's why Ravi's token would work on his shop, and nowhere else. It also has an expiry: a moment, counted in seconds since 1970. This one has long passed, so Chrome would ignore it.
Version 3 tokens can also be third party. Chrome's guide says a third-party trial lets "providers of embedded content or services" try a feature across many sites. The long animation frames trial allowed this. So a monitoring tool's script could turn the API on for every site that used the tool.
Chrome reads the format before anything else. If the length doesn't match the bytes that follow, it stops there. Try three tokens, including the example in Chrome's own guide:
A token from Chromium's own tests, for the test feature Frobulate.
- Byte 0, the version
3- Bytes 65 to 68, the length field
111- Bytes after byte 68
111- origin
https://valid.example.com:443- isThirdParty
true- feature
Frobulate- expiry
1458766277
The format is right. Next, Chrome checks the signature, then the feature, the origin and the expiry.
Why it matters: if a trial seems not to work, check the token first. Chrome's guide says "Chrome ignores invalid or expired tokens."
How the long animation frames trial went
The API's chromestatus entry lists the trial's goals. It wanted early adopters to collect the API's data from real visitors, and to find "missing or confusing pieces". It added that early adopters "can help us find edge cases."
The trial began in Chrome 116 and was to end in Chrome 120. Then the API's owner asked for "3 more milestones". Early bugs in the trial's setup had given it "a slow start". And it's a "deep" feature, with many edge cases. An API owner said LGTM, to Chrome 123.
Chromium's rules keep trials short:
- A first trial can run for at most 12 Chrome versions.
- Each extension can add at most 6 more.
- Each extension needs progress on five things: a draft spec, a design review by the W3C's TAG, other browsers' views, feedback from the people who write specs, and shared tests.
The TAG, the Technical Architecture Group, is the W3C's team that reviews new APIs' designs. Then the Intent to Ship reported: "The origin trial was a big success". Wix, Microsoft and Google joined it, with "smaller companies and several RUM providers". RUM providers make tools that collect data from real visitors. The API shipped in Chrome 123, the trial's last version.
Why it matters: a trial lets real visitors shape an API before it's fixed. And it's open to you: any developer can register.
What the other engines say
Chrome shipped long animation frames. What about Firefox and Safari? Each engine's makers write down what they think of new specs, in public, on GitHub: Mozilla's standards positions and WebKit's standards positions. Anyone can ask for one by opening an issue.
- Mozilla uses
positive,neutralandnegative. Positive means "a potential improvement to the web." - WebKit uses
support,neutralandoppose. Its README says "Only once a label is assigned to an issue does it represent WebKit's position."
Both repositories warn about the same thing. A position isn't a promise to build. Mozilla's says a position "does not commit Mozilla to implementing a specification in Firefox." WebKit's says its positions "do not reflect implementation status."
Asha invites friends to a tea party. Ben replies "Love it!", then gets busy and doesn't come. Ana says nothing, then turns up with a cake. The replies told Asha what each friend thought. Only the day itself showed who came.
- In real life: Ben's "Love it!"
- In JavaScript: A positive position
- In real life: Ana's silence
- In JavaScript: No position yet
- In real life: Who turns up on the day
- In JavaScript: What each engine ships
- In real life: Looking around the room
- In JavaScript: Feature detection in each engine
Here is the API in the three engines:
Mozilla's issue carries the label position: positive. WebKit's issue is open, with no position label yet. And Firefox 159 printed false. So Mozilla likes the API, but Firefox doesn't have it.
It works the other way too. WebKit's issue for Largest Contentful Paint has no position label either. Yet Safari has LCP entries, from Safari 26.2. Only a real check tells you what an engine does.
Here is the full check the course ran, one line per API:
const types = PerformanceObserver.supportedEntryTypes;const has = (type) => (types.includes(type) ? "yes" : "no");console.log(`long-animation-frame: ${has("long-animation-frame")}`);console.log(`longtask: ${has("longtask")}`);console.log(`event: ${has("event")}`);console.log(`largest-contentful-paint: ${has("largest-contentful-paint")}`);console.log(`layout-shift: ${has("layout-shift")}`);const canYield = typeof scheduler === "object" && "yield" in scheduler;console.log(`scheduler.yield(): ${canYield ? "yes" : "no"}`);- Line 1 reads the list of entry types.
- Line 2 makes a small helper that answers yes or no.
- Lines 3 to 7 ask about five entry types.
- Line 8 checks for
scheduler.yield(), which isn't an entry type.typeofavoids an error in a browser with noschedulerat all. - Line 9 prints that answer.
In Chrome 157, all six lines printed yes. Pick an API to see its whole record: its spec's stage, Chrome's trial, each engine's position, and what each engine printed:
- Spec
- First Public Working Draft
- Written at
- the W3C Web Performance WG
- Origin trial
- Chrome 116 to 123
- On for everyone
- Chrome 123
- Mozilla
- positive
- WebKit
- no position yet
- Firefox since
- not yet
- Safari since
- not yet
- Chrome 157:
yes - Firefox 159:
no - WebKit 27.2:
no
Long Animation Frames: a First Public Working Draft at the W3C. In the course's check, Chrome answered yes.
Why it matters: to know where an API stands, read three records. The spec's stage, each engine's position, and what each engine really does. Only the last one tells you what your visitors get.
Interop: one set of tests, one scoreboard
Two engines can build the same spec and still disagree. How the metrics are computed showed Chrome, Firefox and WebKit reporting different numbers for the same page. Tests catch that.
web-platform-tests, or WPT, is a shared test suite for the web. wpt.fyi shows each engine's results on it. The WebPerf WG's contributing guide expects each change to a spec's rules to come with a matching change in WPT.
The Interop project uses these tests to set shared goals. Its README calls it "a collaboration between organizations that implement web technology in browser engines". Each round works like this:
- An open call: for about three weeks, anyone can propose a feature, as an issue in Interop's GitHub repository.
- A choice: the companies taking part pick the focus areas together. A proposal needs support from at least two of them, and no objection.
- A year of work: a public dashboard shows each engine's share of passing tests, area by area.
Three schools agree to teach the same topics this year. Their pupils all sit the same exam paper. A scoreboard in the town hall shows each school's marks, topic by topic. Nobody argues about whose exam was harder. Everyone can see which topic needs work.
- In real life: The same exam paper for every school
- In JavaScript: web-platform-tests
- In real life: The topics chosen for the year
- In JavaScript: Interop's focus areas
- In real life: The scoreboard in the town hall
- In JavaScript: The Interop dashboard on wpt.fyi
Interop has rules about what it can pick. A focus area needs "a mature-enough web standard" and "high quality tests in WPT". It doesn't invent features. Its README says: "The Interop Project is not an organization for defining web standards."
Performance has been part of it. One round chose LCP and INP, as How the metrics are computed showed. Long animation frames has also been proposed as a focus area. Its tests already exist. The course read wpt.fyi's latest results for its 53 test files:
- Chrome Canary 160, Chrome's daily test build, passed every check in 43 of them.
- Firefox Nightly 162, Firefox's daily test build, passed every check in 0.
- Safari Technology Preview 256, Apple's preview of Safari, passed every check in 0.
Why it matters: a scoreboard shows browser makers where the work is. For you, a failing test is evidence. Link it when you ask an engine for a feature, or report a bug.
How to give feedback
Back to Ravi. He has three things to say:
- He'd like the API to report one more number, for his slow taps.
- In Chrome, one field of an entry looks wrong.
- He wants Safari to have long animation frames.
Each one has its own place to go:
For Safari, WebKit already has an open issue on this API. Its README says "Reviewing proposals is always encouraged". So Ravi can add a comment there, saying how the API would help his shop.
Before you write, search. Someone may have asked already. The group's minutes show it discussing new fields for this API, such as a separate time for style work, in a pull request. If you find an issue, add your support. Say how it affects your site. web.dev's guide to filing a good browser bug says to avoid "+1" comments, since "bug trackers typically send emails for every comment."
A bug report that gets fixed
"My car's broken" doesn't help a mechanic much. "It squeaks when I brake going downhill, since the new tyres" does. Better still, take the mechanic on a short drive and let them hear it. Then they can find the cause.
- In real life: Which car, and how old
- In JavaScript: The browser and its version
- In real life: "When I brake going downhill"
- In JavaScript: The steps to make it happen
- In real life: "A squeak, where it should be silent"
- In JavaScript: The expected result, and the actual one
- In real life: "Since the new tyres"
- In JavaScript: The last version where it worked
- In real life: A short drive together
- In JavaScript: A minimal test case
web.dev's guide and Chromium's bug guidelines ask for the same things:
- Check what's correct first, in the spec or on MDN.
- Test the latest version, and other browsers. A browser that's "the odd one out" generally gets a higher priority.
- Make a minimal test case: the smallest page that still shows the bug. web.dev calls a minimal code sample "the number one thing you can do".
- Write the steps, what you expected, and what happened.
- Give the versions and your system. If it's a regression, give the last version where it worked.
You can change the spec itself, too. The group's CONTRIBUTING file asks for the usual GitHub steps: fork, branch, pull request. Fixes to wording and spelling are welcome. Bigger changes need a promise about patents: you join the group, or sign a licensing commitment. And each change to the rules should come with a WPT test.
Why it matters: browser engineers read many reports. A short page that shows the bug in one click is the fastest way to get yours fixed.
Good feedback or not?
Ravi drafted eight pieces of feedback. Sort each one: does it help engineers act, or is it hard to act on?
- One small HTML file that shows the wrong value, with the browser's version
- Numbered steps, what you expected, and what happened
- A note that Firefox and Safari show the right value
- The last version where it worked, and the first where it broke
- "LoAF is broken on our site", with a link to the whole shop
- A "+1" comment on an existing bug
- A screenshot of a dashboard, with no code and no steps
- A new bug for a problem that's already filed
Sort each piece of feedback by whether an engineer could act on it.
Common mix-ups
- "Chrome waits for a W3C Recommendation before it ships." No. Long animation frames shipped in Chrome 123, before its first public draft. Chromium's guide says a working group doesn't have to adopt a feature first.
- "A positive position means the browser will build it." No. Mozilla is positive about long animation frames, and Firefox 159 still printed
false. - "An origin trial turns the feature on everywhere." No. A Chrome origin trial works only in Chrome, only on pages that send a valid token, and only for a set range of versions.
- "The working group meets behind closed doors." No. Its minutes are public, and its technical work is on GitHub, where anyone can read and comment.
- "Interop invents new features." No. It picks features that already have a mature standard and tests, and helps every engine pass them.
- "A '+1' comment helps a bug get fixed." No. It emails everyone and adds nothing. Star the bug, or say how it affects your site.
Practice exercises
Answer first, then use the hints.
This is the second token from Chromium's test file. What does the last line print?
const token =
"Ay0uBIEXlhMfvS43Z+m8bgeqnnZq27xV4OG13d+bkyGuCKx6Wa+hSkLkk6OStg+D" +
"l8pRdqUG19BhWnizn5TbKAMAAABweyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l" +
"eGFtcGxlLmNvbTo0NDMiLCAiaXNUaGlyZFBhcnR5IjogZmFsc2UsICJmZWF0dXJl" +
"IjogIkZyb2J1bGF0ZSIsICJleHBpcnkiOiAxNDU4NzY2Mjc3fQ==";
const bytes = Uint8Array.from(atob(token), (letter) => letter.charCodeAt(0));
const detailsLength = new DataView(bytes.buffer).getUint32(65);
const details = JSON.parse(new TextDecoder().decode(bytes.slice(69)));
console.log(`version ${bytes[0]}, ${bytes.length} bytes, ${detailsLength} in the details`);
console.log(`feature: ${details.feature}, for ${details.origin}`);
console.log(`third party: ${details.isThirdParty}`);third party: false. Chromium's test file made this token with --no-third-party, so a script from another site can't use it. It also prints version 3, 181 bytes, 112 in the details.
Which Firefox version first had scheduler.yield()?
Firefox 142. Mozilla's position on it is positive, and here Firefox did build it.
How many Chrome versions was the long animation frames trial first planned for? What does line 3 print?
// The versions a trial runs in, the first and the last included.
const versions = (first, last) => last - first + 1;
console.log(`First plan: ${versions(116, 120)} versions`);First plan: 5 versions. Well under Chromium's limit of 12 for a first trial. The extension then added 3 more, under its limit of 6.
Open the API's chromestatus entry. What is its origin trial's Chromium trial name?
LongAnimationFrameTiming. It's also the name of the API's flag on chrome://flags.
Ravi wants to see whether Chrome accepted his token. Which DevTools panel shows a page's origin trials?
The Application panel. Chrome's origin trials guide says it shows the origin trials available to a site, in the page's frame details.
In Chrome, one field of Ravi's long animation frame entries looks wrong. The spec says clearly what it should hold. Where should he report it?
Chromium's bug tracker, at crbug.com. The spec is clear, so it's Chrome's code that's wrong. Attach a minimal test case: one small page that shows the wrong field.
Check your understanding
For each question, ask which record it's about: the spec, Chrome's launch, an engine's position, or the tests.
Question 1 of 7What does the second line of the token example print?
Read the code, then predictconst token = "A9+2NjaYsaFkwtULzbWjcsSJiXD0LuoOgma9fET8hq1uEqVcNyqjGH4ExpF7mYUk" + "ireYovWqOwsZEyiX6eodfw4AAABveyJvcmlnaW4iOiAiaHR0cHM6Ly92YWxpZC5l" + "eGFtcGxlLmNvbTo0NDMiLCAiaXNUaGlyZFBhcnR5IjogdHJ1ZSwgImZlYXR1cmUi" + "OiAiRnJvYnVsYXRlIiwgImV4cGlyeSI6IDE0NTg3NjYyNzd9"; const bytes = Uint8Array.from(atob(token), (letter) => letter.charCodeAt(0)); const detailsLength = new DataView(bytes.buffer).getUint32(65); const details = JSON.parse(new TextDecoder().decode(bytes.slice(69))); console.log(`version ${bytes[0]}, ${bytes.length} bytes, ${detailsLength} in the details`); console.log(`feature: ${details.feature}, for ${details.origin}`); console.log(`third party: ${details.isThirdParty}`);Choose an answer to see the explanation.
Question 2 of 7Mozilla's position on Long Animation Frames is positive. What did the course's check print in Firefox 159?
Choose an answer to see the explanation.
Question 3 of 7Which W3C stage means a spec is complete, widely reviewed, and gathering implementation experience?
Choose an answer to see the explanation.
Question 4 of 7Why did Long Animation Frames run an origin trial before Chrome turned it on for everyone?
Choose an answer to see the explanation.
Question 5 of 7How many LGTMs from Chrome's API owners does an Intent to Ship need?
Choose an answer to see the explanation.
Question 6 of 7What does a feature need before Interop can pick it as a focus area?
Choose an answer to see the explanation.
Question 7 of 7What does the WebPerf WG's charter ask before the group adopts an API incubated in WICG?
Choose an answer to see the explanation.
Key takeaways
- The W3C Web Performance Working Group writes many performance APIs' specs, in public, on GitHub, by consensus.
- An API starts as a problem, then an explainer. The group incubates new ideas in WICG first.
- Chrome's own road runs alongside: Intent to Prototype, an optional origin trial, then Intent to Ship with three LGTMs.
- A spec climbs from Working Draft to Candidate Recommendation to Recommendation. Leaving CR needs two independent implementations.
- A standards position says what an engine thinks, not what it ships. Check each engine for real.
- Interop picks features with mature standards and tests, and shows each engine's progress on one scoreboard.
- Send each kind of feedback to its own place, with a minimal test case.
Remember the one-liner.
An API becomes a standard when the problem is written down, a browser tries it, a working group specifies it, and other engines build it and pass the same tests.
Sources
The facts on this page come from these records, standards, docs and source files:
- Web Performance Working Group, W3C.
- Web Performance Working Group Charter, W3C.
- Web Performance Working Group publications, W3C.
- w3c/web-performance: README and CONTRIBUTING.md, W3C Web Performance Working Group.
- Web Performance Working Group meeting minutes, W3C Web Performance Working Group.
- W3C Process Document, section 6.3.1, Maturity Stages, W3C.
- Web Incubator Community Group Charter, WICG.
- Contributing new proposals, WICG.
- Launching Features, The Chromium Projects.
- Long Animation Frame Timing, Chrome Platform Status.
- Intent to Prototype: Long Animation Frame Timing (LoAF), blink-dev.
- Intent to Experiment: Long Animation Frame Timing, blink-dev.
- Intend to extend experiment: Long Animation Frame Timing, blink-dev.
- Intent to Ship: Long Animation Frame Timing, blink-dev.
- Long Animation Frames explainer, W3C Web Performance Working Group.
- Long Animation Frames API (First Public Working Draft), W3C.
- Get started with origin trials, Chrome for Developers.
- trial_token.cc and trial_token_unittest.cc at 157.0.8103.52, Chromium source.
- Mozilla's positions on emerging web specifications (README and issue 929), Mozilla.
- WebKit's positions on emerging web specifications (README and issue 283), WebKit.
- The Interop Project: README, team charter, and proposal selection process, web-platform-tests.
- Interop proposal: Long Animation Frames API, web-platform-tests.
- long-animation-frame test results, wpt.fyi.
- How to file a good browser bug, web.dev.
- Bug Life Cycle and Reporting Guidelines, The Chromium Projects.
- Browser compatibility data, MDN.
Coming next: What's next for web performance. You'll see the APIs and metrics being designed and tried now, and how to keep up with them.