Quicx

Never asks the OSfor another byte.

A deterministic-memory task queue, written in C. You give it a memory budget at startup. It never uses more, tells you precisely what it is using, and gives back what a burst needed once the queue drains.

curl -fsSL https://quicx.dev/install.sh | sh

Linux and macOS, x86-64 and arm64. Installs the quicx binary to /usr/local/bin.

apool8 MiB, mapped once at startup
6 of 68 sizes, illustrated

Press and hold to submit faster than the workers drain. The pool fills to its last slot, refuses the rest, and never grows.

claimed0

returned0

MSG_ERROR 0x010

asked the OS0 B

tasks/s
81,900tasks/send to end, one thread
µs p50
49µs p50submit to done
tasks
46,593tasksof 100 B in 8 MiB (v1.0.4: 655)
KB binary
55KB binaryno dependencies
Idle traffic stays under the measured 2.8 % peak; the flood is yours. Figures are medians of the reference runs of bench/run.sh; nothing estimated.

Every number herecame off a run you can repeat.

Two machines, one -O2 build, every run repeatable with bench/run.sh. Every figure below was measured on these machines.

machine
Apple M4 Pro (12 cores), 24 GB
os
macOS 26.5.1, arm64
build
Apple clang 17, quicxd built -O2
allocator
Default 8 MiB budget, apool v2
transport
Loopback TCP, no network hop
load
8 worker processes, 8 producer connections, C clients

Throughput

81,900tasks/sec

End to end, single thread, median of 5 runs. Closed loop, 8 connections × 32 in flight, 8 workers, 10 s, 0 errors, 0 dropped connections. Five runs landed between 77.8k and 85.4k; v1.0.4 measured 82.4k the same way.

One task, five protocol messages:

  1. submit
  2. ack
  3. dispatch
  4. done
  5. notify

Latency, submit to done

49µs p50

Open loop at 40k/s offered, timed from the scheduled send, so stalls are charged in full rather than hidden.

  • p5049 µs
  • p9064 µs
  • p9998 µs
  • p99.9143 µs
Latency percentiles at 40k tasks per second offered, median of 5 runs: p50 49 µs, p90 64 µs, p99 98 µs, p99.9 143 µs.

Capacity of 8 MiB

46,593tasks of 100 B

v1.0.4 split the pool between sizes in fixed shares and held 655. v2 gives 16 KiB pages to the sizes that arrive, and gives the memory back after a burst.

idle
1,056 KB
queue full
9,088 KB
after the burst
2,080 KB
peak use of the 8 MiB pool, under load
2.8 %

Physical memory (macOS phys_footprint), median of 3 runs. v1.0.4 held 9,200 KB from the moment it started.

Two machines, same scripts

A 2024 Mac and a 2011 Linux PC, each offered a rate it handles comfortably. On the i3, eleven processes share four hardware threads, so its CPU is the ceiling.

machineofferedp50p99p99.9closed loop
Apple M4 Pro40k/s49 µs98 µs143 µs81.9k/s
Intel i3-21009k/s123 µs198 µs208 µs19.0k/s

How it was measured

The method decides what a number means, so it is written out here.

Full benchmark write-up
C clients, not Python
A Python client tops out around 50–100k socket ops/sec and contends on the GIL across threads, so it saturates before the daemon does and ends up measuring itself.
Latency is timed to done
Not to the ack. An ack only means the daemon received the frame; it never touches a worker. For a task queue, the number that matters is when the work is finished.
Open loop for latency, closed loop for throughput
Latency runs put tasks on a fixed schedule and charge stalls against the scheduled send time, the standard correction for coordinated omission. Closed-loop latency is not quoted, because a client that backs off when the server slows cannot measure the server slowing.
Real payloads, parsed by the workers
nginx combined-format access-log lines, 120–260 bytes. Workers parse the IP, method, path hash, status and bytes, and report per-status totals, so a run can be verified rather than trusted.
Two machines, loopback TCP
An Apple M4 Pro on macOS and a 2011 Intel Core i3 on Linux, same scripts, same -O2 build. Clients and daemon share each machine over loopback, so there is no network hop. Real deployments will be slower.
The harness checks itself
256 outstanding requests ÷ 81.9k/s = 3.1 ms, and the measured closed-loop p50 was 3.3 ms (median of 5 runs). Little's Law agrees, so the instrument is measuring queueing and not itself.

Six design decisions.Each with its evidence.

Pick one to see it working.

zsh
user@host ~ $ quicx status
 
quicx v2.1.0 · pid 8278 · up 0h 0m 00s
 
tasks submitted 1,500
completed 0 ░░░░░░░░░░░░░░░░░░░░ 0.0%
in flight 1,500 = 1500 queued + 0 running
 
memory 32 / 508 pages █░░░░░░░░░░░░░░░░░░░ 6.3%
pool 7.95 MiB, 16 KiB pages · 2 sizes in use
 
176B 1,200 / 1,209 ███████████████████░ 99.3%
976B 300 / 304 ███████████████████░ 98.7%
user@host ~ $
01 / 06
Its own socket
The CLI talks to the daemon over a Unix socket, apart from the port that carries tasks.
Human-readable output
Plain aligned text in the terminal. It exits non-zero when the daemon is unreachable, so it is safe to script.
Built into the binary
The status view is part of the quicx binary. There is nothing else to deploy.

quicx status reads the daemon over a separate Unix socket and prints the pages in use, the block sizes holding them, worker states, queue depth and task counts. Producers and workers use the TCP port, so the two never share a connection.

  • Pages in use out of the budget, live
  • Every block size that holds pages: live blocks, capacity, page count
  • Worker pool state: idle, busy, total
  • Tasks submitted, completed, failed, in flight

One daemon.

Producers

  • Producer A
  • Producer B
  • quicx status (CLI)

Quicx daemon

  1. Connection router
  2. Task queue
  3. Dispatcher
  4. Worker pool

apool allocator

Every task above is one block from the fixed budget: O(1) alloc / free, with pages going to the sizes that arrive.

Workers

  • Worker 1
  • Worker 2
  • Worker N

Producers submit tasks over QXP, Quicx’s own compact binary protocol. The daemon routes, queues and dispatches them to a fixed pool of workers. Every task on that path is one block from apool, its page allocator, inside one fixed budget. One daemon, three role-based endpoints, one allocator.

What Quicx does not do.

Some of the speed is work it is skipping.

Quicx is a fast in-memory broker, not a durable one. If you need at-least-once delivery, use beanstalkd or Redis Streams. If you need an exact memory ceiling, keep reading.

  • Persistence

    A restart loses everything queued.

  • Redelivery

    If a worker dies mid-task, the task is lost and the producer is not notified.

    In progress
  • Retries

    No automatic retry, no dead-lettering.

  • Delays, named queues

    One queue with 16 value levels (a FIFO per level, highest first); no delayed tasks and no named queues.

  • Client libraries beyond Java

    dev.quicx:quicx-client is the only one. Every other language talks QXP, the Quicx Protocol, directly. It is documented and small.

  • Payloads above 1 KB

    PROTOCOL_MAX_PAYLOAD is 1,024 bytes by default: a task is one block of a 64 B record plus its payload. A daemon built with make MAX_PAYLOAD=N takes up to 16,320 B, and the capacity formula still holds. Oversized frames get a clean MSG_ERROR.

  • Multiple cores

    One daemon uses one core. Run one daemon per core: on a two-core Linux machine, two pinned daemons did 1.92 times the work of one, and each part of a device can have its own budget.

Against other queues

Only the Quicx row was measured here. Every other figure comes from vendor documentation or third-party benchmarks on unknown hardware, and is included for rough orientation, not as a head-to-head result.

Feature-for-feature comparison
Quicxmeasured here
Throughput81.9k tasks/s (1 thread)Latency49 µs p50 end-to-end
Redis (LPUSH)reported
Throughput~161k commands/sLatency0.30 ms p50, one command
RabbitMQreported
Throughput~40k msg/sLatencyn/a
Kafkareported
Throughput>1M msg/s, batchedLatency~ms
beanstalkdno comparable figure found
Throughputn/aLatencyn/a

The unit trap. A Quicx task is five protocol messages across two connections. A Redis LPUSH is one command, and a real Redis job queue needs LPUSH + BRPOP + an ack. Normalised per completed job, Redis’s ~161k commands/sec is on the order of 50k jobs/sec.

One command away.

Install the daemon, pull the Java client from Maven Central, and submit your first task in Java. There is nothing to sign up for.

curl -fsSL https://quicx.dev/install.sh | sh