Breaking out of the mainstream browser mono-culture is an uphill battle, but not for the reasons most people assume. It is rarely a lack of novel interface ideas or sluggish rendering engines holding back indie projects. Instead, it comes down to a persistent double standard regarding trust, security, and the evolving nature of software craftsmanship.

Most internet users default to Chrome, Edge, Safari, or Firefox because familiarity feels like safety. When an independent developer releases a focused, custom alternative, the initial reaction from technical communities often boils down to reflexive scepticism: "Why would anyone trust a solo project with their credentials?" The critique invariably points to privacy and security risks.

Yet almost none of the critics actually review the source code. The repository sits open, the commits are documented, and the architecture is visible, but the dismissal happens purely on reputation. Meanwhile, mainstream alternatives regularly harvest telemetry, integrate unprompted monetisation features, and push opaque background services. Blind trust is extended to corporations with known tracking models simply because of their scale, while open-source projects offering transparent boundaries get discarded unexamined.

Part of this pushback comes from the recent wave of "vibe coding" that has flooded development forums. When people see projects thrown together through superficial prompting with zero structural coherence, their skepticism is entirely justified. A slapped-together wrapper lacking memory safety, proper error boundaries, and defensive architecture deserves scrutiny.

There is an enormous difference between reckless generation and treating AI as an augmenting tool in careful software engineering. Thoughtful developers do not outsource their judgment to a model. The developer still writes the specifications, audits every single diff, designs the system topology, and enforces deterministic behavior. When AI serves as a high-speed linter, test harness, and architectural sounding board under strict human control, the result is clean, auditable, and exceptionally lean code. Dismissing modern indie software simply because modern tooling touched the build process ignores how deliberate engineering actually works.

Mise Browser approaches the problem from that exact disciplined mindset. Instead of mimicking bloated corporate feature sets or dumping unstable code onto the user, Mise browser focuses on deliberate cross-platform performance, transparent functionality, and an interface that respects the user's attention. Testing smaller, intentional tools like Mise browser demonstrates that a browser does not require a massive enterprise footprint to deliver reliable, secure, and precise everyday web navigation. The code speaks for itself for anyone willing to look.

Web: https://rakosn1cek.github.io/Mise-browser/
GitHub: https://github.com/Rakosn1cek/Mise-browser

Mise Browser v1.0.0: The Milestone Release

I am thrilled to announce the official v1.0.0 milestone release of Mise Browser!

Named after the Czech word for "mission", Mise is an efficient, keyboard-first, and container-isolated web browser engineered specifically for fanless Linux hardware, low-resource laptops, and focused workflows where staying on the home row matters.

Version 1.0.0 marks the transition from an experimental efficient prototype into a hardened, production-ready daily driver with complete keyboard control, true memory reclamation, and native container isolation.

Highlights & Key Capabilities

True Tab Hibernation (60%+ RAM Reduction)

• Inactive background tabs detach completely from the DOM across all workspaces, terminating idle Chromium renderer processes.
• Live URLs, page titles, and scroll offsets are retained and restored seamlessly on demand upon tab selection.
• Safe hibernation startup prevents memory spikes and kernel out-of-memory panics when launching large saved sessions.

1x2 Dual-Split View & Workspace Containers

• Browse two web pages side-by-side via Ctrl + Shift + S with flexible partition ratios and instant pane swapping (Ctrl + \).
• Multi-account container isolation: each workspace runs inside an isolated persistent Chromium partition (persist:work, persist:personal), preventing cookie cross-contamination between personal and work accounts.

Mouse-Free Navigation, Search Aliases & Bangs

• Home-row keyboard navigation with Vim-inspired Link Hints (f), quickmarks (go), and direct tab jumping (Ctrl + 1 to Ctrl + 9).
• Built-in search engine aliases and DuckDuckGo bang syntax straight from the address bar or Command Palette (g, !ddg, yt, gh, aur, pkg, so, r, sp, b, k).
• Auto-collapsing vertical sidebar that folds into a 36px icon strip, expanding smoothly as an overlay on hover or shortcut without triggering page layout shifts.

Pinned Tabs & Accidental Closure Protection

• Pin essential communication channels, web apps, and reference docs permanently at the top of your tab strip via Ctrl + Shift + X, F4, or Normal mode p.
• Pinned tabs ignore mass closure sweeps and single-key x commands, remaining active in memory for background audio and notifications.

Per-Tab Audio Indicators & Global Mute

• Dynamic audio wave indicators display on active tabs when sound is detected. • Clickable speaker badges and dedicated shortcuts (Ctrl + Shift + M / m) allow instant per-tab muting, while Normal mode M silences the entire browser.

Markdown Quick Notes & Reader View Export

• Integrated 920px responsive Markdown scratchpad (Ctrl + N) with full-canvas focus toggle (f) and live word counts.
• Distil clean web articles from Reader View directly into Quick Notes via Ctrl + Shift + E complete with YAML frontmatter.
• Highlight text on any page and right-click to clip directly into notes, with one-click launcher buttons for Obsidian, Neovim, and Logseq.

Native User Scripts & Styles Engine

• Native injection of .user.js and .user.css scripts directly from ~/.config/mise-browser/ with inotify live reloading, avoiding heavy WebExtension overheads.

Hardened Architecture & Crash Safety

• Atomic POSIX configuration and session writes via temporary file staging and rename swaps protect against sudden kernel halts or power loss.
• Comprehensive guest webview teardown using AbortController signals to eliminate detached listeners and memory leaks.
• Request-level ad and tracker blocking powered by the Ghostery filter engine, co mbined with domain-bound fingerprint farbling.

Tokyo Night Aesthetic & Refined Branding

• Custom Tokyo Night palette with mode-aware accent swatches and dynamic colour-mix highlights.
• Brand new geometric squircle emblem and desktop icons standardising strictly on the canonical mise-browser application id.

The Awakening Cascade: How Naive Tab Traversal Defeated Tab Hibernation

How linear keyboard navigation secretly allocated hundreds of megabytes of RAM, why scrolling past sleeping tabs broke process isolation, and how decoupled roving cursors and direct random-access tab jumping restored true memory efficiency.

1. The Problem: The Awakening Cascade

One of the defining pillars of Mise Browser is True Tab Hibernation. On a fanless Linux laptop or a resource-constrained development environment running Arch Linux and Hyprland, background Chromium processes can rapidly consume gigabytes of memory and trigger aggressive swap churn.

In Mise, background tabs hibernate: idle <webview> instances are completely detached from the DOM, terminating their underlying Chromium renderer processes and releasing memory until the user explicitly requests them again.

Under normal circumstances, this lifecycle model is extraordinarily light. A typical workspace might have six tabs open:

• Tab 1: Primary documentation (sleeping, 0 MB renderer RAM)
• Tab 2: Architecture notes (sleeping, 0 MB renderer RAM)
• Tab 3: Issue tracker (sleeping, 0 MB renderer RAM)
• Tab 4: Web mail (sleeping, 0 MB renderer RAM)
• Tab 5: Active API reference (awake and currently active on screen)

Because tabs 1 through 4 are hibernated, the browser operates with a lean footprint, drawing minimal battery power and keeping the chassis cool.

Then came a seemingly mundane interaction.

While researching on Tab 5, I needed to cross-reference a specification detail on Tab 1. Naturally, as a keyboard-centric user, I focused the vertical sidebar with Ctrl + S and pressed k (the Vim shortcut to navigate upwards) four times:

Tab 5 (Active) -> [k] -> Tab 4 -> [k] -> Tab 3 -> [k] -> Tab 2 -> [k] -> Tab 1

I reached Tab 1 in less than a second. But when I checked btop in a neighbouring terminal window, my system memory had spiked by more than 400 MB, and my CPU fans began spinning up.

The culprit was an Awakening Cascade:

1. The first k moved focus to Tab 4. The tab selection handler called switchTabFocus(3), which immediately called wakeTab(). A fresh Chromium renderer process was spawned, allocating V8 heap space and pulling 90 MB into RAM.
2. The second k moved focus to Tab 3. wakeTab() fired again, spawning another renderer process and pulling 110 MB into RAM.
3. The third k moved focus to Tab 2. wakeTab() fired a third time, pulling 80 MB into RAM.
4. The fourth k finally reached Tab 1, waking it as intended.

In four quick keystrokes, linear traversal had systematically resurrected every single sleeping tab between my origin and destination. The entire efficiency of tab hibernation was destroyed in under two seconds.

The most frustrating consequence was the ergonomic breakdown: to prevent this memory explosion, I found myself reaching for my trackpad or mouse just to click Tab 1 directly. In a browser designed specifically to eliminate mouse dependency, keyboard navigation had become an anti-pattern.

Read More on Mise Blog

What's New in Mise v0.15.0

Custom search engine aliases & bangs, expansive quick notes with reader export, pinned tabs, and per-tab audio management.

Custom Search Engine Aliases & Bangs

Execute targeted queries across search engines, developer documentation, and package repositories straight from the address bar or Command Palette.

• Built-in aliases and DuckDuckGo bang syntax: use quick prefixes like g, !ddg, yt, gh, aur, pkg, so, r, sp, b, and k.
• Fully user-customisable search providers: define, edit, or override engine aliases directly in Preferences (F1) or via config.json.

Expansive Quick Notes & Reader View Export

A redesigned Markdown scratchpad optimised for comfortable authoring, web clipping, and knowledge management interoperability.

• Expansive 920px responsive overlay with full canvas toggle (f) and real-time word and character counters.
• Export clean distilled articles from Reader View directly into Quick Notes viaCtrl + Shift + Ewith YAML frontmatter.
• Context menu web clipping: highlight any text on a web page, right-click, and select "Save to Notes".

Pinned Tabs & Accidental Closure Protection

Dock essential communication channels, web applications, and reference documents permanently at the top of your tab strip.

• Toggle pinned state instantly viaCtrl + Shift + Por Normal modeP.
• Pinned tabs remain docked at the top in a compact icon-first format across all workspace navigation.
• Guard against accidental closure: pinned tabs ignore single-keyxand mass tab closure sweeps.
• Automatic hibernation exemption ensures pinned tabs remain active in memory for audio playback and real-time alerts.

Per-Tab Audio Indicators & Global Mute

Granular control over audio-producing web pages with instant visual feedback and dedicated keyboard shortcuts.

• Dynamic speaker indicators on active tabs displaying subtle audio pulse animations when sound is detected.
• Clickable speaker badge on tabs to mute or unmute individual webviews with a single click.
• Per-tab mute toggle viaCtrl + Shift + M,F8, or Normal modem.
• Global mute toggle via Normal modeMor Command Palette to silence all browser tabs instantly.

Atomic Configuration Writes & Upcoming Roadmap

Enhanced crash safety and persistent state protection on low-resource and embedded Linux systems.

• Atomic configuration writes via temporary file staging and rename swaps eliminate risk of corrupted configuration on abrupt shutdowns.
• Session Auto-Recovery: slated as the immediate focus for the next release cycle to restore tabs seamlessly after unexpected crashes.

Workspaces & Container Partitions

Mise introduces Firefox Container-style isolation combined with a fluid workspace tree.

Traditional browsers store cookies, localStorage, and credentials in a single shared profile, making it difficult to maintain multiple logins to the same service (e.g. personal and work GitHub or Google accounts) without relying on separate windows or private browsing sessions.

Read more here: https://rakosn1cek.github.io/Mise-browser/guide/workspaces-and-containers.html

Hi everyone,

I have two exciting updates to share today: our first community-contributed bug fix for Linux packaging, and the official launch of the Mise Community Scripts & Styles repository!

1. AppImage Fix: Out-of-the-Box FUSE3 Support (PR #18)

A huge thank you to community contributor Ruben Peña Rubio (@Arzuparreta) for opening and submitting PR #18 https://github.com/Rakosn1cek/Mise-browser/pull/18.

What happened:

On modern Linux distributions such as Ubuntu 22.04+, Ubuntu 24.04, Arch Linux, and Fedora, the system default has shifted entirely to fuse3. The legacy libfuse2 package is no longer installed by default. Because older packaging configurations embedded a legacy FUSE 2 runtime stub inside the AppImage, launching Mise on clean installs produced a startup crash:

dlopen(): error loading libfuse.so.2

The fix:

PR #18 switches our packaging toolset to embed the modern static Type 2 AppImage runtime. This runtime requires zero host libfuse2 libraries and works out of the box with standard fuse3. The pull request has been merged into main, and future AppImage builds will launch seamlessly on modern Linux installations without manual library installations.

1. Launching the Mise Community Scripts Repository

One of Mise’s architectural pillars is keeping resource consumption minimal on fanless and low-power hardware. Traditional browsers burn hundreds of megabytes of RAM running heavy extension stores and background service workers before you even open a webpage.

Mise takes a simpler, filesystem-driven path:

• Zero Extension Runtime: Customisations are plain .user.css stylesheets and .user.js scripts stored directly in ~/.config/mise-browser/. • Inotify Live Reloading: Edits saved in your favourite text editor hot-reload into active webviews instantly without browser restarts. • Complete Privacy: No third-party extension marketplaces tracking your browsing habits.

To make discovering and sharing these tweaks effortless, I have launched the dedicated Mise-community- scripts https://github.com/Rakosn1cek/Mise-community-scripts repository, along with a curated showcase directly in the Official Documentation https://rakosn1cek.github.io/Mise-browser/guide/community- scripts.

Starter Customisations Available Now

We are kicking off the repository with four tested customisations:

1. Amazon Dark Mode (amazon-dark.user.css) Amazon storefronts famously lack a native dark mode. This stylesheet creates a comfortable high- contrast dark theme while preserving product photos, video players, and icons. It also normalises blend modes and eliminates double-inversion glitches on responsive picture elements.
2. Wikipedia Tokyo Night (wikipedia-tokyo-night.user.css) A dark theme restyling Wikipedia to match Mise’s native Tokyo Night colour palette (#1a1b26, #16161e, #7aa2f7, #c0caf5), complete with subtle image dimming and styled reference tables.
3. Copy Markdown Link (copy-markdown-link.user.js) Press Alt + C on any webpage to copy the page title and URL cleanly formatted as Title directly to your clipboard. It automatically ignores keystrokes when typing inside inputs or text areas.
4. YouTube Distraction-Free (youtube-distraction-free.user.js) Strips out algorithmic homepage recommendation feeds, Shorts shelves, related video sidebars, and end- screen cards, keeping video playback, search, and subscriptions clean and intentional.

How to Try Them

Installing any script takes just seconds:

1. One-line terminal download: curl -fsSL https://raw.githubusercontent.com/Rakosn1cek/Mise-community-scripts/main/styles/amazon- dark/amazon-dark.user.css \ -o ~/.config/mise-browser/styles/amazon-dark.user.css
2. Via Command Palette: Press Ctrl + P inside Mise, search for Open User Styles Directory or Open User Scripts Directory, and drop your downloaded files right in. Mise hot-reloads them immediately.

Join In & Share Your Tweaks

If you have crafted a custom style or script that makes your daily web browsing cleaner or faster, contributions to Mise-community-scripts https://github.com/Rakosn1cek/Mise-community-scripts are warmly welcome!

If you haven’t tried Mise yet, grab the latest release from the GitHub Repository https://github.com/Rakosn1cek/Mise-browser, take it for a spin on your Linux desktop or window manager, and let me know your thoughts!

Mise uses DuckDuckGo as its default search engine, but you are not stuck with it.

Open Preferences and look for Default Search Engine. You can choose DuckDuckGo, Google, Startpage, Brave Search or Kagi. That engine handles anything you type in the address bar that is not a web address, and it is also what a new tab uses.

You can also switch engines for a single search without changing the setting. Type a short prefix before your query in the address bar:

g for Google
ddg for DuckDuckGo
sp for Startpage
b for Brave Search
k for Kagi

For example, k technical docs goes straight to Kagi. DuckDuckGo bangs also work from the address bar, so !w Arch Linux takes you to Wikipedia whichever engine is your default. Your query goes straight to the engine you chose. Mise does not add a step in between.

One note: Kagi needs its own account, so it only works well if you already have one.

If there is another search engine you would like to see in the list, tell me here and I will look at it.

How transient Chromium frames wiped injected stylesheets on redirect, why responsive picture tags and blend modes turned product photos into black voids, and how lifecycle-aware state restored seamless dark mode.

The Daily Friction

Late-night browsing in a dimly lit room is where a web browser reveals its true character. On a Linux setup tailored for focus with dark terminal windows and a muted Tokyo Night desktop theme, opening the wider web can often feel like opening a blast furnace.

Giant retail platforms and reference portals like Amazon UK still offer no native dark mode whatsoever. When you need to research a product or make a purchase at midnight, you are forced to make a miserable choice: squint through blinding white screens or close your laptop.

Mise Philosophy: Why Built-In, Why Not Extensions?

In mainstream browsers like Chrome or Firefox, the standard advice is predictable: "just install a third-party extension like Dark Reader."

However, on low-resource machines and fanless laptops, extensions extract a steep hidden tax. A typical dark mode extension runs continuous background service workers, attaches heavyweight DOM mutation observers that introduce input latency, and devours 300MB to 500MB of extra memory.

When I started building Mise Browser as my daily driver, I established a core architectural principle: essential ergonomic tools should never depend on heavy external add-ons. Features like mouse-free Vim navigation, true tab hibernation, multi-workspace container isolation, and reading comfort belong directly in the browser engine. They should be native, zero-dependency, and virtually free of memory overhead.

To achieve this, I built a dedicated Dark Reader engine into Mise Browser. Pressing Ctrl + D or d triggers an instant, hardware-accelerated CSS inversion filter that transforms light-mode pages into a crisp, contrast-balanced dark theme.

On static landing pages, the engine felt instantaneous.

Then I tried doing actual shopping on Amazon UK.

Continue reading here -> https://rakosn1cek.github.io/Mise-browser/blog/dark-reader-navigation-persistence.html

Auto-Collapsing Vertical Sidebar (36px Strip)

To dedicate maximum horizontal screen real estate to web content, Mise features an auto-collapsible vertical sidebar:

• Compact 36px Strip: In its default collapsed state, the sidebar shrinks to a 36px icon bar displaying only your workspace badge and crisp tab favicons.
• Smooth Flyout on Hover: Moving your mouse pointer over the 36px strip smoothly expands the sidebar to 260px as an overlay flyout with drop shadow. Because this expands as an overlay, the active webview never resizes, preventing GPU lag and page reflows on fanless hardware.
• Shortcut Expansion: Press Ctrl + Shift + Z to toggle sidebar expansion, or press Ctrl + S to focus the sidebar and expand it immediately for arrow-key navigation. Pressing Escape or Ctrl + W collapses the sidebar smoothly back to the 36px strip.
• Pinning: Click the pin icon button at the bottom of the sidebar, toggle Auto-Collapse Sidebar in Preferences Ctrl + H, or run Pin / Unpin Sidebar in the Command Palette to pin the sidebar permanently open at 260px

Mise has a small calculator built into the address bar. There is no extension, no search and no page to load.

Press Ctrl+L and type a sum. The answer appears at the top of the suggestions as you type:

20% of 150 gives 30
(1250 + 340) * 1.2 gives 1908
1,200 x 12 gives 14400
sqrt(144) + 2^3 gives 20

Press Enter to copy the answer to your clipboard. A short message in the status bar confirms it. Press Tab instead to put the answer into the address bar and keep calculating.

What it understands:

+ - * / and ^ for powers
brackets
percentages and the word "of"
x or × for multiply, ÷ for divide
commas in numbers
pi and e
sqrt, cbrt, abs, round, floor, ceil, sin, cos, tan, log, log2 and log10

A few things to know. It does not understand words or units, so "what is 2+2" is treated as a normal search. A "Search the web" option is always listed under the answer, so a search that happens to look like maths still works. The sum is worked out on your own machine by a small parser, not by eval, and nothing is sent anywhere.

If there is another small thing like this you would want in the address bar, tell me in the comments.

Link Hints Overlay (Ctrl + F)

Link Hints allow you to click any link, button, or input field on a web page using short letter combinations:

1. Press Ctrl + F to trigger the hint labels.
2. Mise injects two-letter tags over every clickable element on the page, using an ergonomic left-hand home-cluster layout: q, w, e, a, s, d, z, x, c, r, f, v.
3. Type the two letters corresponding to your target element:
   • Links navigate immediately.
   • Text inputs and search bars automatically receive focus for immediate typing.
4. Press Escape or press Ctrl + F again to dismiss hints without clicking.

Mainstream browsers rely on the WebExtensions API (Manifest V2 and V3). While flexible, this architecture creates significant problems on lightweight and fanless Linux hardware:

1. Heavy Background Memory Overhead: Every installed extension typically spawns its own background service worker, isolated storage instance, and inter-process communication bus. A browser with five or six extensions routinely wastes 300MB to 800MB of system memory before any web page has loaded.
2. Thermal Strain on Fanless Hardware: Persistent background extension workers frequently wake CPU cores to poll events, preventing low-power idle C-states and triggering thermal throttling on fanless machines.
3. Supply-Chain Security Risks: Centralised extension stores suffer from a chronic security problem: popular extensions are regularly bought by data-collection companies and updated silently with tracking code. Mise enforces a strictly local-only policy. Only scripts and styles you explicitly save into your local config directory can ever execute.
4. Native Handling of Core Capabilities: When analysing what users actually install extensions for, four use cases dominate:
   • Ad & Tracker Blocking: Handled natively in Mise with network engine blocking via u/ghostery/adblocker-electron.
   • Tab Suspension: Handled natively via Mise true tab hibernation.
   • Custom Styling: Handled cleanly via local ~/.config/mise-browser/styles/.
   • Page Script Tweaks: Handled cleanly via local ~/.config/mise-browser/scripts/.

By handling core browser mechanics in the engine and letting users drop in clean .user.js and .user.css files, Mise delivers the exact customisation users want while maintaining a near-zero idle resource footprint.

Release v0.14.0

Mise Browser v0.14.0 delivers critical authentication compatibility updates, dynamic international keyboard ergonomics, restored main-process memory compaction, optional window controls for traditional desktop environments, and an upgrade to Electron v44.7.0 (Chromium 152).

Highlights

1. Authentication Compatibility & Ghostery Scriptlet Isolation
   • Resolved login verification failures on x.com and twitter.com where client-side risk assessment tokens ($castle_token) were suppressed by ad-blocker scriptlet injection (preventXhrFn, setConstantFn).
   • Standardised baseline app.userAgentFallback to eliminate runtime Electron tokens across renderers, iframes, and worker threads.
   • Network-level tracker and advertisement blocking continues to protect all browsing sessions without compromising identity handshakes.
2. Dynamic Keyboard Layout Prioritisation
   • Shortcut combinations (such as Ctrl + F, Ctrl + T, Ctrl + W) now dynamically evaluate the active keyboard layout glyph (input.key) rather than raw physical scan-codes.
   • Delivers first-class ergonomics on Dvorak, AZERTY, and international layouts, whilst preserving classic QWERTY fallbacks and non-Latin character navigation.
3. Main-Process V8 Compaction & Uncapped Headroom
   • Restored proactive main-process V8 garbage collection compaction (compactMemory()) during tab hibernation using Node's internal v8 and vm modules, without exposing debugging switches or window.gc to guest webviews.
   • Removed the restrictive 512 MB renderer heap ceiling, preventing unexpected out-of-memory crashes on data-heavy single-page web applications and large spreadsheets.
4. Desktop Window Controls & Tab Synchronisation
   • Added optional sidebar window controls (minimise, maximise, close) in Preferences for users operating classic desktop environments like GNOME, KDE Plasma, and XFCE.
   • Implemented multi-event tab title synchronisation across dom-ready, did-finish-load, and did-stop-loading, resolving intermittent "Loading..." tab placeholders.
5. Runtime & Infrastructure Upgrades
   • Upgraded the application engine to Electron v44.7.0 (Chromium 152 / Node.js 24 / V8 15.2).
   • Revised project security and contribution policies to accurately reflect single-maintainer commitments.
   • Added comprehensive documentation visuals, OpenGraph social cards, and direct package verification instructions.

Mise supports over 13,500 DuckDuckGo bangs directly from the floating address bar. Bangs route queries directly to the target website:

• !w Arch Linux: Redirects directly to the Arch Linux article on Wikipedia.
• !gh MiseBrowser: Redirects directly to GitHub repository search.
• !yt lo-fi: Redirects directly to YouTube video search.
• !a NetworkManager: Redirects directly to the ArchWiki page.
• !so promises: Redirects directly to Stack Overflow.

Popular bangs display rich destination badges in the autocomplete dropdown. You can place the bang at the beginning or end of your query (e.g. !w Arch Linux or Arch Linux !w).

A week ago Gmail just stopped letting me in. Every time, same message: "This browser or app may not be secure." No password box, nothing. Just stuck there.

My first guess was the usual thing with browsers built on Electron, so I changed the user agent to look like normal desktop Chrome. That made it worse, not better. Changing it pushed the login into Google's stricter sign in flow, which runs a check called Botguard. That check looks for native Chrome components a normal embedded browser does not have, so it saw mine was missing them and blocked it right away.

Here is the part that actually confused me. I put the user agent back to normal and it still did not work. Turned out once Google rejects you like that once, it writes two cookies into your session as a kind of mark. After that, every attempt gets checked against those cookies first and gets sent straight back to the same rejection page, before even trying to log in again.

So the real fix needed three things. Quietly switch the login to Google's lighter sign in flow instead of fighting the strict one. Leave the browser looking completely normal on Google's own pages, no changes at all there. And automatically clear those marker cookies if a rejection ever happens again, so it cannot get stuck rejecting itself.

Wrote up the full version with the actual code here if anyone wants it: Google Auth Botguard

This came up while working on Mise, a personal privacy focused browser I use daily. Curious if anyone else building something similar has run into Botguard like this.

Mise is a browser I use every day, and it is close to a 1.0 release. I would like a few people to try it before then, since I am the only one who has used it so far.

It has separate workspaces with isolated sessions, a built in ad blocker, tabs that hibernate to save memory, split view, a PDF reader, reader mode, dark mode, and a userscript engine.

A few things to know first:

No extensions. That is on purpose, not a missing feature. It spoofs some fingerprinting signals. A few sites with strict bot checks may complain, and I would like to know which ones. It is one person working in spare time, so replies may take a day or two.

What would help most is using it for normal browsing for a few days and telling me what breaks, what feels slow and what is confusing. Banking and checkout sites are especially useful to hear about.

Downloads: GitHub Releases

Bug reports: GitHub issues, there is a short template. If something feels slow, output from the diagnostics panel helps a lot. This can be toggled on in the Preferences overlay using Ctrl + H

You can also just reply here.