Xplor is a full web browser — a fork of Chromium (the real thing: Blink, V8, the
multiprocess sandbox, the whole content layer) modified at the C++ source level to be
AI‑native. Every site works, every extension runs, with the sandboxing you expect.
Grok is woven in at the core, not bolted on: an agentic side panel, auto‑organized tabs,
and agents that run on a schedule or quietly in the background. The same engine exposes a
clean local API and a built‑in MCP gateway, so any agent can drive the browser — no
launch flags, no setup dance — and the app keeps itself current with in‑app auto‑update.
Platform: macOS — Apple Silicon (arm64) and Intel (x86_64) — Windows x64, and Linux x64. Download the latest release or build from source.
Contents
Features
Real, shipping features — not a chat box in a sidebar.
- The "Grok it" button — a floating Grok button on every page. Summarize the long
read, fact‑check a claim ("Is this true?"), explain it, or analyze it — the page is
handed to Grok in one click.
- Grok Build — describe an app in plain words and Grok writes it, then runs it live in
a tab. Watch it build, then keep iterating just by chatting ("make the header sticky")
— it edits the app in place, beside a live preview.
- Apps & conversations — every build gets its own folder and a dedicated conversation.
Browse the gallery, filter by status, rename, duplicate, export to a zip, or relaunch —
your apps and chats stay organized.
- Grok Search home — new tabs open Grok Search (Web and Imagine modes built in). Make
the backdrop yours per light/dark mode: a solid color, a gradient, an animated star
field, the built‑in landscape, or your own image by drag‑and‑drop.
- One bar for all of Grok — a unified toolbar across Grok Build, Grok Web, Imagine,
Groki, and X — on Xplor's own pages and as an overlay on grok.com, x.com, and
Grokipedia.
- Agent‑ready & MCP — an always‑on local gateway and a bundled MCP server, so agents
like Grok, Claude, and Cursor can drive the browser natively: tabs, navigation, clicks,
text extraction, screenshots.
See it in motion on the website.
How it works
Stock Chrome only exposes the Chrome DevTools Protocol (CDP) when launched with
--remote-debugging-port, and treats automation as a second‑class debug mode — a
navigator.webdriver flag, an "automation" banner, and a brittle session dance before you
can do anything. Agents deserve better, and people deserve Grok woven into browsing rather
than stapled on. Xplor is both at once, achieved with a small set of source‑level
additions to Chromium:
- AgentGateway (
src/chrome/browser/agent_gateway/) — a component compiled into the
browser process that starts automatically at profile load. It serves the full CDP on
ws://127.0.0.1:9333 and a higher‑level HTTP Agent API on http://127.0.0.1:9334.
- First‑class, not intruder — no automation banner and no
navigator.webdriver
poisoning for gateway sessions. Agents drive tabs while Xplor is in the background;
hidden tabs stay live and screenshottable.
- Local & private — the gateway binds to
127.0.0.1 and is token‑gated. Discovery is
a single file: ~/.xplorer/gateway.json.
- Grok‑native UI (
src/chrome/browser/grok_companion/) — the toolbar, the Grok Search
new tab, the Apps builder, the "Grok it" button, and the side panel. The UI is plain
HTML/CSS/JS served by the gateway and overlaid on Grok's own sites; Grok is wired in as
the default search engine.
- Apps system — "Grok Build" runs the
grok CLI as a subprocess inside a per‑app
folder; it writes static HTML/CSS/JS, and the gateway hosts the result at /run/<id>/.
No bundler, no deploy step.
Architecture
Xplor is an overlay on Chromium: Chromium is too large to vendor, so the repo is a
thin layer (src/ new files + patches/ source edits + companion/ UI) applied on top of
an upstream checkout. Keeping the footprint small is deliberate — it's what makes a fork
rebaseable against a codebase that ships every ~4 weeks.
flowchart LR
subgraph clients["Clients"]
AG["Agents<br/>Grok · Claude · Cursor"]
PW["Playwright · Puppeteer"]
YOU["You (browsing)"]
end
subgraph proc["Xplorer — Chromium browser process"]
GW["AgentGateway<br/>Agent API :9334 · CDP :9333"]
GC["grok_companion<br/>toolbar · Grok‑it button · side panel · search home"]
APPS["Apps runtime<br/>grok CLI → /run/{id}/"]
TABS["Tabs · Blink · V8"]
end
UI["companion/ui<br/>(bundled HTML/CSS/JS)"]
DISC["~/.xplorer/gateway.json<br/>(url · token)"]
AG -- "MCP / HTTP + Bearer" --> GW
PW -- "raw CDP" --> GW
YOU --> GC
GW <--> TABS
GC --> TABS
GW --> APPS
GW -- serves --> UI
GC -- serves/overlays --> UI
GW -. writes .-> DISC
AG -. reads .-> DISC
For agents & developers
The gateway is the integration surface. Discover it, then talk to it (loopback‑only,
token‑gated):
// ~/.xplorer/gateway.json — written at startup
{ "url": "http://127.0.0.1:9334", "cdp_url": "ws://127.0.0.1:9333", "token": "…" }
// Send Authorization: Bearer <token> on every Agent API request.
Python SDK (sdk/xplorer_sdk.py, stdlib‑only, auto‑discovers the running browser):
from xplorer_sdk import Browser
b = Browser()
tab = b.tabs()[0]["id"] # tab ids look like "12:0"
b.navigate(tab, "https://example.com")
print(b.text(tab)) # clean, readable text — one round trip
b.click(tab, "a#more")
tree = b.axtree(tab) # accessibility tree for grounding
shot = b.screenshot(tab) # PNG bytes — works on background tabs
Browser() reads the URL and token from ~/.xplorer/gateway.json, including
the browser's current port. Pass port or token to override discovery; see
connection details for precedence and legacy fallback.
Run SDK connection tests without a Chromium build:
python3 -m unittest discover -s sdk -p 'test_*.py'.
Shell:
GW="$HOME/.xplorer/gateway.json"
URL=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['url'])" "$GW")
TOKEN=$(python3 -c "import json,sys;print(json.load(open(sys.argv[1]))['token'])" "$GW")
curl -s -H "Authorization: Bearer $TOKEN" "${URL%/}/tabs"
MCP (recommended): register sdk/xplorer_mcp.py (stdio, stdlib‑only) and your agent
gets native tools — xplorer_tabs, xplorer_navigate, xplorer_read_text,
xplorer_click, xplorer_type, xplorer_press, xplorer_screenshot, xplorer_eval.
Raw CDP: point Playwright or Puppeteer at ws://127.0.0.1:9333 — no flags.
Full endpoint reference: docs/AGENT_API.md.
Download
Latest builds — these links always point at the newest release. macOS builds
are Developer ID–signed & notarized (open without Gatekeeper warnings); the
Windows build isn't code‑signed yet (SmartScreen may warn — choose More info →
Run anyway, and allow it in Defender if prompted).
macOS: open the DMG and drag Xplorer to Applications. Windows: run the
installer (Xplorer-windows-x64-installer.exe — creates Start‑menu & Desktop
shortcuts), or grab the portable .zip and run Xplorer\Xplorer.exe.
Linux install
Portable x86_64 build — no installer yet. Tested on Ubuntu 24.04; Ubuntu 22.04+
and Debian 12+ should work. Requires an x86_64 CPU (Intel/AMD). ARM64 Linux
(Raspberry Pi, Apple Silicon VMs) will fail with Exec format error.
Quick install — copy‑paste the whole block:
cd ~/Downloads # or wherever you want it
curl -LO https://github.com/daniel-farina/xplorer/releases/latest/download/Xplorer-linux-x64.tar.gz
curl -LO https://github.com/daniel-farina/xplorer/releases/latest/download/Xplorer-linux-x64.sha256.txt
sha256sum -c Xplorer-linux-x64.sha256.txt # prints "...tar.gz: OK"
tar -xzf Xplorer-linux-x64.tar.gz
cd Xplorer-linux-x64
./xplorer
The xplorer wrapper launches the real chrome binary beside it. On first start
the Agent Gateway writes ~/.xplorer/gateway.json and listens on 127.0.0.1:9334
(confirm with cat ~/.xplorer/gateway.json).
Optional — add a menu shortcut (while still inside Xplorer-linux-x64/):
sed "s|@@INSTALL_DIR@@|$PWD|g" xplorer.desktop > ~/.local/share/applications/xplorer.desktop
Sandbox note: the tarball ships without the SUID sandbox bit (tar cannot
preserve it). Modern kernels use the unprivileged namespace sandbox and need no
extra setup. If Chromium warns about the sandbox on your distro, either pass
--no-sandbox or run:
sudo chown root:root chrome_sandbox && sudo chmod 4755 chrome_sandbox
All releases + checksums on the
Releases page, or
build it yourself.
Develop locally
Xplor builds on top of a normal Chromium checkout that lives next to this repo:
chromium/src # upstream Chromium (fetched separately)
xplorer/ # this repo — applied on top
Prerequisites (one‑time): macOS + full Xcode on Apple Silicon, ~100 GB free disk, and
depot_tools on your PATH.
# 1. depot_tools
git clone https://chromium.googlesource.com/chromium/tools/depot_tools.git
export PATH="$PWD/depot_tools:$PATH"
# 2. Chromium source (the long download), as a sibling of this repo
mkdir chromium && cd chromium
fetch --no-history chromium
cd src && gclient runhooks && cd ../..
# 3. this repo, beside chromium/
git clone https://github.com/daniel-farina/xplorer.git
Build:
./xplorer/apply.sh # copy src/ + companion UI + icons, apply source patches
./xplorer/build.sh # Apple Silicon: gn gen out/aether + autoninja
./xplorer/build.sh ./chromium/src x64 # Intel: out/aether_x64 (cross-builds on M-series)
./xplorer/build.sh ./chromium/src linux # Linux x64: out/aether_linux
Linux from source (Ubuntu 24.04+ recommended): same overlay, then
./build/install-build-deps.sh --no-prompt, gclient runhooks, and
./scripts/package_linux.sh to produce dist/Xplorer-linux-x64.tar.gz.
See scripts/linux_buildbox_bootstrap.sh for an unattended remote-build script.
The first build takes a few hours (it compiles all of Chromium locally). After that,
incremental rebuilds are minutes — edit a file and re‑run autoninja -C out/aether chrome.
Companion UI files (companion/ui/*.html|css|js) are served live from disk, so UI tweaks
don't even need a rebuild.
Run it:
open ./chromium/src/out/aether/Xplorer.app
cat ~/.xplorer/gateway.json # confirm the gateway came up
Windows builds the same overlay with the Windows toolchain — PowerShell
scripts mirror the shell ones:
.\xplorer\apply.ps1 -Src C:\src\chromium\src # copy src/ + .ico icon, apply patches
.\xplorer\build.ps1 -Src C:\src\chromium\src # gn gen out\xplorer_x64 + autoninja
Prerequisites differ (Visual Studio 2022 + Windows SDK, depot_tools with
DEPOT_TOOLS_WIN_TOOLCHAIN=0, ~150 GB disk). The output is a flat
out\xplorer_x64\chrome.exe rather than a .app bundle.
Releasing is documented per platform: RELEASE.md (macOS — signing,
notarization, packaging) and RELEASE.windows.md (Windows —
portable zip / mini_installer, optional Authenticode signing).
Project layout
xplorer/
src/ new C++ files copied into the Chromium tree
(agent_gateway/, grok_companion/)
patches/ idempotent, anchor‑based source patches (apply_integration.py)
companion/ Grok‑native UI served by the gateway (toolbar, search, apps)
sdk/ Python client SDK + MCP server for agents
docs/ Agent API reference
site/ landing page (published to GitHub Pages)
build/ release build configuration (args.gn)
branding/ app icon, vector marks
apply.sh / apply.ps1 overlay onto ../chromium/src (macOS / Windows)
build.sh / build.ps1 gn gen + autoninja (macOS / Windows)
RELEASE.md / RELEASE.windows.md build / package / publish runbooks
Contributing
Contributions are welcome. A few things that keep this fork healthy:
- Keep the overlay thin. Prefer adding code under
src/chrome/browser/agent_gateway/
or src/chrome/browser/grok_companion/ over editing Chromium files. Every edit to an
upstream file is something that must be re‑applied each time Chromium is re‑synced.
- Patch via anchors, not diffs. Source edits live in
patches/apply_integration.py,
which inserts/replaces relative to a unique anchor string and is idempotent (safe to
re‑run). If an anchor moves upstream, the patcher fails loudly — update the anchor.
- UI is just files. The companion UI is plain HTML/CSS/JS in
companion/ui/, served
live from disk in dev — no build step, fast iteration.
- Test the real thing. After
apply.sh + build.sh, exercise changes against the
running browser (the SDK in sdk/ is handy for scripted checks).
Open an issue to discuss larger changes first, and keep PRs focused.
Star history
If Xplor is useful to you, please give it a ⭐ on GitHub — it's the simplest way to support the project and helps more people discover it.
License
Xplor is a derivative of Chromium, which is distributed
under a BSD‑3‑Clause license; Chromium's own license and third‑party notices continue to
apply to the browser. Licensing for the Xplor overlay in this repository is set by the
project owner — see the repository for terms.
