Custom browsers built on Chromium.From the engine up.

We don't wrap Chrome in a skin. We modify Chromium at the source level — custom rendering pipelines, enterprise policy engines, embedded browser shells, and purpose-built browsers for industries where off-the-shelf isn't an option. Chromium development services for teams that need a browser as a product, not as a dependency.

  • Chromium source
  • CEF / WebView2
  • Enterprise-grade
  • Custom builds

Why Entalogics for Chromium

Four things every
Chromium project
actually needs.

Chromium has 35 million lines of code. Most teams that fork it can't keep their fork rebased past two upstream releases. We've maintained production Chromium forks across dozens of upstream updates — the discipline isn't in the initial modification, it's in the merge strategy that keeps it alive.

Performance01

Strip what you don't need. The engine gets faster.

A default Chromium build includes sync, translate, extensions, and dozens of services your product doesn't use. We strip unused components at the GN flag level — smaller binary, less memory, faster cold start on the hardware that actually runs it.

Architecture02

Modify at the right layer. Not everything needs a source fork.

CEF for embedding a browser into a desktop app. WebView2 for Windows-native browser embedding. Chrome Extensions for surface-level customisation. Source-level modification only when the API layers genuinely can't do what you need. We pick the lightest approach that solves the problem.

State03

A merge strategy or a dead fork.

Every Chromium modification is a maintenance commitment. We structure patches as isolated, rebased changesets against upstream milestones. When Chrome ships a security fix, your fork gets it in days — not months of manual conflict resolution.

Type safety04

Chromium's C++ codebase demands Chromium-grade discipline.

Mojo IPC for inter-process communication. `base::` types instead of STL where Chromium expects them. Memory safety via `raw_ptr`, `base::SafeRef`, and Chrome's clang plugins. Building inside Chromium means following Chromium's rules — not fighting them.

When Chromium, when not

Chromium is a platform.
Not a quick modification.

Forking Chromium is easy. Maintaining that fork is where teams fail. We'll tell you on the first call if a source fork is justified — or if CEF, WebView2, or an extension gets you there without the maintenance cost.

FORK CHROMIUM WHEN

  • You're building a browser as a product — kiosk browsers, enterprise browsers, vertical-specific browsers
  • Security controls at the engine level — no extensions, no developer tools, no URL bar, policy-enforced restrictions
  • Custom rendering pipeline or protocol handling that the extension API can't reach
  • Embedded browser in industrial, medical, or automotive hardware where Chrome isn't an option

USE CEF OR WEBVIEW2 WHEN

  • You need to embed a browser component inside a desktop application
  • Standard web rendering is enough — you don't need to modify how pages render
  • The CEF or WebView2 API surface covers your customisation requirements

WE SAY NO WHEN

  • "Fork Chromium to change the default search engine." An extension does that. You don't need us.
  • "We need a custom browser in three weeks." Chromium builds alone take longer than that.
  • "Fork it and we'll maintain it ourselves." You won't. The upstream moves too fast.

What we build in Chromium

Six product surfaces.
One quality bar.

The shapes of Chromium development work we deliver most. Each built to survive upstream updates — not just the initial build.

  • S01

    Custom enterprise browsers

    Locked-down browsers with policy-enforced restrictions — no downloads, no dev tools, no URL bar, SSO-integrated, MDM-compatible. Built for regulated industries.

    CHROMIUMENTERPRISE POLICYSSOMDM
  • S02

    Kiosk & digital signage browsers

    Single-purpose browsers for retail, hospitality, and healthcare kiosks. Locked to approved URLs, auto-restart on crash, remote configuration, touch-optimised.

    CHROMIUMKIOSK MODEREMOTE CONFIGTOUCH UI
  • S03

    CEF-embedded desktop applications

    Chromium rendering inside a C++, .NET, or Java desktop application via CEF. Browser functionality without building a full browser — reporting dashboards, HTML-based UIs, embedded documentation viewers.

    CEFCEFSHARPJCEFC++
  • S04

    Privacy-first browsers

    Stripped telemetry, integrated VPN, built-in ad blocking at the network level, custom certificate handling. Chromium rebuilt for privacy as a product feature.

    CHROMIUMDNS-OVER-HTTPSVPN INTEGRATIONAD BLOCKING
  • S05

    Chromium for embedded hardware

    Browser shells on Linux-based embedded devices — automotive infotainment, smart displays, industrial panels. Chromium compiled for ARM, stripped to minimum footprint.

    CHROMIUMOZONEARMYOCTO
  • S06

    Chromium fork maintenance & upstream sync

    Inherited a Chromium fork that's 15 milestones behind? We rebase your patches, resolve conflicts, update to the latest stable, and establish a repeatable merge workflow.

    GIT REBASEGN FLAGSCHROMIUM CIPATCH MANAGEMENT

The playbook

Patterns we
ship on repeat.

Chromium patterns from maintained production forks — not one-off builds that rot.

  • P01

    Isolated patch sets

    Every modification is an isolated, documented patch against upstream. Clean rebase on each milestone update. No monolithic diffs that become unmergeable.

  • P02

    GN flag stripping

    Disable unused features at the build system level — sync, translate, safe browsing, extension system — before they add binary size and attack surface.

  • P03

    Enterprise policy engine

    Chrome's enterprise policy infrastructure used for product-level controls — URL allowlists, download restrictions, proxy configuration, authentication enforcement. Policy, not preferences.

  • P04

    Mojo IPC for custom services

    New browser services wired through Chromium's Mojo IPC layer — the same way Chrome's own services communicate. No bolted-on IPC that breaks on the next upstream merge.

  • P05

    CI against upstream milestones

    Automated builds and tests triggered on every new Chromium milestone release. Merge conflicts detected in CI — not three months later when a security patch is urgent.

  • P06

    Security patch turnaround

    Upstream security fixes applied within 72 hours of Chromium stable release. Your fork stays within one milestone of upstream at all times. No drifting behind while CVEs accumulate.

Signature case

A privacy browser,
rebuilt from a stale fork to upstream-current.

An enterprise privacy browser forked from Chromium 108 — 14 milestones behind upstream, 340+ merge conflicts blocking the rebase, integrated VPN that broke on every update, and three known Chromium CVEs unfixed. Rebased to Chromium 128, restructured all patches as isolated changesets, and established a milestone-per-sprint merge workflow in 10 weeks. CVEs resolved. VPN integration stable. Fork maintainable going forward.

Before

Chromium 108 · 14 milestones behind · 340+ conflicts · 3 unpatched CVEs · VPN broken on update

After

Chromium 128 · current milestone · isolated patches · 0 CVEs · VPN stable across updates

  • Milestones behind14 → 0
  • Unpatched CVEs3 → 0
  • To fully rebased10wk
  • Merge workflowrepeatable

Engagement shape

Eight to ten weeks
to a measurable ship.

A typical Chromium development engagement. We build or rebase milestone by milestone — the current product keeps shipping while we work.

  • W01

    Audit + RFC

    Two senior Chromium engineers. Fork delta analysis, patch inventory, build system audit, upstream gap assessment. A ranked, dollarized RFC.

  • W02–03

    Foundation + first rebase

    Build system configured, GN flags stripped, first milestone rebase completed, CI pipeline running against upstream. Real build on target platforms.

  • W04–08

    Milestone by milestone

    Patches rebased, features integrated, tests passing on each milestone. Your product keeps shipping on the current fork while the new one catches up.

  • W09+

    Release + handoff

    Production build on current upstream milestone. Merge workflow documented. Runbook handed to your team — or we stay on retainer.

Stack

Tools we
reach for first.

Our default Chromium development stack — picked for real fork maintenance.

  • PlatformChromium · CEF · WebView2 · Chrome Extensions API
  • LanguageC++ · Mojo IPC · GN · Python (build scripts)
  • BuildNinja · GN · depot_tools · autoninja
  • TestingChromium test framework · gtest · browser_tests · Playwright
  • ToolingGerrit · Code Search · Clang · AddressSanitizer
  • InfraGitHub Actions · GCP · Docker · Sentry · CrashPad

Engagement

Three ways
to work with us.

No hourly retainer that bills for "thinking time." Pick a lane that matches your stage; everything is fixed-quote or transparently rated.

FIXED SCOPEone-off build

Ship a Chromium project, end-to-end.

A defined scope, a fixed price, a senior-only team. From RFC to production build in 10–16 weeks.

$15k–$30k

FIXED SCOPE

  • Senior engineers only
  • Fixed quote in week 1
  • Code, infra, runbook — yours
Plan a fixed build
DEDICATED TEAMmonthly

Hire dedicated Chromium developers.

Embedded engineers in your Slack, your Jira, your standups. Senior C++ engineers who work inside Chromium's codebase daily. Pause, resize, end with 30 days' notice.

$5k / eng / mo

PER ENGINEER

  • Same senior bar as fixed-scope
  • Embedded in your team
  • Founder-direct escalation
Hire dedicated Chromium devs
ENGAGEMENTcustom

Strategic Chromium partnership.

A long-term partner for organisations maintaining Chromium forks — upstream sync, security patching, feature development, hiring help.

custom

PROCUREMENT-FRIENDLY

  • Multi-quarter roadmap
  • Architecture & hiring partner
  • Procurement-friendly paper
Speak to the founder
FAQ

Sharp questions,
straight answers.

Fork vs CEF, upstream sync, build times, existing forks — the questions we get on every Chromium discovery call.
CEF if you're embedding a browser inside a desktop app — it handles 90% of embedding use cases. WebView2 if your app is Windows-native. Fork only when you need engine-level changes — custom policies, stripped components, modified rendering — that the API layers can't reach.
Isolated patch sets rebased on each milestone release. CI that builds and tests against every new upstream stable. Security patches applied within 72 hours. The fork never drifts more than one milestone behind.
Full build: 2–4 hours depending on hardware. Incremental builds: 5–15 minutes. We configure distributed builds and caching in CI to keep iteration fast.
Yes. The engineers who write the RFC ship the code. No handoff mid-engagement. Direct access throughout.
Yes. We've inherited forks ranging from 5 to 30 milestones behind upstream. We audit the patch delta, restructure into isolated changesets, and rebase. If the fork is too far gone, we'll tell you honestly.

Founder-direct

Tell us whatyou're building.

Thirty minutes with the founder. We'll bring a senior Chromium engineer, the relevant playbook, and a candid read on whether a source fork is the right call — or whether CEF, WebView2, or an extension solves your problem at a fraction of the cost.