# Redpanda — Kafka-Compatible Streaming Platform Without JVM

> Redpanda is a Kafka-compatible streaming data platform written in C++. It is a drop-in replacement for Kafka that is simpler to operate — no JVM, no ZooKeeper, single binary deployment — with lower latency and built-in schema registry.

## Install

Save as a script file and run:

# Redpanda — Kafka-Compatible Streaming Platform Without JVM

## Quick Use
```bash
# Install rpk CLI
# macOS
brew install redpanda-data/tap/redpanda

# Start a single-node cluster
docker run -d --name redpanda \
  -p 9092:9092 -p 8081:8081 -p 8082:8082 -p 9644:9644 \
  docker.redpanda.com/redpandadata/redpanda:latest \
  redpanda start --smp 1 --memory 1G --overprovisioned

# Create a topic
rpk topic create my-topic --brokers localhost:9092

# Produce messages
echo "Hello Redpanda" | rpk topic produce my-topic

# Consume messages
rpk topic consume my-topic
```

## Introduction
Redpanda is designed to be a simpler, faster Kafka. While Kafka requires a JVM, ZooKeeper (or KRaft), and complex tuning, Redpanda is a single C++ binary that self-tunes for your hardware. It is fully Kafka API compatible — existing Kafka clients, Connect connectors, and tools work without any code changes.

With over 12,000 GitHub stars, Redpanda is used by companies that want Kafka-level streaming without the operational complexity. It provides consistently lower latency (p99 < 10ms vs Kafka's 100ms+) and built-in schema registry and HTTP proxy.

## What Redpanda Does
Redpanda receives, stores, and delivers streaming data using the Kafka protocol. Producers write records to topics, consumers read them. Unlike Kafka, Redpanda uses a thread-per-core architecture (like ScyllaDB) for predictable performance, and stores data on local NVMe SSDs with its own storage engine (not relying on the OS page cache).

## Architecture Overview
```
[Kafka Clients]
Any Kafka producer/consumer
librdkafka, confluent-kafka,
kafka-python, sarama, etc.
        |
   [Redpanda (C++ single binary)]
   Kafka API compatible
   Thread-per-core (Seastar)
   Self-tuning, no JVM
        |
+-------+-------+-------+
|       |       |       |
[Raft    [Schema  [HTTP
Consensus] Registry] Proxy]
Built-in  Built-in  REST API
(no ZK)   (no extra for produce
          service)  and consume
        |
   [Storage]
   Optimized for NVMe SSDs
   Tiered storage to S3
   (offload cold data)
```

## Self-Hosting & Configuration
```yaml
# docker-compose.yml — 3-node cluster
version: "3.8"
services:
  redpanda-0:
    image: docker.redpanda.com/redpandadata/redpanda:latest
    command:
      - redpanda start
      - --smp 2
      - --memory 2G
      - --kafka-addr 0.0.0.0:9092
      - --advertise-kafka-addr redpanda-0:9092
      - --rpc-addr 0.0.0.0:33145
      - --advertise-rpc-addr redpanda-0:33145
    ports:
      - 9092:9092
      - 8081:8081
      - 9644:9644

  console:
    image: docker.redpanda.com/redpandadata/console:latest
    ports:
      - 8080:8080
    environment:
      KAFKA_BROKERS: redpanda-0:9092
      KAFKA_SCHEMAREGISTRY_URLS: http://redpanda-0:8081
```

```bash
# rpk CLI operations
rpk topic list
rpk topic create orders --partitions 6 --replicas 3
rpk topic describe orders
rpk group list
rpk cluster info
rpk cluster config set log_retention_ms 604800000  # 7 days
```

## Key Features
- **Kafka API Compatible** — drop-in replacement, no code changes
- **No JVM** — C++ single binary, predictable performance
- **No ZooKeeper** — built-in Raft consensus, simpler operations
- **Self-Tuning** — automatically optimizes for your hardware
- **Built-in Schema Registry** — no separate service needed
- **Tiered Storage** — offload cold data to S3/GCS
- **Redpanda Console** — web UI for topics, consumers, and schemas
- **Low Latency** — consistent sub-10ms p99 latency

## Comparison with Similar Tools
| Feature | Redpanda | Kafka | Pulsar | NATS JetStream |
|---|---|---|---|---|
| Language | C++ | Java (JVM) | Java (JVM) | Go |
| ZooKeeper | No | KRaft (removing ZK) | Yes (removing) | No |
| Schema Registry | Built-in | Separate service | Built-in | No |
| Latency (p99) | <10ms | 50-200ms | 10-50ms | <5ms |
| Kafka Compatible | 100% API | Native | KoP plugin | No |
| Operational Complexity | Low | High | High | Low |
| Best For | Kafka replacement | Ecosystem + scale | Multi-tenant | Lightweight |

## FAQ
**Q: Can I really replace Kafka with Redpanda?**
A: Yes for most use cases. Redpanda implements the Kafka protocol, so Kafka clients, Kafka Connect, ksqlDB, and Kafka Streams work without changes. Test with your specific workload.

**Q: When should I NOT use Redpanda?**
A: If you need the full Confluent ecosystem (ksqlDB, specific connectors), Kafka's multi-datacenter replication (MirrorMaker 2), or if your team has deep Kafka operational expertise.

**Q: How does performance compare?**
A: Redpanda consistently shows lower latency (especially p99/p999) and higher throughput per node in benchmarks. The C++ thread-per-core architecture avoids JVM garbage collection pauses.

**Q: Is Redpanda free?**
A: Redpanda Community is free and open source (BSL-1.1, converts to Apache-2.0). Redpanda Enterprise adds features like continuous data balancing and tiered storage.

## Sources
- GitHub: https://github.com/redpanda-data/redpanda
- Documentation: https://docs.redpanda.com
- Website: https://redpanda.com
- Created by Redpanda Data
- License: BSL-1.1

---
Source: https://tokrepo.com/en/workflows/8d719c12-3734-11f1-9bc6-00163e2b0d79
Author: Script Depot