Native low-latency transport
Zero-copy framed protocol over TCP/QUIC for .NET clients. Designed for in-process and edge deployments where Kafka's TCP handshake overhead is too costly.
Your Streams.
At Scale. In Control.
The .NET-native message streaming platform. No more JVM.
Drop-in Kafka replacement. Run it embedded, standalone, or clustered.
AI pipelines, schemas, and a plugin marketplace — built in, not bolted on.
NuGet
Downloads
License
Apache 2.0
Wire
Surgewave + Kafka 4.x
Built on
.NET 10
Runs as
Single binary
Performance
By the numbers
-
P99 produce latency < 1 ms
99 % of producer write requests finish acked under one millisecond on Surgewave's native protocol, single-broker, NVMe-backed.
Producer-latency distribution on a single Surgewave broker, native protocol, 100-byte records, batched produce, NVMe storage. How it's measured
End-to-end produce path: client serializes record → native protocol frame over TCP → broker append to log → ack returned. Percentiles taken over a one-million-message run from the regression suite.
-
5–10× lower P99 than Apache Kafka
On identical hardware, Surgewave's native protocol delivers P99 produce latency 5–10× lower than Apache Kafka's Kafka-wire baseline. Same physical box, no special tuning.
P99 produce latency, identical hardware (8-core x64, NVMe), 100-byte records, batched produce. Why?
No JVM GC pauses, no Scala-wrapped network thread pool. Surgewave's native protocol is binary and zero-copy; Kafka's protocol re-serializes per message. On the Kafka wire alone Surgewave is on par with Apache Kafka; the multiplier comes from switching to the native protocol.
-
> 1 million messages per second per broker
A single Surgewave broker on commodity NVMe sustains over one million messages per second in batched-produce mode. Three-broker cluster: linear scale.
Per-broker throughput scales linearly with the cluster size, partition-balanced producer. Setup
Commodity 8-core x64 box with consumer-grade NVMe SSD, 16 GB RAM. Confluent.Kafka producer with linger.ms=5, batch.size=64 KB. Records 100 bytes, key-balanced across 12 partitions.
-
Petabyte-scale tiered cold storage
Hot data stays on NVMe; once segments are sealed they tier to S3-compatible object storage. Consumers transparently fetch cold segments — no special client API.
Three-tier log: NVMe for active produce/consume, RocksDB for warm range scans, S3 for archive. Tiering policy
Configurable per topic: max-segment-age, max-segment-size, target-tier. Default policy seals NVMe segments after 1 day, copies to RocksDB at 1 GB, ships to S3 after 7 days. Consumer reads stay transparent — cold segments are fetched on demand.
-
Zero JVM. Pure .NET 10.
No JVM. No GC tuning. No heap sizing. Surgewave is a single .NET 10 executable, optionally Native-AOT compiled to a ~40 MB binary that starts in under a second.
Time from process start to broker accepting connections, single broker. Operational implications
- No
-Xmx/-Xmstuning. .NET GC is self-managing. - No ZooKeeper, no KRaft warm-up — Surgewave's Raft starts in the same process.
- Native AOT: ~40 MB binary, ~80 MB peak RSS at idle. Fits in a tight container or edge device.
- Embedded mode: same binary becomes a NuGet package you `await broker.StartAsync()` in your test fixture.
- No
Numbers are conservative measurements; multipliers are targets from reproducible benchmarks against Apache Kafka on the same hardware. Click any tile for the methodology and chart.
See it in action
Surgewave.Control — the built-in management UI. Browse topics, design pipelines visually, install plugins, and monitor throughput in real time.
One UI for every operation — topic management, consumer groups, schema registry, signed plugin marketplace, visual AI/pipeline editor, real-time throughput. No separate dashboards, no third-party monitoring stack.
Every operation, one Surgewave.Control
From first connection through pipeline design to production observability — Surgewave.Control shows the right tools at the right moment.
Unified dashboard
Broker health, topic counts, partition spread, throughput sparklines — all on one screen. Drill into any topic with a click.
Topic detail & partitions
Per-partition offsets, replica placement, in-flight messages, consumer-group lag. Edit retention and compaction policies inline.
Consumer groups & lag
KIP-848 next-gen rebalance protocol visualised — see members, partition assignment, lag per-partition, and rebalance timeline.
Visual pipeline editor
Drag-drop node graph: Source → Filter → Enrich → AI-Node → Sink. With Surgewave.Ai installed, drop in RAG, embedders, agents, MCP tools.
Surgewave.Streams topology
KStream / KTable DSL visualised — sources, joins, windows, aggregations, state stores. Hot-reload the topology after edits in C# without restarting the broker.
AI agents & RAG traces
Live trace of each agent step: retrieval hits, prompt tokens, tool calls, A2A hops, ONNX inference latency. Drill into a single span like in a tracing UI.
Schema registry browser
Avro, JSON-Schema, Protobuf. Version diff, compatibility check, evolution history. Confluent-Schema-Registry-API-compatible.
Signed plugin marketplace
Browse, verify, install .swpkg plugins. ECDSA-signed packages show a “Verified” badge. One-click install, isolated AssemblyLoadContext.
Connector configuration
100+ connectors (Postgres, S3, Snowflake, Kafka, …) configured via UI. Validate creds before deploy, watch state transitions live.
Live throughput & latency
Per-topic bytes/sec, messages/sec, P50/P90/P99 latency percentiles. SignalR-driven real-time updates — no Grafana required.
Cluster topology
Controller, brokers, partition leaders, ISR sets. Spot under-replicated partitions instantly. Surgewave.Fleet extends this to multi-cluster view.
Surgewave.Fleet — multi-cluster
One control plane for every cluster, every region. Geo-replication links, fleet-wide topic catalogue, rolling upgrades, single-sign-on across all of them.
Identity, ACLs & RBAC
OIDC + SASL identity providers, fine-grained ACLs per topic / group / transactional-id, RBAC roles. Edit live, no broker restart.
Audit log & compliance trail
Every auth event, config change, plugin install, schema evolution — searchable, exportable, tamper-evident. SOC 2 / ISO 27001 ready.
A complete platform, not just a broker.
Surgewave ships the features teams usually bolt on: native fast transport, a typed schema registry, a signed plugin ecosystem, AI pipeline nodes, a Blazor control plane, a cloud control plane for many clusters — and full Kafka 4.x wire compatibility on top.
Signed plugins + SBOM
.swpkg packages signed with ECDSA or enterprise X.509/RFC-3161 timestamps. Every package ships a CycloneDX SBOM. Marketplace enforces on upload.
AI pipeline nodes
Built-in OpenAI / Anthropic / Ollama / xAI / Vertex AI nodes, Qdrant + pgvector retrievers, agent memory, guardrails, ONNX scoring — all as composable pipeline steps.
Schema Registry
Confluent-compatible REST API, 11 formats out of the box (Avro, Protobuf, JSON, FlatBuffers, MessagePack, CBOR, Hyperion, Bond, Thrift, MemoryPack, Cap'n Proto, Orleans).
Surgewave.Connect
117+ source and sink connectors for databases, cloud stores, SaaS APIs, IoT, and AI. Each shipped as a signed .swpkg. Build your own in an afternoon.
Streams + Interactive Queries
Kafka-Streams-style DSL on top of Surgewave with stateful joins, windowing, and HTTP-queryable state stores. LINQ everywhere it makes sense.
Surgewave.Control + Fleet
MudBlazor admin UI per broker, plus Surgewave.Fleet as a single cloud control plane for many clusters across DCs with QUIC-linked health, governance, and lifecycle.
Embedded mode
Run Surgewave in-process for tests, CI, and edge deployments. Same API, same guarantees — no broker container required.
Kafka 4.x wire — migration path
Drop-in compatible with Confluent.Kafka, librdkafka, kafka-go and friends. Point your existing producers and consumers at Surgewave and migrate gradually.
Speak every protocol your stack already uses
One broker, many wires. Surgewave's native protocol is the fast path for new .NET clients; the Kafka 4.x wire keeps every existing client connected. Each protocol is a discoverable plugin — load only what you need.
Native
Low-latency
Surgewave Native Protocol
Zero-copy framed protocol over TCP and QUIC/HTTP3 for new .NET clients. Shares the broker's wire endpoint with the Kafka protocol — auto-detected on the first frame, so one socket serves both Confluent.Kafka clients and the new native SDK.
Kafka Wire
Migration path
Kafka 4.x Wire Protocol
Full Kafka 4.x RPC compatibility. Confluent.Kafka, kafka-go, librdkafka — they all connect without a code change. Migrate gradually, mix and match with the native protocol on the same broker.
gRPC
gRPC-Web
HTTP/3
gRPC, gRPC-Web, HTTP/3
Server reflection, all four streaming flavours, JSON-transcoding for plain HTTP clients. gRPC-Web for browser SDKs, QUIC/HTTP3 for low-latency over lossy networks. Polyglot client SDKs against the same broker.
MQTT
5.0
MQTT 3.1.1 / 5.0
QoS 0/1/2, retained messages, last-will. Bridges every IoT device into a Kafka-compatible event stream.
AMQP
0.9.1
AMQP 0.9.1
Speak RabbitMQ's wire to existing apps while landing every routed message on a Surgewave topic for replay and analytics.
QUIC
0-RTT
QUIC / HTTP/3
Loss-tolerant streaming for mobile producers and edge gateways. 0-RTT resumption keeps cold reconnects under 50 ms.
WebSocket
WebSocket
Browser-native producers/consumers without a sidecar. Same auth, same topics, same offsets as the Kafka clients.
Solutions, not just features
Each Surgewave use case starts from a real pain we kept hitting in .NET shops — here's what Surgewave actually does about it, and where to go next.
Escape Kafka without a rewrite
The pain
JVM cluster ops, ZooKeeper drift, KRaft surprise upgrades, Confluent licence math.
Surgewave
Kafka-wire compatibility means existing producers, consumers, and admin tools connect unchanged. Transactions stay exactly-once. Migrate one topic at a time.
Migration guide →Real-time fraud detection
The pain
Kafka-Streams + Flink + an ML cluster — three systems, three SREs, three bills, three failure modes.
Surgewave
Joins, windowing, and ONNX scoring inside a single .NET process. Native protocol round-trip lands risk decisions inside the tap-to-pay envelope.
Fraud-detection cookbook →AI pipelines & agent memory
The pain
Agent memory glued from Postgres + Redis + Pinecone + LangChain — four systems, four bills, brittle plumbing.
Surgewave
Topic-as-memory, embedded vector retrievers, signed OpenAI / Ollama / Qdrant pipeline nodes. Guardrails veto outputs in-line.
AI docs →Digital twins & massive simulation
The pain
A million vehicles × per-second state updates × replay-the-last-week = Kafka segments thrash, JVM GC stalls.
Surgewave
Per-entity partitioning, native sub-ms transport, RocksDB for hot keyed state, S3-direct for cold replay — weeks of history cost cents per GB.
FleetTracker & DigitalTwin samples →
Storage that fits the workload
The pain
Kafka and Redpanda lock you into one log-segment engine. Keyed lookups become partition scans, cold archives stay on hot SSD — or you pay extra for someone's tiered-storage add-on.
Surgewave
Pick the engine per topic. Arrow columnar for analytics, RocksDB for keyed state, S3-direct for cold archive, NVMe-direct for hot paths — or write your own against IStorageEnginePlugin.
IoT & edge ingestion
The pain
Gateways speak MQTT, analytics wants Kafka — you cobble a bridge service nobody owns.
Surgewave
MQTT in, Kafka out — same broker, same topic, no bridge service. Embedded broker on the edge gateway itself.
IoT cookbook →Surgewave vs the field
A structured side-by-side — broken down by what operators care about: Admin, Performance, Cost, Reliability, Capability.
| Criterion | Surgewave | Apache Kafka | Redpanda | Aeron |
|---|---|---|---|---|
| Admin & Operations | ||||
| Deployment | Single binary, no JVM | JVM cluster + KRaft / ZK | Single binary (C++) | Library inside your process |
| Coordination | Built-in Raft | KRaft or ZooKeeper | Built-in Raft | None (transport only) |
| Embedded mode | In-process (surgewave://embedded) |
No | No | Yes (it’s a library) |
| Control plane | Per-broker Control + fleet view | Kafka Admin API + 3rd-party | Redpanda Console | External tooling |
| Performance | ||||
| P99 latency | Sub-ms (native), Kafka-baseline on Kafka wire | JVM-bounded, ~ms | Sub-ms (C++ broker) | Microsecond UDP |
| Throughput | >1M msg/s/broker | >1M msg/s/broker | ~1.5M msg/s/broker | 10M+ msg/s (in-memory) |
| Runtime | .NET 10 / C# 14, AOT-ready | JVM (Scala/Java) | C++ (Seastar) | JVM |
| Cost & Footprint | ||||
| Memory | No JVM heap, GC-aware | JVM heap tuning required | Thread-per-core (no GC) | JVM heap |
| Cold storage | Tiered to S3/Azure/GCS | 3.6+ tier (preview) | Tiered (managed only) | No |
| Disk format | Arrow, RocksDB, S3, NVMe-direct | Kafka segment log | Custom segment log | Off-heap buffers |
| Reliability | ||||
| Replication | Per-partition ISR + Raft | ISR-based | Raft (per-partition) | No persistence |
| Exactly-once | Producer Tx + WriteTxnMarkers | Yes (Kafka EOS) | Yes | App-layer |
| Geo-replication | Cluster Linking + Mirror | MirrorMaker 2 | Built-in linking | None |
| Capability | ||||
| Wire protocols | Kafka 4.x + Native + gRPC + AMQP + MQTT + WebSocket + QUIC | Kafka only | Kafka only | UDP/multicast |
| Plugin model | Signed .swpkg, ALC isolation |
JAR (Connect, MM2) | Wasm transforms | None |
| Stream processing | Surgewave.Streams (KIP-1071-aware) | Kafka Streams | Console transforms | None |
| AI pipelines | Built-in nodes (RAG, agents, ONNX) | External tooling | External tooling | None |
| Schema Registry | Confluent-API compatible, built-in | External (Confluent SR) | External (Confluent SR) | None |
Public head-to-head benchmarks land with 1.0; the table above summarises architecture, not measured numbers. See the full Surgewave vs Kafka write-up for the migration story.
Install in under a minute
Native packages for every major OS, plus a portable container image. Surgewave has no JVM dependency — the broker is one self-contained binary.
winget install Kuestenlogik.Surgewave
# or download surgewave-x.y.z-win-x64.msi from
# github.com/Kuestenlogik/Surgewave/releases# Debian / Ubuntu
sudo apt install ./surgewave_x.y.z_amd64.deb
# RHEL / Fedora
sudo rpm -i surgewave-x.y.z.x86_64.rpmdocker run -d \
-p 9092:9092 -p 5050:5050 \
ghcr.io/kuestenlogik/surgewave:latesthelm repo add surgewave https://surgewave.io
helm install surgewave surgewave/surgewave# Run Surgewave in-process for tests, CI, edge gateways
dotnet add package Kuestenlogik.Surgewave.Broker
# Then in code:
var broker = await SurgewaveRuntime.Create().StartAsync();Want a deeper integration? See the embedded-broker guide, or browse the full download options.
Up and running in three commands
Pick what you need. We'll show the exact lines for your setup.
Which components do you need?
Prefer code? Open the 5-minute quickstart with the .NET, Go, and Python client SDKs.
Migrating from Apache Kafka?
Repoint your clients. Done.
Surgewave speaks the Kafka 4.x wire protocol on the standard Kafka endpoint.
Existing Confluent.Kafka and librdkafka-based clients connect
unchanged. When you're ready for lower latency, swap the NuGet package and
stay on the same API.
# Before — your Kafka client
bootstrap.servers=kafka-1:9092,kafka-2:9092,kafka-3:9092
# After — same client, same config syntax, same cluster shape
bootstrap.servers=surgewave-1:9092,surgewave-2:9092,surgewave-3:9092Built to learn from
From your first message to production.
Three complementary on-ramps. Pick the one that fits how you learn — structured tutorial, real apps to copy from, or jump straight into the CLI with your AI assistant alongside.
Surgewave Bootcamp
A hands-on, self-paced tutorial: build real applications while learning Surgewave concepts. Multiple learning paths, guided walkthroughs via Shepherd.js, exercises with starter code and reference solutions.
Open BootcampSample apps
Full reference applications you can clone, run, and adapt — Kafka-compat migration, IoT fleet, RAG pipeline, event-sourcing, multi-protocol gateway, signed plugin walkthroughs and more. Each sample runs end-to-end against a local broker.
Browse samplesCLI & MCP server
A first-class command line covering every cluster operation, and a built-in Model Context Protocol server so Claude, Cursor and other agentic IDEs can drive your broker directly — inspect topics, replay messages, register schemas, profile performance, all from a chat window.
CLI & MCP docsSovereign by design
Made in Germany. Built for Europe.
Surgewave is a Küstenlogik product, engineered and maintained in Germany under EU data protection law. As the conversation about European technological sovereignty gets louder, the answer to “what do we actually own” needs to be short: this runs on your iron, under your rules.
- Self-hosted by default. Surgewave runs on your infrastructure — bare metal, private cloud, or a sovereign EU cloud. There is no managed SaaS that we operate; your topic data never sits on our servers.
- No CLOUD Act exposure. Küstenlogik is a German company. There is no US parent, no US subsidiary that can be served with a CLOUD Act or FISA 702 disclosure order on your behalf.
- GDPR built in. Field-level encryption, PII detection, and right-to-erasure ship as a first-class Privacy plugin — not gated behind an enterprise tier and not a bolt-on third-party integration.
- Apache 2.0 core, auditable. Every line of the broker, the protocol, the storage engine and the CLI is public. Forkable, reviewable, no rug-pull licence terms.
- No opt-out telemetry. Metrics and traces go to the OTLP endpoint you configure — or nowhere at all.
Roadmap
On course
What just shipped — and what’s next on the chart.
Recently shipped
Kafka 4.x wire compatibility v0.1.0
Unmodified Kafka clients connect on port 9092 — Confluent.Kafka, librdkafka, tools and monitoring work unchanged. No ZooKeeper, single binary.
Native binary protocol v0.1.0
A low-latency framed transport for .NET clients alongside the Kafka wire, with a published spec so other languages can implement it. Magic byte SRWV selects the native handler on the same port.
Public launch — NuGet + containers v0.1.0
86 Kuestenlogik.Surgewave.* packages on nuget.org, multi-arch container images on GHCR + Docker Hub, Windows MSI / .deb / .rpm installers.
CLI as a dotnet tool v0.1.5
dotnet tool install -g Kuestenlogik.Surgewave.Tool — 70+ admin commands plus broker lifecycle, all under the surgewave command.
Akka.NET integration v0.3.0
Akka.Streams sources/sinks/flows and an Akka.Persistence journal + snapshot store, both backed by Surgewave — Kuestenlogik.Akka.Surgewave.Streams + .Persistence.
Pluggable + tiered storage v0.1.0
FileSystem, in-memory, Arrow, RocksDB, SQLite, Parquet, LMDB, DuckDB, NVMe-direct, S3-direct — with a hot/cold tier that offloads sealed segments to S3 / Azure / GCS, transparent on the read path.
Public head-to-head benchmarks
Surgewave native and the Kafka wire on identical hardware, full configuration disclosed. The CI regression harness already tracks throughput + transport overhead; the documented run lands with 1.0.
Native clients for Python, Go, Rust
The native protocol has a public wire spec; first-party clients in other languages extend the compatibility story beyond .NET to the full Kafka-client ecosystem.
Disaggregated compute / storage
Broker as a pure coordination layer: producers write straight to object storage without ISR replication, readers fetch from object storage. Topic-level opt-in, building on the existing S3 engine.
Basic AI primitives in the open core
Five AI pipeline nodes (LLM chat, embeddings, vector read/write, prompt template) plus a single-shot RAG node move into the Apache-2.0 core, so a minimal AI pipeline runs without any commercial extension.
Independent Jepsen run
The in-house linearizability checker catches anomalies in our own runs; an external Jepsen run against a clustered docker-compose is the industry-standard trust signal.
Full detail and ordering live in the ROADMAP.md.
We Wrote the Framework.
Surgewave is built and maintained by Küstenlogik. When you need production-grade Surgewave — performance tuning, custom plugins, Kafka migration, architecture review — talk to the people who wrote it.
Production Support
24/7 incident response with an SLA. We pick up the pager when your cluster does. Triage, root-cause, fix, postmortem — all by the people who wrote the code paths.
Custom Plugins
Need a connector for an in-house system? A bespoke storage engine for your hot path? An AI pipeline node tied to your model registry? We build, sign, and ship it as a regular .swpkg.
Architecture Review
Pre-deployment audit before you put Surgewave on the critical path: capacity planning, replication topology, security review, failure-mode walkthrough. Two-week engagement, written report.
Migration & Training
Coming from Kafka, Redpanda, or a custom queue? We run the migration, train your platform team alongside, and stick around through the first week of production.
FAQ
Questions, answered
The short version. Deeper dives live in the docs and the comparison pages.
What is Surgewave?
A Kafka-wire-compatible message broker written in .NET 10. It accepts unmodified Kafka 4.x clients on port 9092 and adds a native binary protocol for lower-latency .NET workloads — broker, streams, schema registry, and control plane all on one runtime, with an embedded mode for tests and edge.
Can I use my existing Kafka clients?
Yes. Surgewave speaks the Kafka 4.x wire protocol, so any Kafka client (Confluent.Kafka, librdkafka, …) works unchanged — just point bootstrap.servers at Surgewave. Switch to the native protocol later for lower latency, no rewrite required.
Why Surgewave instead of Apache Kafka?
Same wire protocol, no JVM, no ZooKeeper, single binary, and an embedded mode that makes integration tests run without Docker. Full migration story on the Surgewave vs Kafka page.
Why not Redpanda?
Both drop the JVM — Redpanda bets on C++, Surgewave on .NET 10. If your stack is .NET, Surgewave gives you broker, streams and plugins on the same runtime, with an Apache-2.0 core (not BSL). Details on Surgewave vs Redpanda.
Why not Aeron?
Aeron is a transport library, not a persistent broker — no durable log, no Kafka API. Surgewave is a broker with replayable storage that also offers a low-latency native transport. See Surgewave vs Aeron.
Do I need Docker or ZooKeeper?
No. Coordination is built in (KRaft-style Raft, in-process). For tests you can run an embedded in-memory broker — no container, no external services:
await using var surgewave = new EmbeddedSurgewave();
await surgewave.StartAsync();Which .NET version is required?
.NET 10 or later. Surgewave uses modern C# and is tuned for performance with Span<T>, Memory<T> and SIMD.
Is it open source?
Yes — the core is Apache-2.0 (GitHub). Enterprise features ship as separately-licensed plugins, so the broker, clients and core tooling stay permissively licensed.
Ready to swap out your Kafka?
Surgewave runs a single-node broker, a full cluster, or an embedded in-process mode from the same binaries. Try it in five minutes.
Single binary. No JVM. Runs in 30 seconds.
Custom plugins, paid support, or architecture review? Talk to us · See our services