OpenWorkers is an open-source serverless platform for running JavaScript, TypeScript and Rust (WebAssembly) workers, with built-in bindings for databases, key-value storage, and object storage.

Don't need the full platform? Use openworkers-runtime-v8 as a standalone JavaScript runtime in your Rust application:

use openworkers_core::{Event, HttpRequest, Script};
use openworkers_runtime_v8::Worker;

#[tokio::main]
async fn main() {
    let code = r#"
        addEventListener('fetch', (event) => {
            event.respondWith(new Response('Hello from V8!'));
        });
    "#;

    let script = Script::new(code);
    let mut worker = Worker::new(script, None).await.unwrap();

    let (event, rx) = Event::fetch(HttpRequest::get("http://localhost/"));
    worker.exec(event).await.unwrap();

    let response = rx.await.unwrap();
    println!("Status: {}", response.status);
}

Add to your Cargo.toml:

[dependencies]
openworkers-runtime-v8 = { git = "https://github.com/openworkers/openworkers-runtime-v8", tag = "v0.15.0" }
openworkers-core = { git = "https://github.com/openworkers/openworkers-core", tag = "v0.15.0" }
tokio = { version = "1", features = ["full"] }

See openworkers-runtime-v8 for full documentation. See openworkers-task-executor for a complete implementation example.

One runner serves HTTP and HTTPS, runs every worker (the dashboard and API included), starts the crons and stores the console logs. It needs one PostgreSQL database, and one runner runs per database.

The dashboard and the API are one worker, openworkers-api, on the platform itself (dogfooding); postgate is then optional, since the workerized api reaches the database through its runtime binding.

• JavaScript/TypeScript execution via V8
• Rust workers as native WebAssembly components (wasm32-wasip2), with a workers-rs-compatible SDK
• Web-standard APIs: fetch(), Request, Response, Headers, crypto, TextEncoder/Decoder
• Streaming support: ReadableStream, WritableStream
• Console logging with structured output

Workers can access platform resources through bindings:

export default {
  async fetch(request, env) {
    // Key-Value Storage (native JSON support)
    await env.KV.put("session", { userId: 123 }, { expiresIn: 3600 });
    const session = await env.KV.get("session");

    // Database (PostgreSQL)
    const users = await env.DB.query("SELECT * FROM users WHERE id = $1", [
      session.userId,
    ]);

    // Static Assets (S3/R2)
    const asset = await env.ASSETS.fetch("/images/logo.png");

    return new Response("Hello World");
  },
};

• Multi-tenant isolation via PostgreSQL schemas
• SQL validation blocks dangerous operations (system tables, schema escapes)
• BYOD support: Bring Your Own Database with direct connection strings

export default {
  async scheduled(event, env) {
    // Runs on schedule
    console.log(`Cron triggered at ${event.scheduledTime}`);
  },
};

• V8 Isolates: Each worker runs in an isolated V8 context
• No credential exposure: Workers only see binding names, never secrets
• SQL validation: Queries are parsed and validated before execution
• Schema isolation: Multi-tenant databases use SET search_path for isolation
• Path sanitization: Object storage paths are sanitized to prevent traversal attacks

• Rust 1.85+
• Bun 1.0+
• PostgreSQL 15+

# Clone repositories
git clone https://github.com/openworkers/openworkers-runner.git
git clone https://github.com/openworkers/openworkers-api.git

# Start the runner
cd openworkers-runner && cargo run --features v8

# Start the API dev loop (in another terminal)
cd openworkers-api && bun install && bun run dev

For a full self-hosted platform, follow openworkers-infra's GETTING_STARTED.

1. Database is the single source of truth: All components read from/write to PostgreSQL. No local state.

2. API is userland: The API is designed to run as a worker on the platform itself (dogfooding).

3. CLI is the infra tool: All infrastructure operations (migrations, setup) go through the CLI.

4. Security by design: Credentials never reach the JavaScript sandbox.

5. Cloudflare Workers compatible: API compatibility with Cloudflare Workers where possible.

MIT, across the organization.

Contributions are welcome - open an issue or a pull request on the relevant repository.

Built with Rust, TypeScript, Claude Code, and a lot of love.