OpenWorkers is an open-source serverless platform for running JavaScript/TypeScript workers. Deploy functions that scale automatically (soon™), 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 = "0.8"
openworkers-core = "0.8"
tokio = { version = "1", features = ["full"] }

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

                         ┌─────────────────┐
                         │  nginx (proxy)  │
                         └────────┬────────┘
                                  │
         ┌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┬╌╌╌╌╌╌╌─┴──┬───────────────┐
         ╎               ╎           │               │
         ╎               ╎           │ sse/ws        │ http
┌╌╌╌╌╌╌╌╌┸╌╌╌╌╌╌╌┐   ┌╌╌╌┸╌╌╌┐  ┌────┸────┐    ┌─────┸───────┐
╎   dashboard    ╎   ╎  api  ╎  │ logs *  │    │   runner *  │
└╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┘   └╌╌╌┬╌╌╌┘  └────┰────┘    └─────┰───────┘
                         ╎           │               │
                         ╎           │               │
                ┌╌╌╌╌╌╌╌╌┸╌╌╌╌╌╌╌╌┐  │      ┌────────┸────────┐
                ╎   postgate *    ╎  └──────┥      nats       │
                └╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌╌┘         └────────┰────────┘
                                                     │
                                                     │
                ┌─────────────────┐           ┌──────┴───────┐
         * ─────┥   PostgreSQL    │           │ scheduler *  │
                └─────────────────┘           └──────────────┘

Single database. Components marked with * connect to PostgreSQL.

Note that dashboard and api can now be run directly as workers (postgate is in that case optional too as workerized api has runtime bindings to database).

Services logs and scheduler are not required for the core runtime but provide additional functionality (log streaming and cron jobs).

• JavaScript/TypeScript execution via V8
• 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.75+
• Bun 1.0+
• PostgreSQL 15+
• NATS Server

# 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

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

See individual repository READMEs for detailed setup instructions.

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 License - see LICENSE for details.

Contributions are welcome! Please read our Contributing Guide before submitting a PR.

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