Event streaming, reimagined

Two million events
per second.
Zero tuning.

Kafka-compatible streaming with single-digit millisecond latency. No JVM. No ZooKeeper. No 3AM pages. Just the fastest event backbone your agents and services have ever used.

2,147,483msg/s

Peak throughput / core

3.2ms

p99 end-to-end latency

10x

Less memory than Kafka

JVM dependencies

torrent-bench — throughput test

$ torrent bench --producers 8 --msg-size 1KB --duration 30s

───────────────────────────────────────────

broker torrent://10.0.1.5:9092

topic bench-throughput-001

partitions 12

acks all (exactly-once)

───────────────────────────────────────────

[ 5s] 2,041,338 msg/s │ p99 3.1ms │ 0 errors

[ 10s] 2,147,483 msg/s │ p99 3.2ms │ 0 errors

[ 15s] 2,138,912 msg/s │ p99 3.0ms │ 0 errors

[ 20s] 2,153,107 msg/s │ p99 3.1ms │ 0 errors

[ 25s] 2,142,671 msg/s │ p99 3.2ms │ 0 errors

[ 30s] 2,144,920 msg/s │ p99 3.1ms │ 0 errors

PASS 30s elapsed — 64,366,431 messages delivered, 0 lost

Benchmarks

Head-to-head with Kafka

Same test, same hardware, same topic configuration. 3-node cluster, 12 partitions, 1KB messages, acks=all. Independently reproducible.

Metric	Torrent	Apache Kafka 3.7	Delta
Throughput (msg/s/core)	2,147,483	205,312	10.5x faster
p99 latency (acks=all)	3.2 ms	14.8 ms	4.6x lower
p999 latency	4.1 ms	87.2 ms	21x lower
Memory / broker (idle)	48 MB	512 MB	10.7x less
Cold start	1.2s	38s	31x faster
Exactly-once overhead	+2%	+18%	9x less
Kafka API compatibility	100%	100%	parity

Integrate in minutes

Your existing Kafka code
just works

Full Kafka API compatibility. Switch your bootstrap servers, keep everything else. Native SDKs for Go and Rust when you want zero-copy performance.

        producer.go
        
      
package main

import (
    "github.com/torrent-dev/torrent-go"
)

func main() {
    p, _ := torrent.NewProducer(&torrent.Config{
        Brokers:  []string{"torrent://10.0.1.5:9092"},
        Acks:     torrent.AcksAll,
        Linger:   5 * time.Millisecond,
    })
    defer p.Close()

    p.Send("events.user.click", "user-42", payload)
    // p99 delivery: 3.2ms
}

        consumer.rs
        
      
use torrent::{Consumer, Config, Offset};

fn main() -> Result<()> {
    let consumer = Consumer::new(Config {
        brokers: vec!["torrent://10.0.1.5:9092"],
        group:   "analytics-pipeline",
        offset:  Offset::Latest,
    })?;

    consumer.subscribe("events.user.*")?;

    for msg in consumer.stream() {
        process(msg.value());
        msg.commit()?; // exactly-once
    }
}

Architecture

Everything Kafka promised,
nothing it made you manage

Built from scratch in Rust. One binary, no external dependencies. Automatic partition balancing, built-in schema registry, tiered storage to object stores.

Topics & Partitions

Ordered, durable log per partition. Automatic rebalancing when brokers join or leave. No manual reassignment scripts.

Consumer Groups

Cooperative rebalancing with zero stop-the-world pauses. Consumers keep processing during group membership changes.

Exactly-Once Semantics

Idempotent producers and transactional consumers. 2% overhead vs Kafka's 18%. No duplicate processing, ever.

Schema Registry

Built-in, not bolted-on. Protobuf, Avro, JSON Schema. Schema evolution with compatibility checking at produce time.

Tiered Storage

Hot data on NVMe, cold data on S3/GCS/R2. Transparent to consumers. Infinite retention without infinite disk.

Raft Consensus

No ZooKeeper. No KRaft migration. Native Raft built into every broker. Leader election in under 200ms.

Observability

The boring dashboard

Your ops dashboard should be boring. Flat throughput, low latency, green partitions. That's what infrastructure that works looks like.

torrent-cluster-prod-us-east

2026-04-02 11:23:41 UTC

Throughput

2.14M msg/s

+0.2% from avg

p99 Latency

3.1ms

-0.1ms from avg

Consumer Lag

142msgs

nominal

Disk Usage

34%

1.2 TB / 3.6 TB

In-sync Catching up Offline

Configuration

12 lines. That's the whole config.

Kafka has 197 broker configs. Torrent has 12 that matter. Sane defaults, override only what you need.

        torrent.yaml
      
cluster:
  name: prod-us-east
  node_id: 1

storage:
  data_dir: /var/torrent/data
  tiered:
    backend: s3
    bucket: torrent-cold-prod
    after: 7d

network:
  port: 9092
  tls: auto    # ACME cert provisioning

01 No JVM tuning. No heap sizing, no GC pauses, no -Xmx flags. Rust manages memory at compile time.
02 No ZooKeeper. Native Raft consensus built into every broker. One binary to deploy.
03 No partition reassignment. Automatic rebalancing on node join/leave. No kafka-reassign-partitions.sh.
04 Auto TLS. ACME certificate provisioning. No manual keystore management.
05 Tiered storage by default. Hot data on local NVMe, cold data offloaded to S3 automatically after the configured window.

Two million eventsper second.Zero tuning.

Head-to-head with Kafka

Your existing Kafka codejust works

Everything Kafka promised,nothing it made you manage

The boring dashboard

12 lines. That's the whole config.

Start streaming inunder 60 seconds

Two million events
per second.
Zero tuning.

Your existing Kafka code
just works

Everything Kafka promised,
nothing it made you manage

Start streaming in
under 60 seconds