Obscura im Test: Der von Rust gebaute Headless-Browser für KI-Agenten – 30 MB Speicher und Chrome wird alt aussehen

TL;DR: Obscura ist eine Open-Source-Headless-Browser-Engine, die komplett in Rust von Grund auf neu entwickelt wurde und speziell für KI-Agenten und Webcrawler konzipiert ist. Mit nur 30 MB Speicher (Chrome verbraucht schnell 2 GB+), 85 ms Startzeit und einer Installationsgröße von lediglich 70 MB. Vollständig kompatibel mit dem Chrome DevTools Protocol (CDP) und kann Headless Chrome zusammen mit Puppeteer/Playwright direkt ersetzen. Auf GitHub bereits mit über 22.000 Stars ausgezeichnet und hat sogar den ersten Prototyp von Cloudflare Kitesurf inspiriert. Dieser Artikel bietet eine vollständige technische Analyse, Installationsanleitung, Praxisintegration mit KI-Agenten und Performance-Benchmarks.

1. Die drei größten Probleme von Headless Chrome

Wenn du KI-Agenten für Web-Scraping, automatisierte Tests oder Datenerfassung einsetzt, verwendest du wahrscheinlich Headless Chrome. Aber es gibt einige zunehmend schwerwiegende Probleme:

1. Das Speicherloch

Chromes Multi-Prozess-Architektur bedeutet, dass jeder Tab ein eigener Prozess ist. 10 gleichzeitige Scraping-Aufgaben? Schnell sind 2–4 GB Speicher verbraucht. Auf Cloud-Servern bedeutet das höhere Instance-Kosten.

2. Schneckenlangsame Starts

Ein Cold Start von Headless Chrome dauert normalerweise 2–5 Sekunden. Für KI-Agenten-Workflows, die häufig starten und stoppen müssen (z. B. bei jedem Tool-Aufruf einen neuen Browser), ist diese Latenz fatal.

3. Der Albtraum beim Deployment

Das Chrome-Binary ist über 300 MB groß und benötigt dazu noch jede Menge Systemabhängigkeiten (libX11, libnss3, libatk-bridge2.0 …). Ein Docker-Image mit Chrome sprengt schnell die 1-GB-Marke.

Das sind keine Randprobleme – es sind die Kernengpässe bei der großflächigen Bereitstellung von KI-Agenten.

2. Was ist Obscura: Eine in Rust neu geschriebene Browser-Engine

Obscura wurde im April 2026 von h4ckf0r0day veröffentlicht und implementiert eine Headless-Browser-Engine komplett von Grund auf in Rust. Es ist kein Wrapper für Chrome, sondern ein echter Ersatz:

• Integrierte V8-Engine: Führt JavaScript direkt aus, ohne Abhängigkeit von externen Browsern
• Native Rendering-Engine: Unterstützt CSS-Layout, Screenshots und PDF-Export ohne Chromium
• Vollständige CDP-Kompatibilität: Puppeteer und Playwright können sich direkt verbinden
• Integrierter Anti-Detect: Fingerabdruck-Randomisierung, Tracker-Blockierung, navigator.webdriver = undefined

Die wichtigsten Daten im Überblick

GitHub Stars: über 22.000+, Forks: 1.600+. Es hat sogar Cloudflares Kitesurf-Projekt inspiriert – Cloudflare hat bei der Entwicklung seines eigenen Agent-Browsers zunächst Obscura auf Workers portiert.

3. Technische Architektur: Die Geheimnisse der Rust-Implementierung

Obscuras Architektur basiert auf drei Kernprinzipien: Keine Abhängigkeiten, Speichersicherheit, maximale Performance.

3.1 Integrierte V8-Engine

Obscura kompiliert und bettet die V8-JavaScript-Engine direkt ein (dieselbe JS-Engine wie in Chrome). Das bedeutet:

• Vollständige ES2024+-Unterstützung
• WebAssembly-Kompatibilität
• Native Ausführungsgeschwindigkeit ohne Interpreter-Overhead

// Vereinfachtes Architektur-Diagramm (tatsächlicher Code im obscura-core-Crate)
pub struct ObscuraEngine {
    v8_runtime: v8::Runtime,
    dom: Html5everDom,
    renderer: NativeRenderer,
    cdp_server: CdpHandler,
}

3.2 Native Rendering-Engine

Im Gegensatz zu Puppeteer/Playwright, die auf Chromes Blink-Rendering-Engine angewiesen sind, hat Obscura seine eigene Rendering-Pipeline implementiert:

• Layout-Engine: Unterstützt Flexbox, Grid, Table, Float, Positioning
• Paint-Engine: CSS-Hintergründe, Rahmen, Verläufe, SVG, Canvas
• Screenshots/PDF: Native Unterstützung für Viewport-Screenshots, Full-Page-Screenshots und PDF-Export

Die aktuelle Implementierung deckt die gängigen CSS-Funktionen ab, aber Nischenfeatures (wie Medienwiedergabe oder Compositor-Effekte) können von Chromium abweichen.

3.3 Vollständige CDP-Protokoll-Implementierung

Obscura implementiert die Kern-Domains des Chrome DevTools Protocol und ist damit ein echter Ersatz für Puppeteer/Playwright:

Das bedeutet, dass dein bestehender Puppeteer/Playwright-Code praktisch ohne Änderungen auf Obscura umgestellt werden kann.

4. Installation und Schnellstart

4.1 Vorkompilierte Binaries herunterladen (empfohlen)

# Linux x86_64
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-x86_64-linux.tar.gz
tar xzf obscura-x86_64-linux.tar.gz
./obscura --version

# macOS Apple Silicon
curl -LO https://github.com/h4ckf0r0day/obscura/releases/latest/download/obscura-aarch64-macos.tar.gz
tar xzf obscura-aarch64-macos.tar.gz

# Arch Linux
yay -S obscura-browser

# NixOS
nix-env -iA nixpkgs.obscura

Keine Abhängigkeiten: Kein Chrome, kein Node.js, keine Systembibliotheken erforderlich. Einfach herunterladen und loslegen.

4.2 Docker-Deployment

docker run -d --name obscura -p 127.0.0.1:9222:9222 h4ckf0r0day/obscura

Das Image basiert auf distroless/cc, ohne Shell, ohne Paketmanager, komprimiert nur ~57 MB.

4.3 Aus dem Quellcode kompilieren

git clone https://github.com/h4ckf0r0day/obscura.git
cd obscura

# Mit Rendering-Engine
cargo build --release -p obscura-cli --bins --features render

# Mit Rendering + Anti-Detect
cargo build --release -p obscura-cli --bins --features render,stealth

Erfordert Rust 1.75+. Der erste Build dauert etwa 5 Minuten (V8 wird aus dem Quellcode kompiliert, danach wird zwischengespeichert).

4.4 Der erste Befehl

# Seitentitel abrufen
./obscura fetch https://example.com --eval "document.title"

# Alle Links extrahieren
./obscura fetch https://example.com --dump links

# JavaScript rendern und HTML ausgeben
./obscura fetch https://news.ycombinator.com --dump html

# Screenshot
./obscura fetch https://example.com -s page.png

5. KI-Agenten-Integration in der Praxis

Die größte Stärke von Obscura zeigt sich bei der Integration in KI-Agenten-Frameworks. Hier sind drei gängige Integrationsmethoden.

5.1 Verwendung mit Puppeteer

# CDP-Server starten
./obscura serve --port 9222

// agent-browser.js
import puppeteer from 'puppeteer-core';

const browser = await puppeteer.connect({
  browserWSEndpoint: 'ws://127.0.0.1:9222/devtools/browser',
});

const page = await browser.newPage();
await page.goto('https://news.ycombinator.com');

// KI-Agenten können diese Funktion aufrufen, um Seiteninhalte abzurufen
async function extractPageContent(url) {
  await page.goto(url, { waitUntil: 'networkidle2' });

  return {
    title: await page.title(),
    text: await page.evaluate(() => document.body.innerText),
    links: await page.evaluate(() => 
      Array.from(document.querySelectorAll('a'))
        .map(a => ({ text: a.innerText, href: a.href }))
        .slice(0, 50)
    ),
  };
}

// Beispiel: Hacker News Schlagzeilen abrufen
const stories = await page.evaluate(() =>
  Array.from(document.querySelectorAll('.titleline > a'))
    .map(a => ({ title: a.textContent, url: a.href }))
);
console.log(stories.slice(0, 5));

await browser.disconnect();

5.2 Verwendung mit Playwright

import { chromium } from 'playwright-core';

const browser = await chromium.connectOverCDP({
  endpointURL: 'ws://127.0.0.1:9222',
});

const context = await browser.newContext();
const page = await context.newPage();

await page.goto('https://en.wikipedia.org/wiki/Web_scraping');
console.log(await page.title());

// Formularübermittlung und Login
await page.goto('https://quotes.toscrape.com/login');
await page.evaluate(() => {
  document.querySelector('#username').value = 'admin';
  document.querySelector('#password').value = 'admin';
  document.querySelector('form').submit();
});
// Obscura verarbeitet POST, folgt 302-Weiterleitungen und verwaltet Cookies

await browser.close();

5.3 MCP-Server-Integration

Obscura hat einen integrierten MCP-Server (Model Context Protocol), der direkt von KI-Modellen wie Claude und GPT aufgerufen werden kann:

# MCP-Server starten
./obscura mcp --port 8080

Dann registrierst du diesen MCP-Server in deiner KI-Agenten-Konfiguration. Das KI-Modell kann die Browser-Funktionen direkt aufrufen:

• fetch(url) – Seiteninhalt abrufen
• screenshot(url) – Screenshot erstellen
• evaluate(js) – JavaScript ausführen
• click(selector) – Element anklicken
• fill(selector, value) – Formular ausfüllen

6. Web-Scraping in der Praxis

6.1 Paralleles Scraping

# Mehrere URLs parallel abrufen
./obscura scrape \
  https://example.com \
  https://news.ycombinator.com \
  https://github.com/trending \
  --concurrency 25 \
  --eval "document.querySelector('h1')?.textContent || document.title" \
  --format json

6.2 Anti-Detect-Modus

# CDP-Server mit Anti-Detect starten
./obscura serve --port 9222 --stealth

Anti-Detect-Funktionen umfassen:

• Fingerabdruck-Randomisierung: GPU, Bildschirm, Canvas, Audio, Akku – bei jeder Sitzung unterschiedlich
• Echte User-Agents: navigator.userAgentData zeigt Chrome 145
• Vertrauenswürdige Events: event.isTrusted = true
• Versteckte interne Eigenschaften: Object.keys(window) ist sicher
• Native-Funktions-Tarnung: Function.prototype.toString() gibt [native code] zurück
• webdriver-Tarnung: navigator.webdriver = undefined (wie bei echtem Chrome)
• Tracker-Blockierung: Integrierte Blacklist mit 3.520 Domains, blockiert Analyse-, Werbe- und Telemetrie-Skripte

6.3 Proxy-Unterstützung

# Über SOCKS5-Proxy scrapen
./obscura --proxy socks5://127.0.0.1:1080 fetch https://example.com --dump text

# Über HTTP-Proxy
./obscura --proxy http://127.0.0.1:8080 scrape https://example.com https://news.ycombinator.com

6.4 Warten auf dynamische Inhalte

# Auf Netzwerk-Inaktivität warten (ideal für SPAs)
./obscura fetch https://spa-example.com --wait-until networkidle0

# Auf einen bestimmten Selector warten
./obscura fetch https://example.com --wait-for ".content-loaded"

# Timeout festlegen
./obscura fetch https://slow-site.com --timeout 10

7. Performance-Benchmarks

Wir haben Obscura und Headless Chrome auf demselben Server (Ubuntu 22.04, 4 Kerne, 8 GB) miteinander verglichen.

7.1 Seitenladegeschwindigkeit

7.2 Speicherverbrauch

Der Speicherverbrauch von Obscura wächst fast linear, während Chromes Multi-Prozess-Architektur zu einem exponentiellen Anstieg des Speicherverbrauchs führt.

7.3 Startzeit

7.4 Deployment-Größe

8. Einschränkungen und Hinweise

Obscura ist kein Allheilmittel – folgende Szenarien erfordern eine sorgfältige Abwägung:

8.1 Rendering-Kompatibilität

Obscura deckt zwar die gängigen CSS-Funktionen ab, aber folgende Szenarien können von Chrome abweichen:

• Nischen-CSS-Funktionen: Einige experimentelle oder selten verwendete CSS-Eigenschaften sind möglicherweise nicht implementiert
• Medienwiedergabe: Video-/Audio-Wiedergabe wird nicht unterstützt (bei Headless-Browsern normalerweise auch nicht nötig)
• WebGL/WebGPU: 3D-Grafik-Rendering kann unvollständig sein
• Schrift-Rendering: Plattformspezifische Schrift-Rasterung kann von Chrome abweichen

Empfehlung: Wenn deine Zielwebsite viele moderne CSS-Funktionen oder komplexe Animationen verwendet, teste zuerst die Screenshot-Ergebnisse mit Obscura.

8.2 JavaScript-Kompatibilität

Obscura verwendet die V8-Engine, die JavaScript-Ausführung ist mit Chrome identisch. Aber:

• Browser-APIs: Einige browserspezifische APIs (wie Service Worker, WebRTC) sind möglicherweise nicht vollständig implementiert
• Erweiterungen: Chrome-Erweiterungen werden nicht unterstützt

8.3 Grenzen des Anti-Detect

Obsuras Anti-Detect-Funktionen sind sehr stark, aber:

• Fortschrittliche Fingerabdruck-Erkennung: Manche Websites verwenden ungewöhnliche Fingerabdruck-Techniken (z. B. Mausbewegungsanalyse), die zusätzliche Maßnahmen erfordern
• IP-Reputation: Anti-Detect löst nur das Problem des Browser-Fingerabdrucks – für die IP-Reputation benötigst du einen Proxy-Pool

8.4 Empfehlungen für den Produktionseinsatz

• Speicher überwachen: Obwohl Obsura wenig Speicher verbraucht, sollte bei langem Betrieb dennoch überwacht werden
• Timeout-Konfiguration: Für umfangreiche SPAs die Umgebungsvariable OBSCURA_SCRIPT_DEADLINE_MS anpassen
• Protokollierung: Im Produktionseinsatz wird strukturiertes Logging zur Fehlerbehebung empfohlen

9. Obscura vs. andere Lösungen

Empfehlungen:

• KI-Agenten / großflächiges Scraping → Obscura (klare Vorteile bei Performance, Speicher und Anti-Detect)
• Vollständige Browser-Funktionen erforderlich → Headless Chrome (Medien, Erweiterungen, experimentelle APIs)
• Automatisierte Tests → Playwright (bessere Cross-Browser-Unterstützung)
• Schnelle Prototypen → Puppeteer (einfache API, große Community-Ressourcen)

10. Fazit

Obscura stellt einen wichtigen Durchbruch im Bereich der Headless-Browser dar. Es beweist, dass es machbar ist, mit Rust von Grund auf eine hochperformante, ressourcenschonende Browser-Engine zu entwickeln, die vollständig mit dem bestehenden CDP-Ökosystem kompatibel ist.

Kernvorteile:

• ✅ 30 MB Speicher: 1/10 von Chrome – großflächige Parallelverarbeitung ist kein Albtraum mehr
• ✅ 85 ms Start: Ideal für KI-Agenten-Tool-Aufrufe
• ✅ 70 MB Deployment: Docker-Image von 1,2 GB auf 57 MB reduziert
• ✅ Keine Abhängigkeiten: Kein Chrome, kein Node.js, keine Systembibliotheken
• ✅ Vollständiges CDP: Puppeteer/Playwright-Code praktisch ohne Änderungen
• ✅ Integriertes Anti-Detect: Fingerabdruck-Randomisierung + Tracker-Blockierung

Geeignete Szenarien:

• KI-Agenten-Web-Scraping und Datenerfassung
• Großflächiges paralleles Crawling
• Automatisierte Workflows mit häufigem Browser-Start/Stopp
• Ressourcenbeschränkte Cloud-Umgebungen (Edge Computing, Container-Deployment)
• Scraping-Szenarien mit Anti-Detect-Anforderungen

Nicht geeignete Szenarien:

• Vollständige Browser-Funktionen erforderlich (Medienwiedergabe, WebGL, Erweiterungen)
• Cross-Browser-Kompatibilitätstests (dafür Playwright verwenden)
• Neueste experimentelle Web-APIs erforderlich

Obscura hat bereits über 22.000 Stars erhalten und das Cloudflare-Kitesurf-Projekt inspiriert. Es entwickelt sich von einem „experimentellen Ersatz" zu einer „produktionsreifen Erstwahl".

Wenn dein KI-Agent noch Headless Chrome verwendet, wird es Zeit, Obscura auszuprobieren.

Häufig gestellte Fragen (FAQ)

1. Kann Obscura Headless Chrome wirklich vollständig ersetzen?

Für 90 % der KI-Agenten- und Crawler-Szenarien: Ja. Obscura implementiert das vollständige CDP-Protokoll mit JavaScript-Ausführung, DOM-Manipulation, Netzwerk-Abfangen und anderen Kernfunktionen. Wenn dein Szenario jedoch auf Medienwiedergabe, WebGL oder Chrome-Erweiterungen angewiesen ist, benötigst du weiterhin Headless Chrome.

2. Wie gut sind Obsuras Anti-Detect-Funktionen? Wird es von Websites erkannt?

Obscura bietet eine vollständige Anti-Detect-Lösung: Fingerabdruck-Randomisierung, echte User-Agents, navigator.webdriver = undefined, Native-Funktions-Tarnung und mehr. In Kombination mit einem Proxy-Pool kann die meisten Browser-Fingerabdruck-Erkennungen umgangen werden. Für IP-Reputation und Verhaltensanalyse sind jedoch zusätzliche Lösungen erforderlich.

3. Muss mein Puppeteer/Playwright-Code geändert werden?

Praktisch nicht. Obscura implementiert das vollständige CDP-Protokoll. Du musst nur den Verbindungsendpunkt von Chrome auf Obsuras CDP-Server (ws://127.0.0.1:9222) umstellen – der Rest des Codes bleibt unverändert.

4. Verbraucht Obscura wirklich nur 30 MB Speicher?

Ja, das ist der Basisverbrauch für eine einzelne Seite. Im Stresstest mit 100 gleichzeitigen Seiten verbraucht Obscura etwa 620 MB, während Chrome über 16 GB benötigt. Obsuras Speicherverbrauch wächst fast linear, während Chromes Multi-Prozess-Architektur zu einem exponentiellen Anstieg führt.

5. Ist Obscura für den Produktionseinsatz geeignet?

Es gibt bereits viele produktive Anwendungen. Obscura verwendet die Apache-2.0-Lizenz, hat über 22.000 GitHub-Stars und das Cloudflare-Kitesurf-Projekt basiert ebenfalls darauf. Für den Produktionseinsatz wird empfohlen, den Speicherverbrauch zu überwachen, angemessene Timeout-Werte zu konfigurieren und strukturiertes Logging zu aktivieren.

Referenzlinks:

• GitHub-Repository: https://github.com/h4ckf0r0day/obscura
• Offizielle Dokumentation: https://docs.obscura.sh
• Cloudflare Kitesurf: https://blog.cloudflare.com/kitesurf/
• CDP-Protokolldokumentation: https://chromedevtools.github.io/devtools-protocol/