FUJIN

The Programmable Browser Platform

Features • Quick Start • Architecture • Docs • Contributing

---

What is FUJIN?

FUJIN is not just another browser. It's a developer platform for building applications that augment, automate, and transform the web experience.

Think of it as:

Chrome DevTools meets VS Code Extensions meets Rust Safety

# Create your first module in seconds
fujin new my-module
cd my-module
fujin dev
# → Your module is running in the browser

✨ Features

🔒 WASM-First Security

Every module runs in a WebAssembly sandbox with:

• Memory isolation — Modules cannot access each other's memory
• Capability-based permissions — Fine-grained, auditable access control
• Crash resistance — A faulty module cannot crash the browser
• Fuel metering — Resource limits prevent runaway code

🦀 Built in Rust

• Memory safety without garbage collection
• Predictable, high performance
• Modern tooling (cargo, clippy, rustfmt)
• Language-level security guarantees

🧩 Everything is a Module

Build anything:

• Password managers
• Ad blockers
• Developer tools
• AI assistants
• Automation scripts
• Page modifiers

🚀 Developer Experience

We obsess over DX:

• Hot reload — See changes instantly
• Clear errors — Human-readable diagnostics
• Instant feedback — fujin dev and you're running
• Great docs — Comprehensive guides and API references

🎯 Quick Start

Prerequisites

• Rust 1.70+
• wasm32-unknown-unknown target

# Install Rust (if needed)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Add WASM target
rustup target add wasm32-unknown-unknown

Install FUJIN

# Clone the repository
git clone https://github.com/fujin-browser/fujin.git
cd fujin

# Build the browser
cargo build --release -p fujin-browser

# Build the CLI
cargo build --release -p fujin-cli

Create Your First Module

# Create a new module
./target/release/fujin new hello-world
cd hello-world

# Build and run with hot reload
../target/release/fujin dev

Example Module

use fujin_sdk::prelude::*;

#[fujin_module]
#[derive(Default)]
pub struct HelloWorld;

impl Module for HelloWorld {
    fn on_load(&self) -> ModuleInfo {
        ModuleInfo::new("hello-world", "0.1.0", "My first module")
    }

    fn on_page_ready(&self) {
        console::info!("Hello from FUJIN!");
        
        // Access the DOM (requires permission)
        if let Some(title) = dom::query_selector("title") {
            console::info!("Page title: {}", title.text_content());
        }
    }
}

🏗️ Architecture

FUJIN follows a micro-kernel architecture where the kernel remains minimal and all extensions happen through sandboxed WASM modules.

┌────────────────────────────────────┐
│        PROGRAMMABLE BROWSER        │
├────────────────────────────────────┤
│   Applications (WASM Modules)      │
│            ↓                       │
│        Module Runtime              │
│            ↓                       │
│            Kernel                  │
│  ┌───────┐ ┌───────┐ ┌─────────┐  │
│  │ Servo │ │  IPC  │ │ Runtime │  │
│  └───────┘ └───────┘ └─────────┘  │
│  ┌───────┐ ┌───────┐ ┌─────────┐  │
│  │Network│ │Window │ │Security │  │
│  └───────┘ └───────┘ └─────────┘  │
└────────────────────────────────────┘

Project Structure

fujin/
├── kernel/              # Trust boundary (minimal, secure)
│   ├── fujin-kernel/    # Core orchestration
│   ├── fujin-servo/     # Rendering engine integration
│   ├── fujin-process/   # Process management
│   ├── fujin-ipc/       # Inter-process communication
│   ├── fujin-network/   # Network stack
│   └── fujin-window/    # Window management
├── runtime/             # Module execution
│   ├── fujin-runtime/   # WASM executor (Wasmtime)
│   ├── fujin-capability/# Permission system
│   └── fujin-lifecycle/ # Module lifecycle
├── security/            # Security enforcement
│   ├── fujin-security/  # Policy enforcement
│   └── fujin-crypto/    # Cryptographic primitives
├── sdk/                 # Developer interface
│   ├── fujin-sdk/       # Module SDK
│   └── fujin-sdk-macros/# Procedural macros
├── cli/                 # Developer tools
│   └── fujin-cli/       # CLI application
├── browser/             # Browser application
│   └── fujin-browser/   # Main entry point
├── examples/            # Example modules
└── docs/                # Documentation (mdBook)

🔐 Security Model

FUJIN implements Zero Trust Security. Every module is assumed potentially malicious.

Capability-Based Permissions

# fujin.toml
[permissions]
dom = { level = "read", scope = ["body", ".content"] }
network = { level = "scoped", scope = ["api.example.com"] }
storage = "local"

[permissions.denied]
filesystem = true
input_capture = true

Permission Categories

Category	Levels	Description
dom	none, read, write	DOM access
network	none, scoped, full	HTTP requests
storage	none, local, sync	Persistent storage
tabs	none, read, manage	Tab information
system	none, limited, full	System APIs

All permission requests are:

• ✅ Human-readable
• ✅ Auditable
• ✅ Revocable at runtime

📖 Documentation

• Getting Started Guide — Installation and first module
• SDK Reference — Complete API documentation
• Architecture Guide — Deep dive into the platform
• Security Model — Understanding permissions

Build the documentation locally:

cargo install mdbook
cd docs/book
mdbook serve

🛠️ CLI Reference

fujin new <name>       # Create a new module project
fujin init             # Initialize module in current directory
fujin build            # Build the module to WASM
fujin dev              # Start dev server with hot reload
fujin validate         # Validate module manifest
fujin package          # Package for distribution
fujin doctor           # Check development environment

🎯 Who is FUJIN For?

FUJIN is built for builders:

• Rust developers exploring browser extensions
• Automation engineers building web scrapers and tools
• AI application developers creating browser-based agents
• Power users wanting programmatic browser control
• Developer tool creators building the next generation of dev tools

We're not (yet) targeting general consumers. We're building the foundation for those who build.

🗺️ Roadmap

Phase	Status	Description
M0 — Foundation	✅	Project structure, dependencies
M1 — Window	✅	Native window management
M2 — Rendering	✅	WebView integration
M3 — Navigation	✅	URL loading, history
M4 — Runtime	✅	WASM execution (Wasmtime)
M5 — Capabilities	🔄	Permission system
M6 — DOM Bridge	✅	Module ↔ DOM communication
M7 — SDK & CLI	✅	Developer tools
M8 — Browser UI	✅	Tabs, toolbar, navigation
M9 — Ecosystem	⏳	Module registry, distribution

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

# Clone the repository
git clone https://github.com/fujin-browser/fujin.git
cd fujin

# Build everything
cargo build

# Run tests
cargo test

# Run the browser
cargo run -p fujin-browser -- --debug

Code Style

• Format with cargo fmt
• Lint with cargo clippy
• All crates use #![forbid(unsafe_code)] where possible
• Documentation is required (#![warn(missing_docs)])

📜 License

FUJIN is dual-licensed under:

• MIT License
• Apache License 2.0

Choose whichever license works best for your project.

🙏 Acknowledgments

FUJIN stands on the shoulders of giants:

• Servo — The original vision for a parallel browser engine
• Wasmtime — Secure, fast WebAssembly runtime
• wry — Cross-platform WebView
• Tokio — Async runtime for Rust

---

We're not building a browser. We're building the programmable runtime of the web.

⭐ Star us on GitHub • 💬 Join Discord • 🐦 Follow on Twitter