◉ COOLJAPAN
← All posts
July 13, 2026 • 6 min read

CeleRS 0.3.0 Released — Real Crypto, Real Chords, 100% Pure Rust

CeleRS 0.3.0 eliminates sqlx and reqwest workspace-wide for oxisql/oxihttp-client, swaps mock XOR encryption for real AES-256-GCM/ChaCha20-Poly1305, and fixes chord/chain execution and Kombu middleware that were silent no-ops. 18 crates, 5,676 tests passing. The sovereign task-queue layer for COOLJAPAN.

release celers celery task-queue distributed-systems pure-rust security workflow enterprise

In CeleRS 0.2.0, a chord nested inside a chain was silently dropped, the worker pool ran a simulated sleep-only loop instead of your actual tasks, and “envelope encryption” was a mock XOR cipher with no integrity check at all.

Today we released CeleRS 0.3.0 — a release that spent as much energy replacing what was fake with what is real as it did adding anything new. Every broker crate cut over from sqlx to the pure-Rust oxisql-postgres/oxisql-mysql, every HTTP call site cut over from reqwest to oxihttp-client, and a full audit of “looks implemented” code turned up — and fixed — six separate places where the system was quietly doing less than it claimed.

No C. No sqlx’s C-adjacent TLS chain. No mock crypto pretending to be a cipher.
Zero sqlx or reqwest dependency declarations remain anywhere in the workspace.
Just a task queue that does, honestly, what its API says it does — and compiles to a single static binary that runs everywhere, from laptops to Kubernetes clusters.

Why CeleRS 0.3.0 is a game changer

The 0.2.0 release was feature-complete on paper. In practice, a source-level audit found real gaps between the API surface and what actually ran:

CeleRS 0.3.0 ends all of that.

Concrete wins from this release:

Technical Deep Dive: What Changed Under the Hood

  1. Core & Protocol Layer (celers-core, celers-protocol, celers-kombu) Message creation timestamps (MessageHeaders.created_at) for age tracking, real bidirectional protocol v2↔v5 migration with version stamping, a native v5 wire-format builder, and a YAML serializer alongside a pluggable CustomSerializerRegistry.

  2. Broker Layer & the Pure-Rust Migration (celers-broker-postgres, celers-broker-sql, celers-broker-redis, celers-broker-amqp, celers-cli) sqlx → oxisql-postgres/oxisql-mysql, reqwest → oxihttp-client. The port itself surfaced real bugs — a hardcoded TlsMode::Disabled that silently downgraded sslmode=require connections to plain-text was caught and fixed before it shipped, via a shared tls_mode.rs helper across all five migrated crates.

  3. Workflow & Scheduling (celers-canvas, celers-beat, celers-worker) DAG visualization (DagVisualize::to_mermaid()/to_dot()), workflow loops and sub-workflow composition, versioned workflow serialization with a MigrationRegistry, holiday-calendar business-day arithmetic, schedule-conflict detection, and the Unix→Quartz day_of_week fix for crontab scheduling.

  4. Enterprise Security & Observability (celers-core, celers-metrics) HMAC-SHA256 task signature verification, configurable argument sanitization, PII detection/masking (email/phone/Luhn-checked card/SSN), native Prometheus histograms with a self-implemented P² streaming quantile estimator, a pure-UdpSocket StatsD backend, SLA/SLO burn-rate alerting, and EWMA-based anomaly detection.

Getting Started

[dependencies]
celers-core = "0.3"
celers-protocol = "0.3"
celers-broker-redis = "0.3"
celers-worker = "0.3"
celers-macros = "0.3"
tokio = { version = "1", features = ["full"] }

Define a task with the procedural macro, then start a worker against it:

use celers_macros::task;
use celers_core::Result;

#[task]
async fn add(x: i32, y: i32) -> Result<i32> {
    Ok(x + y)
}
// Generates `AddTask` (implements `Task`) and `AddTaskInput { x: i32, y: i32 }`.

use celers_broker_redis::RedisBroker;
use celers_core::TaskRegistry;
use celers_worker::{Worker, WorkerConfig};

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let broker = RedisBroker::new("redis://localhost:6379", "celers")?;

    let registry = TaskRegistry::new();
    registry.register(AddTask).await;

    let config = WorkerConfig {
        concurrency: 4,
        max_retries: 3,
        default_timeout_secs: 300,
        ..Default::default()
    };

    let worker = Worker::new(broker, registry, config);
    worker.run().await?;
    Ok(())
}

No Redis handy? Swap in InMemoryBroker + InMemoryResultBackend from celers-core and the same code runs with zero external services.

What’s New in 0.3.0

Tips

This is the foundation

CeleRS is the distributed task queue backend for the COOLJAPAN stack:

Repository: https://github.com/cool-japan/celers

Star the repo if you want a task queue that doesn’t just claim to work end-to-end — it’s now audited to.

The era of task queues that quietly mock the hard parts is over.

Pure Rust, honestly implemented, fully sovereign — CeleRS 0.3.0 is here.

— KitaSan at COOLJAPAN OÜ July 13, 2026

↑ Back to all posts