Engineering service
Custom Chromium browser development
We build and maintain custom Chromium browsers: your brand and features on top, engine changes where you need them, and signed releases that stay current with Chrome's security updates.
- 11+ years of experience
- 300+ projects delivered
- Remote team, clients worldwide
- NDA on request
Overview
What it is and when it fits
Chromium is the open-source project behind Chrome, Microsoft Edge, Brave, Opera and many other browsers. It is roughly 35 million lines of code, made of a few large parts: the Blink rendering engine, the V8 JavaScript engine, the Content layer that ties them together, the browser UI, the networking stack and the sandbox. A custom browser is your product built on top of those parts.
Changing Chromium once is the easy part. Chrome now ships a new major version every two weeks, so most of the work is keeping your changes small enough to carry forward. We keep them as a reviewable patch series that is rebased onto new upstream releases, instead of edits scattered across the tree.
Who this is for
- Founders and product teams building a browser as their product: their brand, their features, their defaults.
- Companies that need behavior no extension or embedded browser can reach: networking, UI, profile handling or built-in features.
- Organizations that already run a Chromium fork and need it audited, upgraded or taken over.
- Teams weighing a fork against an extension, CEF, WebView2 or Electron who want a clear recommendation.
How it works
Architecture at a glance
Anatomy of a custom Chromium browser
Your browser
Name, branding, new-tab page, settings, onboarding and the built-in features that make it yours.
Patch series
Small, documented changes to Chromium, kept separate from upstream code and rebased on each release.
Chromium
Browser UI, Content, Blink, V8, networking and the sandbox, kept as close to upstream as possible.
Build and release
- Windows
- macOS
- Linux
GN builds with Siso or Ninja, CI, installers, code signing and auto-update.
- Your productWhat your users see
- Our engineeringWhat we build and maintain
- UpstreamThird-party code we build on
- Platforms and releaseBuild, sign and deliver
What we offer
What we build on Chromium
Branding and first-run experience
Your name, icons, new-tab page, onboarding, default search and settings, changed in the source so they survive every update.
Built-in features
Ad and tracker blocking, a VPN or proxy, a crypto wallet or an AI sidebar, built into the browser rather than added as extensions users can remove.
Privacy and security changes in the engine
Stricter defaults, telemetry and Google service calls removed or redirected, and anti-fingerprinting work in Blink and the network stack.
Enterprise policy and managed deployment
Chromium's policy system set up for your fleet: locked settings, extension allow and force-install lists, and packages for Group Policy or MDM tools.
Installers, signing and auto-update
Installers for Windows, macOS and Linux, code signing and notarization, and an update service you run so fixes reach users without a reinstall.
Fork takeover and Chromium upgrades
An audit of an existing fork, then its patches rebased onto a current Chromium release and kept there as new versions ship.
Process model, site isolation and sandbox
Engine work in Chromium's Content layer: how renderer, GPU and utility processes start and are isolated, for kiosks, embedded hardware and locked-down deployments.
Custom URL schemes and protocol handlers
Your own URL schemes so the browser can load internal apps, local packages or proprietary content types alongside http and https.
Component updates from your own server
Chromium's component updater pointed at your server, so data such as certificate revocation lists or your own filter lists update without a full browser release.
Deliverables
What you get
- 01
Patch series in a repository your team controls
Every change is a small, described patch on top of a named upstream version, so a reviewer can see exactly what differs from Chromium.
- 02
Reproducible build setup
GN configuration and CI, so any engineer can produce the same binaries from a clean checkout.
- 03
Your product surfaces
Name, icons, new-tab page, onboarding, default settings and the built-in features agreed in scope.
- 04
Installers, signing and update channel
Platform installers, code signing and notarization, and an update service so users receive fixes without reinstalling.
- 05
Upgrade runbook
Written steps for rebasing the patch series onto a new Chromium release and verifying it.
- 06
Test plan and results
Functional checks for your custom features and a regression pass on core browsing behavior.
Compare
Fork, embed or extension: choosing the right approach
Each option trades control against the work of keeping it current. Pick the lightest one that covers what you need.
| Approach | What you control | Ongoing cost | Choose it when |
|---|---|---|---|
| Browser extension | Behavior on web pages and some browser features, within the extension APIs | Low | Your feature works inside users' existing browsers and you do not need your own browser. |
| Embedded browser (CEF, WebView2) | A web view inside your own application, with hooks for navigation and content | Medium | You are building a desktop app that needs to show web content but is not itself a browser. |
| Electron app | A desktop app built with web technologies, with your own main-process code | Medium | You want a cross-platform desktop app and the browser is not the product. |
| Custom Chromium browser | Browser UI, networking, profile handling, built-in features and engine behavior | High | The browser itself is the product, or you need changes that no extension or embed can make. |
Why it matters
What this gives you
Control beyond extension APIs
Changes happen in Blink, V8, the network stack or the browser UI, so you can ship behavior extensions cannot reach, and users cannot remove it like an add-on.
Control over networking
Decide how your browser handles proxies, encrypted DNS and certificates, not only what pages may request.
Stricter isolation where you need it
Process isolation and sandbox policy can be tightened for kiosks, regulated environments and embedded hardware.
Changes in the right layer
Chromium is roughly 35 million lines of code. Putting each change in the layer it belongs to keeps your patch series small and each upgrade cheaper.
Our approach
How a Chromium project runs
Feasibility
We review what you want to change and check whether a lighter option would do the job.
You get: A written recommendation and an estimate range
Architecture
We decide which Chromium layers each feature touches and how to keep those changes isolated.
You get: A patch plan and a chosen upstream version
Build
We set up the build system and CI first, then implement features as small patches.
You get: Working builds from a clean checkout
Harden and test
We test your features and core browsing behavior, and review changes near security boundaries.
You get: Test results and a list of known limits
Release and maintain
We ship signed installers with an update path and rebase onto new Chromium releases, or hand your team the runbook.
You get: Release pipeline and upgrade runbook
When this is not the right fit
- You only need to change behavior on some websites. An extension is cheaper to build and to keep running.
- You have no team or budget to keep a fork updated. A fork that falls behind collects unpatched security issues.
- You need web content inside an existing desktop app. An embedded browser or Electron usually fits better.
Tech stack
Technologies we use
The engines, APIs and tools we use for custom Chromium browsers.
Chromium
C++BlinkV8GNSisoMojo IPCContent APIChrome DevTools ProtocolSite isolationOmahaFAQ
Common questions
Typical ranges, not a quote: a rebranded Chromium build with light changes takes 6–10 weeks, a custom Chromium browser with its own features reaches a first release in 3–6 months, and deep engine work takes 6–12 months or more. Each extra platform adds time. After a short feasibility review we give you a written estimate for your scope.
The work lives in a repository your team controls. Ownership and licensing terms are agreed in the contract before work starts. Chromium itself stays under its own open-source licenses.
Chrome has shipped a new major version every two weeks since Chrome 153 (September 2026), with security fixes in between. Chromium has no long-term support branch; the slowest official line is Chrome's Extended Stable, which moves every 8 weeks. We rebase your patch series onto the line you choose and ship through your update channel. Rebasing one version typically takes 1–3 weeks, depending on how many patches you carry.
Yes. We start with an audit of the patches, the build system and how far the code has drifted from upstream. That tells you whether to continue, clean it up or re-apply the changes on a fresh base.
Windows, macOS and Linux are the standard targets. Chromium also builds for Android, so many desktop changes can carry over to an Android browser. iOS is different: Apple requires iOS browsers to use its WebKit engine, except in the EU and Japan for apps with Apple's special entitlement, so an iOS version is usually a separate WebKit-based app. We have built Android and iOS browsers; tell us early, because mobile changes the architecture.
No one outside those companies can. Opera and Edge are built on Chromium, but their own code is proprietary, so they cannot be forked. We build similar features, such as a sidebar, workspaces, a built-in VPN or ad blocking, into your own Chromium browser. Your Chrome extension already runs in both.
Proof
Related production work
Security browsers
Total Security Browser
A hardened Chromium browser for Total Security Limited in the UK. We built the browser, its installer and its Omaha-based auto-updater.
- Omaha
- Installer
- Security hardening
Multi-session browsers
Symphony Browser
A multi-session Chromium browser we built for a private client: every tab is its own isolated session, with fingerprint protection built in.
- Session isolation
- Fingerprint protection
- Chromium
Privacy and anti-fingerprinting
Anti-Fingerprint Chromium Browser
A hardened Chromium browser we built for a private client. Canvas, WebGL, audio and font signals are controlled in the engine, so they stay consistent with each other.
- Canvas
- WebGL
- Audio context
Our services
Related services
Custom Chromium browsers
Plan your Chromium browser with an engineer
Describe the browser you want to build or the fork you need to take over. You will hear what it takes to build it and, just as important, to keep it current.
