completefrontend
Open lab My progress
THE WEB PERFORMANCE FIELD GUIDE

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.

By the end, you can
  • 01
    Follow an API from idea to standardName each step: the explainer, incubation, Chrome's intents and origin trial, the working drafts, Candidate Recommendation and Recommendation.
  • 02
    Read where an API standsCheck a spec's stage, Chrome's chromestatus entry, each engine's standards position, and what each engine really supports.
  • 03
    Give 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 have long animation frames?Pop out in the code editor (opens in a new tab)JavaScript
// 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 true if long-animation-frame is on the list, and false if 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:

An API's road to a web standard, in six stages: Idea, a problem, posted as an issue; Explainer, the problem and use cases, in plain words; Incubation, worked on in public, often in WICG; Working Draft, LoAF is here: its first public draft; Candidate Recommendation, complete; two engines must build it; Recommendation, endorsed by the W3C. Below, Chrome's own road for Long Animation Frames: a prototype behind a flag, an origin trial from Chrome 116 to 123, and on for everyone in Chrome 123.the standardIdeaa problem, posted as an issueExplainerthe problem and use cases, in plain wordsIncubationworked on in public, often in WICGWorking DraftLoAF is here: its first public draftCandidate Recommendationcomplete; two engines must build itRecommendationendorsed by the W3CChrome's own steps, alongsidePrototypebehind a flagOrigin trialChrome 116 to 123On for everyoneChrome 123
The top part is the standard, from an idea to a Recommendation. Long Animation Frames has reached its first public Working Draft. The bottom row is Chrome's own road: a trial in versions 116 to 123, then on for everyone in 123.
Real-life analogyA new dish for a chain of tea shops

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
The main idea

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.

Real-life analogyA residents' meeting with open notes

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 decides what
WhoWho can take partWhat it decides
WICGAnyone who signs the W3C's contributor agreement.Which new ideas get a repository and editors, before any working group.
The Web Performance Working GroupPeople 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 ownersChromium 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 repositoriesAnyone can ask. Each engine's own people answer.What that engine thinks of a spec. Not whether it will build it.
The Interop teamPeople 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.

Real-life analogyA wish list before the plans

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:

  1. 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.
  2. Ready for Developer Testing: developers can turn the flag on and try it.
  3. 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.
  4. 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:

Long animation frames in Chrome's recordPop out in the code editor (opens in a new tab)JavaScript
// 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.

Real-life analogyA book, from draft to print

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:

The W3C's stages, and the group's specs at each one
StageWhat it meansThe 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:

  1. A site registers for the trial. It gets a token: a long string made for that site's origin.
  2. The site sends the token with every page. It can use a <meta http-equiv="origin-trial"> tag, an Origin-Trial HTTP header, or a script.
  3. Chrome checks the token. If it's valid, the feature turns on for that page, for every Chrome visitor. No flags.
  4. The site sends feedback: in private, through the trial's form, and in public, usually on the feature's GitHub.
Real-life analogyA trial dish on the specials board

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:

Read an origin-trial tokenPop out in the code editor (opens in a new tab)JavaScript
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:

Playground: read an origin-trial token
Chromium's test token180 bytes

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
Try it yourself
Chrome can read it

The format is right. Next, Chrome checks the signature, then the feature, the origin and the expiry.

The lab follows the format checks in Chromium's trial_token.cc. It doesn't check the signature: that needs Chrome's key.

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."

Long Animation Frames' origin trial, by Chrome version. First planned from Chrome 116 to 120. Extended from 121 to 123. On for everyone from Chrome 123.first planextensionfor everyone116117118119120121122123124Chrome
Each column is one Chrome version. The trial was planned for 116 to 120, then extended to 123. Chrome 123 turned LoAF on for everyone, so the trial's last version was also the first that shipped it.

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, neutral and negative. Positive means "a potential improvement to the web."
  • WebKit uses support, neutral and oppose. 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."

Real-life analogyReplies to a party invitation

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:

The overview's check in three engines, and each engine's word on Long Animation Frames. Chrome 157.0.8103.52 printed true; Chrome's step: on in Chrome 123. Firefox 159.0 printed false; Mozilla's position: positive. WebKit 27.2 printed false; WebKit's position: none yet.Chromeversion 157.0.8103.52printed trueChrome's step:on in Chrome 123Firefoxversion 159.0printed falseMozilla's position:positiveWebKitversion 27.2printed falseWebKit's position:none yet
The same check in three engines. Only Chrome writes long animation frame entries. Mozilla likes the API, but Firefox doesn't have it. WebKit hasn't given a position.

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:

Ask an engine about six APIsPop out in the code editor (opens in a new tab)JavaScript
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. typeof avoids an error in a browser with no scheduler at 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:

Playground: where is each API now?
The standard and Chrome
Spec
First Public Working Draft
Written at
the W3C Web Performance WG
Origin trial
Chrome 116 to 123
On for everyone
Chrome 123
The other engines
Mozilla
positive
WebKit
no position yet
Firefox since
not yet
Safari since
not yet
  • Chrome 157: yes
  • Firefox 159: no
  • WebKit 27.2: no
Try it yourself
On the W3C's track

Long Animation Frames: a First Public Working Draft at the W3C. In the course's check, Chrome answered yes.

Recorded from chromestatus.com's JSON, the W3C's API, the WICG draft's own page, and Mozilla's and WebKit's GitHub issues. The engine check ran in Chrome and in Playwright's builds of Firefox and WebKit. The Firefox and Safari versions come from MDN's compatibility data.

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:

  1. An open call: for about three weeks, anyone can propose a feature, as an issue in Interop's GitHub repository.
  2. A choice: the companies taking part pick the focus areas together. A proposal needs support from at least two of them, and no objection.
  3. A year of work: a public dashboard shows each engine's share of passing tests, area by area.
Real-life analogyOne exam paper, one scoreboard

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:

Where feedback goes. For an idea for the API's design: the spec's GitHub issues. For a bug in one browser: that browser's bug tracker. For a question for one engine: its standards positions. For a brand-new API idea: WICG's proposals. For a test that's wrong or missing: web-platform-tests.what you havewhere it goesan idea for the API's designthe spec's GitHub issuesa bug in one browserthat browser's bug trackera question for one engineits standards positionsa brand-new API ideaWICG's proposalsa test that's wrong or missingweb-platform-tests
Each kind of feedback has its own place. All five are public, so you can first read what others have already said.

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

Real-life analogyDescribing a strange noise to a mechanic

"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?

Good feedback or not?
  • 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
Try it yourself
0 of 8 correct

Sort each piece of feedback by whether an engineer could act on it.

Choose a category for every card. You can change an answer at any time; Reset clears them all.

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.

Exercise 1 · Warm-upAnother test token

This is the second token from Chromium's test file. What does the last line print?

Starter codePop out in the code editor (opens in a new tab)JavaScript
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}`);

Answer, then press Check. Spacing and letter case don’t matter.

    Exercise 2 · Warm-upWhen Firefox got scheduler.yield()

    Which Firefox version first had scheduler.yield()?

    Answer, then press Check. Spacing and letter case don’t matter.

      Exercise 3 · PracticeThe trial's first plan

      How many Chrome versions was the long animation frames trial first planned for? What does line 3 print?

      Starter codePop out in the code editor (opens in a new tab)JavaScript
      // 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`);

      Answer, then press Check. Spacing and letter case don’t matter.

        Exercise 4 · PracticeThe trial's name

        Open the API's chromestatus entry. What is its origin trial's Chromium trial name?

        Answer, then press Check. Spacing and letter case don’t matter.

          Exercise 5 · ChallengeTrials in DevTools

          Ravi wants to see whether Chrome accepted his token. Which DevTools panel shows a page's origin trials?

          Answer, then press Check. Spacing and letter case don’t matter.

            Exercise 6 · ChallengeWhere does the bug go?

            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?

            Answer, then press Check. Spacing and letter case don’t matter.

              Check your understanding

              For each question, ask which record it's about: the spec, Chrome's launch, an engine's position, or the tests.

              The performance standards quiz · 7 questionsScore: first tries count
              1. Question 1 of 7What does the second line of the token example print?

                Read the code, then predictPop out in the code editor (opens in a new tab)JavaScript
                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}`);

                Choose an answer to see the explanation.

              2. 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.

              3. Question 3 of 7Which W3C stage means a spec is complete, widely reviewed, and gathering implementation experience?

                Choose an answer to see the explanation.

              4. 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.

              5. Question 5 of 7How many LGTMs from Chrome's API owners does an Intent to Ship need?

                Choose an answer to see the explanation.

              6. Question 6 of 7What does a feature need before Interop can pick it as a focus area?

                Choose an answer to see the explanation.

              7. 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:

              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.

              CompleteFrontend Clear concepts. Working examples.