theoden8/webspace_app: Self-Hosted Mobile Webspaces with Ad Blocking

Mobile browsers force every website into the same cookie jar, the same tracking profile, the same cluttered experience. For developers who rely on web apps—self-hosted dashboards, SaaS tools, documentation sites—this means either accepting cross-site tracking or juggling multiple browser profiles and incognito windows. The friction is real: session isolation is manual, ad blocking is inconsistent across platforms, and organizing work versus personal tools becomes a chore.

theoden8/webspace_app addresses this directly. It's an open-source Flutter application that wraps websites into discrete, isolated "webspaces" on your phone, each with independent cookies, language settings, and script injection. With 173 stars and active development through July 2026, it represents a pragmatic alternative to mainstream browsers for users who prioritize compartmentalization and control. This article examines what theoden8/webspace_app actually delivers, how to build it from source, and where it fits in the mobile browser landscape.

What is theoden8/webspace_app?

theoden8/webspace_app—branded as WebSpace—is a mobile application developed by Kirill Rodriguez and released under the MIT License. Built primarily in Dart with Flutter, it targets iOS and Android as production platforms, with macOS and Linux supported for development. The project has accumulated 173 GitHub stars and 7 forks, indicating modest but genuine community interest.

At its core, WebSpace is not a traditional browser. It is a web app container that presents websites through embedded WebKit views (WPE WebKit on Linux, platform-native engines elsewhere via flutter_inappwebview), organized into user-defined spaces. Think of it as a workspace manager for the mobile web: each "webspace" groups related sites, and each site operates with configurable isolation boundaries.

The project's relevance stems from its integration of privacy features typically scattered across browser extensions and separate tools: content blocking via Brave's adblock-rust engine, DNS-level blocking through Hagezi lists, tracking parameter stripping via ClearURLs rules, and local CDN caching. These are not bolted-on afterthoughts but compiled into the application, with the Rust-based adblock engine building automatically during the Flutter compilation process.

For developers, the codebase offers a concrete example of integrating Rust with Flutter via FFI, managing per-platform build pipelines (Gradle, CMake, Xcode), and handling runtime-fetched filter list licensing. The project is actively maintained, with its last commit dated July 16, 2026.

Key Features

Per-Site Isolation Architecture

WebSpace's defining characteristic is cookie isolation at the site level, backed by secure storage. Unlike standard browsers where all sites share a cookie store (or where container tabs require manual management), WebSpace enforces separation by design. Each site within a webspace maintains its own session state, preventing cross-site tracking through shared credentials or identifiers.

Multi-Layer Content Blocking

The application implements three complementary blocking mechanisms:

• Ad & tracker filtering via adblock-rust (MPL-2.0), the same engine Brave browser uses, with EasyList-style filter lists fetched at runtime
• DNS-level domain blocking through Hagezi blocklists (GPL-3.0), available in five severity levels
• Tracking parameter removal using ClearURLs rules (LGPL-3.0), stripping UTM and similar tracking query parameters from URLs

LocalCDN (Android)

CDN resources are cached locally to prevent third-party tracking through content delivery networks. This is particularly relevant for developers using CDN-hosted libraries or fonts, where the CDN operator gains visibility into visitor patterns.

Proxy Support with Authentication

Available on Android, iOS 17+, macOS 14+, and Linux. This enables routing traffic through corporate proxies, Tor, or self-hosted VPN endpoints without system-wide configuration.

Per-Site User Scripts

Custom JavaScript^{↗ Bright Coding Blog} injection per site allows modifying page behavior, adding functionality, or working around mobile-unfriendly interfaces. This mirrors desktop extensions like Tampermonkey but operates within the app's controlled environment.

Additional Technical Features

• 30+ per-site language preferences
• Import/export settings for backup and migration
• Home screen shortcuts for direct site access
• Light/dark mode with configurable accent colors
• Runtime-fetched blocklists with proper license attribution in-app

Use Cases

Development and Staging Environment Management

Developers maintaining multiple environments (production, staging, local) for the same application can create dedicated webspaces per environment. Each maintains independent authentication state, preventing accidental operations against production while testing. The per-site script injection enables adding debug helpers or mock data layers without modifying deployed code.

Self-Hosted Service Dashboards

Users of self-hosted tools—Home Assistant, Pi-hole, Grafana, [INTERNAL_LINK: self-hosted-monitoring-tools]—often access these through the same browser used for general web activity. WebSpace isolates these services into dedicated spaces with distinct cookies and optional proxy routing, reducing attack surface if a general browsing session is compromised.

Privacy-Compartmentalized Personal Browsing

Separating work tools, personal services, shopping, and social media^{↗ Bright Coding Blog} into distinct webspaces prevents the cross-site tracking that fuels modern ad profiles. The combination of cookie isolation, DNS blocking, and parameter stripping addresses multiple tracking vectors simultaneously without requiring multiple browser applications.

Research and Competitive Analysis

Analysts needing to view sites as different personas (varying geolocation via proxy, language settings, cookie profiles) can configure these as separate sites or webspaces rather than managing multiple browser profiles or virtual machines.

Content Blocking on Platforms Without Extension Support

Mobile Safari and Chrome lack the extension ecosystem of desktop browsers. WebSpace brings uBlock Origin-equivalent blocking (via the same underlying Rust engine and filter lists) to mobile without requiring platform-level changes or jailbreak.

Installation & Setup

WebSpace is available through official app stores (F-Droid, Apple App Store, Google Play) or buildable from source. For developers modifying the application or contributing, source builds require specific tooling.

Prerequisites

• FVM (Flutter Version Manager) — manages the specific Flutter version the project requires
• Xcode — for iOS and macOS builds
• Android SDK — for Android builds
• cargo on PATH — for building the Rust adblock engine
• ANDROID_NDK_HOME or NDK installed under the SDK — for Android Rust compilation

Source Build Steps

# Clone the repository
git clone https://github.com/theoden8/webspace_app
cd webspace_app

# Install the project's specified Flutter version
fvm install

# Fetch Dart dependencies
fvm flutter pub get

The fvm install step is critical—WebSpace pins a specific Flutter version, and building with a different version may produce inconsistencies. FVM handles this transparently.

Platform-Specific Rust Build Integration

The adblock-rust crate (rust/webspace_adblock) builds automatically during normal Flutter compilation:

To skip Rust compilation (resulting in no content blocking at runtime), use -PskipRustAdblock=true for Android builds. Without cargo available, the build prints a skipping notice and succeeds, but ad blocking no-ops.

Standalone Rust Rebuild

For iterating on the Rust code without full Flutter rebuilds:

# Rebuild for specific platform
./scripts/build_rust.sh linux

# Available targets: android <abi>, android-all, ios, macos

Note: Windows builds ship without the Rust library; there is no Dart fallback implementation.

Real Code Examples

The README provides two primary code blocks: the setup sequence and the standalone Rust build script invocation.

Example 1: Initial Project Setup

# Clone from the official repository
git clone https://github.com/theoden8/webspace_app
cd webspace_app

# Install pinned Flutter version via FVM
fvm install

# Resolve all Dart/Flutter package dependencies
fvm flutter pub get

This sequence establishes the development environment. The fvm install command reads the project's .fvm/fvm_config.json to install the correct Flutter SDK version—essential for reproducible builds given Flutter's rapid release cycle. The pub get step downloads dependencies including the forked flutter_inappwebview, encryption libraries, and mapping components. Developers should verify FVM is globally installed and accessible before starting.

Example 2: Standalone Rust Engine Build

# Build the adblock-rust library for Linux
./scripts/build_rust.sh linux

# Alternative targets for other platforms
# ./scripts/build_rust.sh android armeabi-v7a
# ./scripts/build_rust.sh android-all
# ./scripts/build_rust.sh ios
# ./scripts/build_rust.sh macos

This script is used when modifying rust/webspace_adblock/ source code and wanting rapid iteration without the overhead of full Flutter builds. The script handles platform-specific compilation flags, output paths, and library naming conventions. For Android, specifying the ABI (armeabi-v7a, arm64-v8a, x86, x86_64) or using android-all builds all architectures. The resulting libraries are placed where the Flutter build system expects them, enabling hot-restart testing of blocking rule changes.

The README does not contain additional code examples beyond these two blocks. This reflects the project's current documentation state rather than a limitation in functionality.

Advanced Usage & Best Practices

Managing Runtime Filter Lists

WebSpace fetches filter lists and blocklists at runtime rather than bundling them. This reduces APK/IPA size and ensures current rules, but means first-run blocking effectiveness depends on network availability. For offline-first use, consider pre-loading the application while connected to allow initial list downloads.

Proxy Configuration for Development

When testing against local development servers, the proxy support can route through a local intercepting proxy (Burp Suite, mitmproxy) for traffic inspection. Configure the proxy in WebSpace settings, install the proxy's CA certificate at the system level, and inspect encrypted traffic per webspace without affecting device-wide browsing.

Script Injection for API Testing

Per-site user scripts can inject custom headers or modify fetch behavior, enabling testing of API endpoints that require specific authentication schemes. This is not a replacement for proper API clients but provides quick mobile verification.

Backup Strategy

The import/export functionality covers settings; pair this with regular exports before significant changes. Note that exported data may contain sensitive cookies—encrypt backups appropriately.

Build Pipeline Integration

For CI/CD, ensure cargo and the Android NDK are cached between builds. The Rust compilation step adds significant time to clean builds; incremental builds benefit from Rust's own caching once the initial compilation completes.

Comparison with Alternatives

Firefox Focus offers single-session privacy but lacks persistent organization or multi-site isolation. Brave Mobile provides excellent blocking in a full browser but doesn't compartmentalize sites into isolated spaces. Safari with extensions achieves some parity but requires iOS 15+, depends on extension availability, and lacks proxy authentication support.

WebSpace trades general browsing flexibility for structured isolation. It's not a replacement for daily driver browsers but a specialized tool for specific workflows.

FAQ

Does WebSpace require root or jailbreak? No. It operates within standard app sandbox constraints on all supported platforms.

Can I use my own filter lists? The README documents EasyList-style lists fetched at runtime; custom list URLs are not explicitly mentioned.

Why does the Android build need the NDK? The NDK builds the Rust adblock engine into native libraries for each target ABI.

Is the iOS version affected by WebKit mandate? Yes—like all iOS browsers, it uses Apple's WebKit framework via flutter_inappwebview.

What happens if cargo is not installed? The Flutter build succeeds but content blocking no-ops at runtime; there is no Dart fallback.

Can I contribute to the Rust engine? The wrapper rust/webspace_adblock is in-repo; upstream adblock-rust is maintained by Brave.

Are the fetched blocklists licensed to me? They are user-fetched data; the app includes attribution but you are not receiving a licensed software derivative.

Conclusion

theoden8/webspace_app occupies a specific niche: developers and privacy-conscious users who need structured isolation of web applications on mobile, not just ad blocking in a traditional browser. Its technical implementation—Flutter with Rust FFI, runtime filter lists, per-platform build integration—demonstrates solid engineering practices and provides a reference for similar projects.

With 173 stars and consistent maintenance, it's a viable tool for its intended use cases, not a mass-market browser replacement. The MIT license and open source build pipeline make it auditable and modifiable for organizations with specific compliance requirements.

If your workflow involves multiple self-hosted services, strict compartmentalization needs, or testing across isolated sessions, explore the repository and evaluate whether its webspace model fits your requirements. The source is available, the build is documented, and the F-Droid and store releases provide immediate access for evaluation.