Kafka
Produce to and consume from a cluster in the same window as everything else. Every security shape, topic management without a CLI, and Schema Registry on both sides. It speaks the same broker protocol your services do, so what works here works from them.
Watching Takes Nothing Away
The consumer assigns partitions directly. It never joins a consumer group and never commits an offset, so tailing a topic does not rebalance the applications already reading it or move anyone's committed position.
The History Lives in the Backend
What you read is held in Rust under a byte budget, around 226,000 typical messages by default, and the panel shows a window onto it. A busy topic fills that buffer, not the UI, and the search runs over all of it.
Schema Registry, Both Directions
Encode a produce against the registry's Avro schema, and decode what you read by the schema id each message carries. The producer and the consumer hold their own registry connections, so turning one on never changes the other.
One Tab, Both Sides
A Kafka tab is one connection, and the producer and the consumer share it. Compose a message on the left with its key, headers and partition; tail the topic on the right and watch it land. The message you just sent is a row you can expand, decoded, seconds later.
Every Security Shape
PLAINTEXT, SSL, SASL_PLAINTEXT, SASL_SSL. PLAIN, SCRAM-SHA-256, SCRAM-SHA-512 and OAUTHBEARER, with the token fetched and refreshed for you. Trust a private CA, present a client certificate for mutual TLS as a PEM pair or a PKCS#12 keystore, and choose exactly how much of the broker's certificate is checked.
Schema Registry on Both Sides
The producer and the consumer each connect to their own registry, so turning one on never changes the other. Producing, the subject and the exact schema are on screen before you send and the value is validated field by field, then the send frames with the schema id you were shown rather than a fresh lookup. Reading, every framed message is decoded by the id it carries.
Or Bring Your Own Schema
Reading a topic that has no registry behind it? Paste an Avro schema or upload an .avsc, choose whether it decodes the key or the value, and add up to ten. Each message is decoded by the first that fits, so a topic carrying several record types reads cleanly. A schema you supplied is tried before the registry, and if the two disagree about the same id the panel tells you yours may be stale.
Start Reading Anywhere
Where a read begins is the whole question on a topic that has been running for months. Pick one of five, and every partition is positioned before the first record arrives.
Latest
Only what arrives from now on. The default, because a tool that replays a whole topic on open makes itself the loudest thing on the cluster.
Last N
The last N records of each partition. The question people actually ask: Latest shows nothing on a quiet topic and Earliest shows millions.
Earliest
Everything the topic still holds, from the oldest record retention has not yet deleted.
Offset
The same offset on every partition, for when you know exactly where the record you are chasing sits.
Timestamp
The first record at or after an instant, resolved per partition by the broker. Pick a wall-clock time, land on the right offsets.
Full Producer Control
Every knob a real producer has, on the message in front of you. The partition list offers the partitions the topic actually has, so an out-of-range choice is not something you can express. When exactly-once is on, acks is held where librdkafka requires it rather than offered and then overruled.
The result bar reads like a status line: which partition, which offset, how many bytes, how long it took. With acks at 0 it says the message was sent, never that it was delivered, because nothing confirmed it.
On Every Message
- Text, JSON, or raw bytes as base64, with the JSON you typed sent exactly as you typed it
- A key whose hash picks the partition, or an explicit partition chosen from the ones the topic actually has
- Headers, including repeated names and the value-less form Kafka uses as a flag
- Tombstones: a key with no value at all, which is how log compaction deletes a key
- acks 0, 1, or all, plus gzip, snappy, lz4 or zstd compression
- Exactly-once delivery, retries, and a produce timeout that actually bounds the send
The Whole Lifecycle
- Create with a partition count, a replication factor capped at the broker count, and config overrides
- Describe: per-partition leader, replicas, in-sync replicas, and where each log ends
- Edit the six managed configs (cleanup.policy, compression.type, max.message.bytes, min.insync.replicas, retention.bytes, retention.ms) without disturbing overrides you did not set
- Raise the partition count, which is the only direction Kafka allows
- Delete, behind a confirmation, because it takes every message with it
Manage Topics Without a CLI
The kebab beside the topic picker runs the whole lifecycle through the AdminClient. Create a topic, look at how its partitions are placed, change the settings that can be changed, delete it when it has served its purpose.
When the broker refuses, you get the reason in words: a replication factor above the broker count, a name the cluster will not accept, a partition count that can only go up. Not a raw error enum to look up.
Read, Filter, Export
A topic carries whatever was written to it, so nothing here assumes what the producer sent. Every row shows partition, offset, timestamp, key and size, and expands into the whole record.
Whatever the Topic Carries
JSON is laid out, text is text, and bytes that are not text are shown as hex rather than as a wall of replacement characters. A 64-bit id keeps every digit it was written with.
Search Everything Held
The filter runs over the whole buffer in the backend, not the rows the window happens to hold, and it searches keys, values and headers. On a decoded topic it searches the decoded content, field names included.
Narrow to One Partition
Filter the view down to a single partition when you are chasing an ordering question rather than a value.
Raw Beside Rendered
Expand a row and switch to Raw for the whole record as one JSON object: key, headers and value, with the bytes in full. For when the rendering itself is what you are checking.
Export What Matched
JSON array, JSON Lines, or CSV, written from the whole match rather than the page on screen. Decoded rows export decoded; numbers are written exactly as they arrived.
Values Only
Export just the message values for replaying elsewhere, seeding a fixture, or pasting into a request. A partition and an offset are facts about this topic at this moment.
Credentials You Never Have to Retype
What you type into the security fields lives in memory while the app is open and is never written to disk. To have it remembered, put a {{variable}} there instead and mark that variable secret in the environment. It is then kept in your OS keychain, or pulled from Vault at connect time, and every field resolves it: the password, the CA, the token endpoint, the key passphrase.
Ready to work with your streams?
Download Atrahasis and produce, consume, and manage topics from the tool you already build with.