Krabka is Kafka without the JVM.
Built for extreme efficiency.

Name: Krabka
Author: krabka-io

Krabka is an open-source, byte-exact Apache Kafka wire-protocol broker, native KRaft consensus quorum, and polyglot streaming engine in Rust. A fraction of the memory, instant starts, and zero garbage collection pauses.

Get Started GitHub

Safe Rust (zero unsafe)

Single static binary

1. Start single-node broker in 1 second

$ curl -fsSL https://krabka.io/quickstart/docker-compose.yml -o docker-compose.yml && docker compose up -d

2. Produce records with existing Kafka CLI

$ kafka-console-producer.sh --bootstrap-server localhost:9092 --topic events

KRaft Quorum Active (0.0.0.0:9092)

Working set: 114.2 MiB

114 MiB 10x Savings

Baseline Memory

vs 2.5–5.5 GiB in JVM Strimzi Kafka

1.2s

Cold Start to Ready

No JVM warmup, no heap tuning

Zero

GC Latency Spikes

Predictable sub-millisecond p99 latencies

100%

Byte-Level Parity

Speaks Apache Kafka 4.3 wire protocol

Engineered for Extreme Efficiency

Direct benchmark measurements on a 3-broker Kubernetes cluster comparing Krabka vs Strimzi (Apache Kafka 4.3 / OpenJDK 21).

Broker Working Set Memory

97% Savings

Lower is better • Measured under 50k msg/sec sustained workload

Krabka (Native Rust) 114 MiB

Strimzi Kafka (JVM OpenJDK 21) 4,280 MiB (4.2 GiB)

No JVM garbage collector pauses or multi-gigabyte heap buffers. Ideal for edge nodes, CI pipelines, and dense multi-tenant Kubernetes clusters.

Cold Start to First Ack

7x Faster

Lower is better • Pod launch to first accepted produce request

Krabka (Single Binary) 1.2 s

Strimzi Kafka (JVM Warmup) 8.6 s

Instant cluster bootstrap and fast leader failover. Pod restarts during Kubernetes rolling updates finish in seconds without cluster stalls.

Read the full benchmark report and reproduction steps

Native Polyglot Developer Experience

First-class client libraries and stream processing engines for Rust, Go, Java, and Kubernetes.

krabka-client-rs

use krabka_client::producer::{FutureProducer, ProducerRecord};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let producer = FutureProducer::builder()
        .bootstrap_servers("localhost:9092")
        .build()?;

    // Zero-allocation async produce
    let delivery = producer.send(
        ProducerRecord::to("telemetry")
            .key("sensor-042")
            .payload(b"{\"temp\": 23.4, \"status\": \"nominal\"}"),
    ).await?;

    println!("Acked at partition {} offset {}", delivery.partition, delivery.offset);
    Ok(())
}

package main

import (
	"context"
	"github.com/krabka-io/krabka-streams-go/streams"
	"github.com/apache/arrow/go/v17/arrow"
)

func main() {
	builder := streams.NewTopologyBuilder()
	
	// Stream processing with Zero-Copy Apache Arrow record batches
	builder.Stream("events").
		Filter(func(record arrow.Record) bool {
			return record.NumRows() > 0
		}).
		To("aggregated-events")

	app := streams.NewApplication(builder.Build(), streams.Config{
		BootstrapServers: []string{"localhost:9092"},
	})
	app.Run(context.Background())
}

import io.krabka.streams.KrabkaStreams;
import io.krabka.streams.StreamsBuilder;
import io.krabka.streams.kstream.KStream;

public class FraudDetectionApp {
    public static void main(String[] args) {
        StreamsBuilder builder = new StreamsBuilder();
        KStream<String, Transaction> transactions = builder.stream("transactions");

        transactions
            .filter((key, tx) -> tx.getAmount() > 10000.0)
            .to("flagged-transactions");

        KrabkaStreams streams = new KrabkaStreams(builder.build(), "localhost:9092");
        streams.start();
    }
}

apiVersion: krabka.io/v1alpha1
kind: KrabkaCluster
metadata:
  name: production-cluster
  namespace: streaming
spec:
  replicas: 3
  version: "1.0.0"
  storage:
    tiered:
      enabled: true
      bucket: "s3://krabka-cold-storage"
      region: "us-west-2"
  resources:
    limits:
      cpu: "4"
      memory: "2Gi"
    requests:
      cpu: "500m"
      memory: "512Mi"