Performance Benchmarks

Enable io_uring on Linux

io_uring reduces syscalls by 10-20x by using a shared ring buffer between the kernel and userspace. Requires Linux kernel 5.1+. On macOS/Windows it is a no-op.

# In Cargo.toml
[dependencies]
unique = { version = "1", features = ["io_uring"] }

Enable SIMD JSON on x86_64

SIMD JSON uses AVX2 CPU vector instructions to parse JSON 2-4x faster. Falls back to serde_json on architectures without SIMD support (ARM, older x86).

# In Cargo.toml
[dependencies]
unique = { version = "1", features = ["simd"] }

Build with --release and LTO

Always build production binaries with --release. Unique.js ships with [profile.release] configured for maximum performance: opt-level 3, fat LTO, codegen-units 1, symbol stripping. Do not override these.

cargo build --release --features "unique-core/io_uring unique-core/simd"

Increase file descriptor limits

Linux defaults to 1024 open file descriptors per process. For high-concurrency servers, increase this to 1M. Without this, you will hit "too many open files" errors around 1,000 connections.

# Add to /etc/security/limits.conf or run before starting the server:
ulimit -n 1048576

Use buffer pooling (automatic)

Unique.js pools response buffers by default — no configuration needed. Each response object is reused instead of allocated. This reduces memory allocator pressure by 90%+ under load. Do not disable it.

Set acceptor_threads to CPU core count

Unique.js uses SO_REUSEPORT to share a port across multiple acceptor threads. The kernel load-balances incoming connections. Set the thread count to your CPU core count for optimal throughput.

# In your app config:
Unique::new()
    .acceptor_threads(num_cpus::get())
    .run("0.0.0.0:3000").await?;

Enable TCP_NODELAY (automatic)

TCP_NODELAY disables Nagle algorithm, reducing latency on small responses. Unique.js enables this by default on every connection. Do not disable it unless you have a specific reason.

Use a reverse proxy for TLS

Let nginx or Caddy handle TLS termination and proxy to Unique.js over plain HTTP on localhost. This frees Unique.js to focus on application logic instead of crypto. The latency overhead of the proxy is negligible (<0.1ms).

# nginx config
server {
    listen 443 ssl http2;
    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

Cache JSON responses

Unique.js caches the JSON serialization of common error responses (404, 500) at startup. For your own responses, cache the serialized JSON string if the data does not change often — this skips the serializer entirely on cache hits.

use unique_core::response::cached_json;

let cached = cached_json(serde_json::to_string(&config)?);

app.handle_get("/api/config", move |_req, res| {
    let cached = cached.clone();
    Box::pin(async move { res.json_cached(&cached) })
});