High-performance background job processing and task scheduling powered by a persistent LSM-tree database. Works in any stack.

Zizq (/zɪsk/) is a fast and durable job queue packed into a single native binary, built on an embedded LSM database — not on Redis, and not on your application’s RDBMS.

$ zizq serve
Zizq 0.7.1
Listening on 127.0.0.1:8901 (admin)
Listening on 127.0.0.1:7890 (primary)

• Get Started
• Website
• Docs
• Source

Zizq is a language agnostic job queue, usable from any environment with an HTTP client. Jobs can be enqueued in one language can be processed by a worker written in another.

Need to enqueue in Node and process in Rust? Zizq does that.

// Node.js enqueues a job
await client.enqueue({
  type: "send_email",
  queue: "emails",
  payload: { userId: 42, template: "welcome" },
});

// Rust runs a worker to process that job
#[derive(Serialize, Deserialize, JobKind)]
#[zizq(name = "send_email", queue = "emails")]
struct SendEmail { user_id: u64, template: String }

let worker = Worker::builder()
    .client(client)
    .concurrency(25)
    .queues(vec!["emails"])
    .handler(Router::new().route(async |job: SendEmail| {
        handle_send_email(job)?
    }))
    .build()?;

Official client libraries for Node.js, Ruby, Elixir and Rust handle connection management and concurrent job dispatch, so your application stays focused on the important stuff. All official clients are MIT licensed.

• Node.js Client
• Ruby Client
• Elixir Client
• Rust Client

Full documentation is available on the website.

• Getting Started
• HTTP API Reference
• Zizq Command Line

Stay in control with a built-in terminal UI providing live queue depth and worker activity at a glance.

$ zizq top

• Persistent by default — jobs survive crashes, disconnects and restarts, on a transactional LSM-tree database
• Prioritised queues — granular priorities blended with simple FIFO, mixed across unlimited named queues
• Backoff and retry — configurable exponential backoff, global or per-job retry limits, and a dead-letter queue
• Recurring schedules — time zone aware cron-style schedules with second-level granularity
• Unique jobs — duplicates prevented at enqueue time, scoped by lifecycle rather than arbitrary TTLs
• Batched jobs — many small units folded together into one at enqueue time
• Concurrency limits — configurable server-side controls on how many jobs of a given type can be in-flight at once
• Rate limiting — throttled job dispatch without blocking your workers
• HTTP/2 and HTTP/1.1 — with JSON or MessagePack
• Job management APIs — introspect and operate on the queue, including jq expression filters

The Zizq server is source-available under BUSL-1.1. Most features are freely available. Some advanced features require a Pro license. Every official client library is open source and MIT licensed.

If you need help using Zizq, create an issue on the Zizq repo. Feedback is very welcome.