Published: April 3, 2025
When it comes time to roll out a new feature in Chrome, there are many checks and balances to ensure a working, compliant and reliable feature. One of those balances is Finch experiments. Don't let the "experiment" portion of its name trick you into thinking it's unsafe, it's quite the opposite. Finch rollouts help us to add features that could potentially cause compatibility issues in a safe way, as they allow us to quickly disable a feature if we encounter unforeseen issues. This article explains how and why we use Finch for some feature releases in Chrome.
Generally, to enable a feature in Chrome simply means to toggle a boolean from off to on inside Chrome. When a new feature "ships", it simply means this boolean has its default state changed to "on" for all users. There are several ways to do that:
- Enable the feature "in code": this means the Chrome executable itself has a setting that is enabled by default.
- Enable the feature "by Origin Trial": the Origin trial system is a way for a particular site to opt all Chrome users into an experiment, which enables a particular feature on that site only.
- Enable the feature "using Finch": Chrome fetches a configuration file from a server periodically, and this file can contain instructions to enable or disable a feature.
- A "Finch kill switch": is the opposite of enabling "using Finch". In this case the feature is enabled "in code" but then disabled using the Finch system, usually due to problems detected after launch
Finch use cases
The topic of this blog post is Finch, so we won't discuss enabling "in code" or "origin trial" much more. But Finch has multiple interesting use cases.
Test on a small group of users (A/B Testing)
Often, Finch is used to do "A/B testing" of a feature or optimization. In this case, a feature is enabled for a small percentage of users, so that data can be collected about the difference in performance, behavior, or usage when the feature is enabled versus disabled.
An example of A/B testing is when we launched Speculative image decodes. This is a performance improvement that should not be noticeable to developers or users, other than causing Chrome to load pages more quickly. But to be sure nothing unexpected happened, and also to be able to accurately measure the performance impact, we used Finch to A/B test it.
Disable a problematic feature
For the safety of the product and user experience, Chrome can use the Finch system to remotely disable problematic features that have been enabled "in code". For example, if a feature was enabled by default, but problems only surfaced after Chrome reached Stable status, we need a way to quickly disable the feature to return users and businesses back to a safe state. That can be necessary when there are undiscovered bugs in the feature, or when a feature happens to break existing sites for unforeseen reasons.
Enable risky features in a safer way
For most of the features that Chrome launches, there is little risk, because we can test and verify that the new code works on all sites.
Sometimes, however, launching features can be quite risky, due to unknown compatibility problems or other tricky interactions. In this case the Finch system can be used to actually enable the feature, rather than simply keeping it in reserve as a kill switch.
For example, HTML parser "relaxation" was a change related to the new customizable-select feature which allowed more content than before to be placed inside a <select> element. Since it's possible that this change could break existing sites, we needed to roll it out carefully.
Enabling features using Finch can be safer than using Finch to remove them, because Finch doesn't reach 100% of users for various reasons. For example, some enterprise users have a policy that prohibits Finch configuration entirely. Those users would remain at risk in the case that a feature is enabled in code, and then kill switched using Finch, because those users will not receive the Finch setting, and will continue to have the feature enabled. By instead enabling the feature using Finch, we can guarantee the ability to disable it for absolutely all users in case of emergency.
How to check if you're in a Finch experiment?
This is difficult for users to do directly. The recommended way is to contact a Chrome engineer (most typically in the context of a Chromium bug) and send them your "variations list". This is a list of special coded versions of all Finch settings for a given browser. It can be retrieved easily:
- Navigate to
chrome://version. - Copy the entire text list (yes it can be quite long) listed next to "Active Variations".
- Paste that text into a text file (for example,
variations.txt) and attach it to a bug.
With this list of variations, Chrome engineers can decode the list and see which features are enabled or disabled on your browser.
What happens when the Finch experiment hits 100% and is good to go?
Once we have made ourselves comfortable that our experiment is "successful", and the feature in question doesn't pose risks to developers or users, we always enable the feature "in code". At this point, it is safe to end-date the Finch configuration, so that it stops having an effect on browsers after the version where the feature was enabled in code.