Install bunqueue, zero infrastructure.

One command installs everything: the library, the server, and the CLI. No Redis, no broker, nothing else to provision.

Requirements

Bun v1.3.9 or later

Install

bun add bunqueue

That is it. The package is 5.5 MB with 7 packages total, and includes the client library, the standalone server, and the CLI.

npm install bunqueue-client    # Node.js 20+
deno add npm:bunqueue-client   # Deno 2+

pip install bunqueue-client

composer require bunqueue/client

go get github.com/egeominotti/bunqueue/sdk/go

cargo add bunqueue-client

# Hex release upcoming; use sdk/elixir as a path dependency today
{:bunqueue_client, path: "../bunqueue/sdk/elixir"}

The Bun bunqueue package bundles the client, the server, and the CLI. Every other SDK is a client only: it connects to a bunqueue server, started once with bunx bunqueue start (see SDKs and Server Mode).

Verify it works

Save this as test.ts and run bun run test.ts:

import { Queue, Worker } from 'bunqueue/client';

// Both Queue and Worker must have embedded: true
const queue = new Queue('test', { embedded: true });
const worker = new Worker('test', async (job) => {
  console.log('Processing:', job.data);
  return { success: true };
}, { embedded: true });

await queue.add('hello', { message: 'bunqueue is working!' });

Start a server (bunx bunqueue start), save this as test.ts, then run node --experimental-strip-types test.ts (Node 22+) or deno run -A test.ts:

import { Queue, Worker } from 'bunqueue-client';

const queue = new Queue('test'); // connects to localhost:6789
const worker = new Worker('test', async (job) => {
  console.log('Processing:', job.data);
  return { success: true };
});

await queue.add('hello', { message: 'bunqueue is working!' });

Start a server (bunx bunqueue start), then run python test.py:

from bunqueue import Queue, Worker

queue = Queue("test")  # connects to localhost:6789
queue.add("hello", {"message": "bunqueue is working!"})

def process(job):
    print("Processing:", job.data)
    return {"success": True}

Worker("test", process).run()

Start a server (bunx bunqueue start), then run php test.php:

use Bunqueue\Queue;
use Bunqueue\Worker;

$queue = new Queue('test'); // connects to localhost:6789
$queue->add('hello', ['message' => 'bunqueue is working!']);

$worker = new Worker('test', function (Bunqueue\Job $job) {
    var_dump($job->data());
    return ['success' => true];
});
$worker->run();

Start a server (bunx bunqueue start), then go run .:

queue := bunqueue.NewQueue("test", bunqueue.Options{}) // localhost:6789
defer queue.Close()
queue.Add("hello", map[string]any{"message": "bunqueue is working!"}, nil)

worker := bunqueue.NewWorker("test", func(job *bunqueue.Job) (any, error) {
    fmt.Println("Processing:", job.Data())
    return map[string]any{"success": true}, nil
}, bunqueue.WorkerOptions{})
worker.Run()

Start a server (bunx bunqueue start), then cargo run:

use bunqueue_client::{ConnectionOptions, JobOptions, Queue, Value, Worker, WorkerOptions};

let queue = Queue::new("test", ConnectionOptions::default()); // localhost:6789
let data = Value::Map(vec![(Value::from("message"), Value::from("bunqueue is working!"))]);
queue.add("hello", data, JobOptions::default())?;

let worker = Worker::new("test", |job| {
    println!("Processing: {:?}", job.data());
    Ok(Value::from(true))
}, WorkerOptions::default());
worker.run()?;

Start a server (bunx bunqueue start), then mix run test.exs:

queue = Bunqueue.queue("test")  # connects to localhost:6789
{:ok, _job} = Bunqueue.Queue.add(queue, "hello", %{message: "bunqueue is working!"})

worker =
  Bunqueue.Worker.new("test", fn job ->
    IO.inspect(job.data, label: "Processing")
    {:ok, %{success: true}}
  end)

Bunqueue.Worker.run(worker)

You should see Processing: { message: "bunqueue is working!" }. Next: the Quick Start builds on this.

To check the server and CLI:

bunqueue --version
bunqueue start

Single binary (no Bun required)

Each release ships self-contained executables, useful on servers and edge devices (Raspberry Pi, ARM64 boxes) where you don’t want to install a runtime:

# Platforms: linux-x64 | linux-arm64 | darwin-x64 | darwin-arm64 (windows-x64 ships as a .zip)
curl -fsSLO https://github.com/egeominotti/bunqueue/releases/latest/download/bunqueue-linux-arm64.tar.gz
tar -xzf bunqueue-linux-arm64.tar.gz
sudo mv bunqueue-linux-arm64 /usr/local/bin/bunqueue

bunqueue start --data-path /var/lib/bunqueue/queue.db

A SHA256SUMS file is attached to every release for checksum verification.

The binary is the full server + CLI. For the client SDK in your app code you still install the package (bun add bunqueue).

Install from source

git clone https://github.com/egeominotti/bunqueue.git
cd bunqueue
bun install
bun run build

TypeScript support

bunqueue is written in TypeScript and ships full type definitions:

import type {
  Job,
  JobOptions,
  WorkerOptions,
  StallConfig,
  DlqConfig,
  DlqEntry
} from 'bunqueue/client';