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.

        clients (HTTP, HTTPS)
                 |
     +-----------+-----------+
     |        runner         |
     |                       |
     |  every worker, api    |
     |  included; crons;     |
     |  console logs         |
     +-----------+-----------+
                 |
     +-----------+-----------+
     |      PostgreSQL       |
     +-----------------------+

One runner per platform database. The database holds the workers, the cron schedules and the console logs.

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.