2011 – 2026

Apache Kafka Versions

Every release of Apache Kafka — from the 0.7 incubating release open-sourced out of LinkedIn, through the platform-defining APIs (replication, Connect, Streams, exactly-once) to the current line. Kafka 4.3 (May 2026) is the current release; Kafka has been KRaft-only since 4.0 (March 2025), when Apache ZooKeeper was removed entirely. With ship dates and headline changes per version, the multi-year KRaft transition this page exists to make legible, and the Apache-2.0-vs-Confluent-Community-License story.

The architecture change behind every recent release

Do I still need ZooKeeper? Not since Kafka 4.0.

For most of its history Kafka stored its cluster metadata — brokers, topics, partitions, controller election — in a separate Apache ZooKeeper ensemble you had to run and operate alongside the brokers. KIP-500 replaced that with KRaft (Kafka Raft), a built-in Raft-based metadata quorum that lets the brokers manage their own metadata — no ZooKeeper.

The transition took years, tied to specific versions: KRaft shipped as early access in 2.8 (April 2021), went production-ready for new clusters in 3.3 (KIP-833, 2022), gained a supported ZooKeeper→KRaft migration path that reached production-ready in 3.6 (KIP-866), and 3.9 was the last release to support ZooKeeper at all — the recommended bridge for migrating an existing cluster to 4.0. Kafka 4.0 (March 2025) removed ZooKeeper entirely: 4.x is KRaft-only. So the answer is version-pinned — on 4.0 or later you do not run ZooKeeper; on 3.9 or earlier you still can. See the era divider in the table below and the KRaft history.

Era

ZooKeeper era — 0.x–2.8, metadata lived in a separate Apache ZooKeeper ensemble
KRaft transition — 3.0–3.9, KRaft matures from preview to production alongside ZooKeeper
KRaft-only — 4.0 onward, ZooKeeper removed; KRaft is the only metadata mode

Support: Apache Kafka publishes no formal LTS or end-of-life matrix. The project ships a new minor roughly every four months and the community maintains about the three most-recent minors with patch releases; older minors — now including 3.9, the final ZooKeeper bridge release — are effectively end-of-life and moved to the archive. Longer commercial support (up to three years) is available through Confluent Platform. As of August 2026, 4.3 is current; the live list of supported releases is at kafka.apache.org/downloads.

Apache Kafka version table

Version
Kafka 4.3 Current
KRaft-only
May 22, 2026
Current line. Broker cordoning (cordoned.log.dirs); per-partition retention metrics; faster tiered-storage follower bootstrap; share-group operational tuning. Latest patch 4.3.1 (Jun 25, 2026).
  • Broker cordoning — the new cordoned.log.dirs setting marks a log directory off-limits for new partition placement while the broker stays up and existing replicas keep serving. Useful for draining a failing disk without taking the broker down.
  • Partition-retention metrics — new JMX metrics expose what percentage of its maximum retention each topic-partition is using, so operators can spot partitions approaching a retention cliff before data is dropped.
  • Tiered-storage follower bootstrap — a new follower replica on a tiered-storage topic can recover from remote-store offsets instead of replaying the entire local log, shortening reassignment and recovery time.
  • Share-group tuning — broker- and group-level configs to control the Queues / Share Group behavior that went production-ready in 4.2; Streams gains StateStore-managed changelog offsets and exposes Bytes in the public API.
  • Roughly 25 KIPs and 600+ commits over 4.2. 4.3 also carries deprecations marked for removal in a future Kafka 5.0 — notably the streams-scala module (KIP-1244). Latest patch 4.3.1 (Jun 25, 2026) fixes a Kafka Streams RocksDB native-memory leak (KAFKA-20616). See the 4.3.0 announcement, and confirm the live tip at kafka.apache.org/downloads.
Version
Kafka 4.2
KRaft-only
Feb 17, 2026
Queues (Share Groups) production-ready; Streams server-side rebalance protocol GA; dead-letter-queue support in exception handlers; standardized --bootstrap-server across CLI tools; Java 25 support.
  • Queues for Kafka went production-ready — Share Groups (KIP-932), early access in 4.0 and a preview in 4.1, reached production readiness with a RENEW acknowledgement type, adaptive batching in the share coordinator, and comprehensive lag metrics. Multiple consumers can now cooperatively process records from the same partitions with per-record acknowledgement — queue semantics without strict partition-to-consumer assignment.
  • Streams rebalance protocol GA — the server-side Streams rebalance protocol (built on KIP-848) reached GA with a limited feature set; dead-letter-queue support landed in exception handlers, plus anchored wall-clock punctuation.
  • CLI and metrics consistency — every CLI tool standardized on --bootstrap-server; metric naming moved toward the consistent kafka.<component> pattern; new idle-ratio metrics for the controller and MetadataLoader.
  • Java 25 support; external-schema support in JsonConverter; rack-id exposure in the Admin API. Latest patch 4.2.1 (May 30, 2026).
Version
Kafka 4.1
KRaft-only
Sep 2, 2025
Queues / Share Groups (KIP-932) reach preview; a new Streams rebalance protocol (KIP-1071, built on KIP-848) arrives in early access; further consumer-protocol and KRaft hardening.
  • Share Groups reached preview — the Queues-for-Kafka work (KIP-932) moved from 4.0's early access to a preview here: ready to evaluate and test, explicitly still not ready for production. Production readiness came in 4.2.
  • Streams rebalance protocol (KIP-1071) — a new Kafka Streams rebalance protocol built on the KIP-848 consumer group protocol, moving group coordination broker-side for Streams applications. Early access in 4.1; GA (with a limited feature set) in 4.2.
  • Continued hardening of the KIP-848 consumer group protocol (GA'd in 4.0) and KRaft; incremental Connect and Streams improvements. Latest patch 4.1.2 (Mar 17, 2026). See the 4.1.0 announcement.
Version
Kafka 4.0
KRaft-only
Mar 18, 2025
ZooKeeper removed entirely — KRaft-only. New consumer group protocol (KIP-848) GA; Queues / Share Groups (KIP-932) early access; Java 8 and the Scala 2.12 build dropped — brokers now require Java 17.
  • ZooKeeper removed — the milestone this page's KRaft callout is about. 4.0 is the first release that cannot run in ZooKeeper mode; every cluster is KRaft. Existing ZooKeeper clusters must migrate via a 3.9 bridge before upgrading (see the era divider below).
  • New consumer group protocol GAKIP-848 reached general availability. The broker now drives partition assignment incrementally instead of the old "stop-the-world" client-side rebalance, removing the latency spikes that hit large groups on every membership change. Enabled by default server-side; consumers opt in with group.protocol=consumer.
  • Queues for Kafka (early access) — Share Groups (KIP-932) shipped as early access, bringing queue-style cooperative consumption to Kafka for the first time. It became a preview in 4.1 and production-ready in 4.2.
  • Toolchain floor raised — Java 8 support was dropped outright (KIP-750). Brokers, Connect, and tools now require Java 17, while clients and Kafka Streams require Java 11 (KIP-1013) — so "Java 11" is still a supported client floor, not a dropped one. The Scala 2.12 build was dropped (KIP-751), leaving Scala 2.13 as the only broker build, and logging migrated from Log4j to Log4j2 (KIP-653). See the Scala-version note below.
  • See the 4.0.0 announcement.
Version
Kafka 3.9
KRaft transition
Nov 6, 2024
The final release with ZooKeeper support — the recommended bridge to 4.0. Tiered storage went production-ready (KIP-405); dynamic KRaft quorums (KIP-853).
  • Last ZooKeeper release — 3.9 is the terminal 3.x line and the last Kafka that supports ZooKeeper. Its role is the bridge release: a ZooKeeper cluster upgrades to 3.9, migrates to KRaft, and only then moves to 4.x. It received extended patch releases for exactly that reason — the last was 3.9.2 (Feb 21, 2026) — but 3.9 has since dropped off Apache's supported-releases list and is now archived, so the bridge is still the path but no longer a patched one.
  • Tiered storage production-readyKIP-405 left early access, letting brokers offload older log segments to remote object storage and keep less on local disk.
  • Dynamic KRaft quorums — KIP-853 allows adding and removing KRaft controllers and brokers dynamically, closing an operational gap that had made KRaft controller changes rigid.
Version
Kafka 3.8
KRaft transition
Jul 29, 2024
Tiered-storage improvements; JBOD support in KRaft mode; Connect and Streams refinements ahead of the 3.9 ZooKeeper-era finale.
  • JBOD in KRaft — support for multiple log directories per broker (just-a-bunch-of-disks) under KRaft, one of the last capabilities KRaft needed to match ZooKeeper-mode feature parity before 4.0.
  • Tiered-storage refinements; MirrorMaker and Connect improvements; incremental KRaft hardening.
Version
Kafka 3.7
KRaft transition
Feb 27, 2024
New consumer group protocol (KIP-848) early access; tiered storage still in early access; Java 21 support; JBOD-in-KRaft early access.
  • KIP-848 early access — the first preview of the next-generation consumer rebalance protocol that would GA in 4.0.
  • Java 21 support; ZooKeeper-to-KRaft migration continued to mature; Connect and Streams updates.
Version
Kafka 3.6
KRaft transition
Oct 10, 2023
ZooKeeper→KRaft migration production-ready (KIP-866); tiered storage arrives in early access (KIP-405).
  • Migration production-ready — the ZooKeeper-to-KRaft migration (KIP-866), early-access since 3.4/3.5, became production-ready in 3.6. Existing clusters could now be moved to KRaft with a supported path.
  • Tiered storage (early access) — KIP-405 shipped its first preview, decoupling storage from compute by offloading old segments to remote object stores (GA in 3.9).
Version
Kafka 3.5
KRaft transition
Jun 15, 2023
ZooKeeper mode formally deprecated; ZooKeeper→KRaft migration still in early access; full distributed mode for dedicated MirrorMaker 2 clusters (KIP-710); first-class offsets support in Connect (KIP-875).
  • ZooKeeper deprecated — with KRaft production-ready for new clusters (since 3.3) and a migration path still in early access, 3.5 formally deprecated ZooKeeper mode, signaling the direction of 4.0.
  • MirrorMaker 2's dedicated mode gained full distributed-mode support (KIP-710); Connect gained REST endpoints for managing connector offsets (KIP-875); consumers gained rack-aware partition assignment (KIP-881). The original MirrorMaker (MM1) was not removed here — it was deprecated in 3.0 and finally deleted in 4.0.
Version
Kafka 3.4
KRaft transition
Feb 7, 2023
ZooKeeper→KRaft migration ships in early access (KIP-866) — the first release existing clusters could begin moving off ZooKeeper.
  • Migration early access — KIP-866 introduced the machinery to migrate an existing ZooKeeper-backed cluster to KRaft (early access; production-ready in 3.6).
  • Fetch-from-follower and stability improvements; Connect and Streams updates.
Version
Kafka 3.3
KRaft transition
Oct 3, 2022
KRaft marked production-ready for new clusters (KIP-833) — the watershed that made ZooKeeper-free Kafka a supported choice.
  • KRaft production-ready — after two years of development, KIP-833 declared KRaft production-ready for new clusters. Existing ZooKeeper clusters still needed a migration path (which followed in 3.4–3.6). Note the odd start: a serious bug was found in 3.3.0 after the artifacts were published but before the announcement, so 3.3.0 was never announced and Apache recommends against using it — 3.3.1 (Oct 3, 2022) is the release that actually shipped this line.
  • KRaft catch-up shipped alongside it: KRaft-to-KRaft upgrades (KIP-778) and controller-quorum health monitoring (KIP-835). Elsewhere in the release: a strictly uniform sticky partitioner (KIP-794), pause/resume for Streams topologies (KIP-834), and exactly-once support for Connect source connectors (KIP-618).
Version
Kafka 3.2
KRaft transition
May 17, 2022
KRaft authorizer (StandardAuthorizer, KIP-801) for ACLs; log4j 1.x replaced with reload4j; Interactive Query v2; fixes to the idempotent-producer default.
  • ACLs in KRaft — the StandardAuthorizer (KIP-801) brought ACL support to KRaft mode, another parity step toward removing ZooKeeper.
  • log4j 1.x → reload4j — the logging dependency moved to reload4j, a security-patched fork of log4j 1.x. This is not the Log4j2 migration, which came later in 4.0 (KIP-653).
  • Interactive Query v2 (KIP-796 and friends); rack-aware standby task assignment in Streams (KIP-708); a partition-recovery hint to the leader (KIP-704); and fixes to the idempotent-producer-by-default behavior introduced in 3.0.
Version
Kafka 3.1
KRaft transition
Jan 24, 2022
Java 17 support; Topic IDs in the FetchRequest (KIP-516); OIDC support for SASL/OAUTHBEARER; the eager rebalance protocol is deprecated.
  • A maintenance-and-refinement minor on the road to KRaft parity, with KRaft still in preview: Java 17 support, Topic IDs threaded through the FetchRequest (KIP-516), OIDC for SASL/OAUTHBEARER (KIP-768), new broker-count and latency metrics, and deprecation of the eager rebalance protocol.
Version
Kafka 3.0
KRaft transition
Sep 21, 2021
KRaft in preview; idempotent producer enabled by default (KIP-679); stronger exactly-once defaults; Java 8 and Scala 2.12 deprecated.
  • KRaft preview — the metadata quorum, early-access in 2.8, became a fuller preview in 3.0 (still not for production).
  • Idempotent producer on by default — KIP-679 turned on the idempotent producer by default, making exactly-once-friendly semantics the out-of-the-box behavior.
  • Deprecated Java 8 and Scala 2.12 (both removed in 4.0); message-format and older-client cleanups.
2.8 → 3.x — KRaft begins replacing ZooKeeper. Rows above this divider are the KRaft-transition era (3.0–3.9) and the KRaft-only era (4.0+); rows below shipped in the ZooKeeper era. KRaft (KIP-500) arrived as early access in 2.8, went production-ready for new clusters in 3.3 (KIP-833), gained a production-ready ZooKeeper→KRaft migration in 3.6 (KIP-866), and 3.9 was the last release to support ZooKeeper at all — before 4.0 removed it entirely. See the callout above and the KRaft history.
Version
Kafka 2.8
ZooKeeper
Apr 19, 2021
KRaft early access — the first release you could run without ZooKeeper (experimental, KIP-500). Topic IDs; Connect and Streams improvements.
  • The first ZooKeeper-less Kafka — 2.8 shipped KRaft as early access, letting you stand up a cluster with no ZooKeeper for the first time. Strictly experimental, but the beginning of the whole transition.
  • Topic IDs (stable identifiers for topics across renames/recreates); Connect and Streams improvements.
Version
Kafka 2.7
ZooKeeper
Dec 21, 2020
Early KRaft groundwork (the KIP-595 Raft implementation for the metadata quorum); PEM-format SSL certificates and keys; broker-side SCRAM config API; topic-operation throttling and connection-rate quotas.
  • Groundwork for KRaft landed here as the KIP-595 Raft implementation for the metadata quorum — internal plumbing ahead of 2.8's user-facing early access, not yet something you could run a cluster on.
  • PEM format for SSL certificates and private keys; a broker-side SCRAM config API; throttling for create-topic, create-partition and delete-topic operations; broker-wide and per-listener connection-creation rate limits (KIP-612); sliding-window aggregations and TRACE-level end-to-end latency metrics in Streams.
Version
Kafka 2.6
ZooKeeper
Aug 3, 2020
Client and broker performance work; Connect improvements; explicit rebalance-protocol and metrics additions.
  • Throughput and latency improvements across producer, consumer, and Connect; new metrics; incremental Streams work.
Version
Kafka 2.5
ZooKeeper
Apr 15, 2020
Exactly-once semantics improvements; co-groups in Streams; TLS and ZooKeeper 3.5.x upgrade.
  • Exactly-once semantics hardening; Streams co-group support; bumped the bundled ZooKeeper to 3.5.x; TLS improvements.
Version
Kafka 2.4
ZooKeeper
Dec 16, 2019
MirrorMaker 2.0; incremental cooperative rebalancing; fetch-from-closest-replica (rack-aware reads).
  • MirrorMaker 2.0 — a ground-up rewrite of cross-cluster replication built on Connect, replacing the fragile original MirrorMaker.
  • Incremental cooperative rebalancing — consumers no longer revoke every partition on each rebalance, reducing stop-the-world pauses (a theme KIP-848 finished in 4.0).
  • Sticky partitioner — KIP-480 changed the default partitioner for keyless records to fill one partition at a time instead of round-robining, producing markedly better batching and lower latency. (A strictly uniform version followed in 3.3, KIP-794.)
  • Fetch-from-closest-replica (KIP-392) for rack-aware, lower-latency reads; a new Java authorizer interface; non-key joins in KTable.
Version
Kafka 2.3
ZooKeeper
Jun 25, 2019
Connect incremental cooperative rebalancing; in-memory session and window stores in Kafka Streams; an incremental AlterConfigs API; several Connect REST API improvements.
  • Incremental cooperative rebalancing came to Connect; Kafka Streams gained in-memory session and window stores; a new incremental AlterConfigs API landed and the old one was deprecated.
  • Operational work: tracking of partitions under their min-ISR count, external configuration stores (KIP-421), consumer opt-out of automatic topic creation, and improved replica-fetcher behavior on errors.
Version
Kafka 2.2
ZooKeeper
Mar 22, 2019
Consumer-group management improvements (the default group.id is now null rather than an empty string); kafka-topics.sh moves onto the AdminClient; periodic SASL re-authentication.
  • Admin and consumer-group refinements — bin/kafka-topics.sh gained AdminClient support, SASL connections can periodically re-authenticate, and SSL gained custom principal-name support.
  • Streams added the flatTransform() DSL operator, and KafkaStreams implements AutoCloseable for try-with-resources.
Version
Kafka 2.1
ZooKeeper
Nov 20, 2018
Zstandard (zstd) compression; Java 11 support; improved replication and quota handling.
  • Zstandard compression — KIP-110 added zstd as a message-compression codec, materially improving compression ratios over gzip / snappy / lz4.
  • Java 11 support; replication and reliability improvements.
Version
Kafka 2.0
ZooKeeper
Jul 30, 2018
Prefixed ACLs and finer-grained security; Streams and Connect maturity; incremental exactly-once improvements.
  • Prefixed and wildcard ACLs; security and quota improvements; Streams and Connect refinements. A cleanup major rather than a feature break — the 1.x→2.0 step signaled maturity, not incompatibility.
Version
Kafka 1.1
ZooKeeper
Mar 28, 2018
Controller and broker scalability (faster failover with many partitions); Connect and Streams improvements.
  • Controller improvements that sharply reduced failover time on clusters with large partition counts — a scaling milestone; Connect and Streams enhancements.
Version
Kafka 1.0
ZooKeeper
Nov 1, 2017
The maturity milestone — production stability, metrics, and exactly-once hardening. A version-number signal, not a feature break (0.11 was arguably the bigger release).
  • 1.0 signaled stability, not a break — after years on 0.x, the jump to 1.0 marked Kafka as production-mature. The functionally larger release was the prior one: 0.11's exactly-once semantics.
  • Metrics, operability, and exactly-once / Streams hardening; JBOD disk-failure handling.
Version
0.x lineage (0.7 – 0.11)
ZooKeeper
2012 – 2017
Kafka spent years on 0.x — and shipped its most consequential features there: replication (0.8), Connect (0.9), Streams (0.10), and exactly-once (0.11).

Kafka was on a 0.x version for its first five years, and those releases carried the platform-defining APIs. 0.11's exactly-once semantics were arguably more significant than the 1.0 maturity milestone that followed. Listed here for completeness rather than as full rows:

  • 0.7 (Jan 2012) — the first Apache release (incubating), the LinkedIn open-source made an Apache project.
  • 0.8 (Dec 2013) — intra-cluster replication. The reliability watershed: partitions gained replicas and leader election, making Kafka durable enough for mission-critical pipelines.
  • 0.9 (Nov 2015) — Kafka Connect, the new Java consumer, security (SSL/SASL, ACLs), and quotas.
  • 0.10 (May 2016) — Kafka Streams, the stream-processing library built into Kafka; message timestamps and rack awareness.
  • 0.11 (Jun 2017) — exactly-once semantics: the idempotent producer and transactions, plus the v2 message format. The single most important 0.x release.

None of these receive updates; nothing here is what you would deploy today. The LinkedIn origin and the API build-out are covered in the history below.

Click any row to expand. Each row has a stable id for sharing — e.g. /software/kafka/versions/#kafka-4-0, #kafka-3-3, #kafka-2-8.

Apache Kafka vs Confluent — the licensing story

Is Kafka open source? Yes — the core is Apache 2.0.

Apache Kafka — the broker, clients, Connect, and Streams tracked on this page — is licensed Apache 2.0, an OSI-approved open-source license. That has never changed. The licensing question people run into is about Confluent, the company founded in 2014 by Kafka's original creators (Jay Kreps, Neha Narkhede, and Jun Rao) to commercialize it — and an IBM subsidiary since March 2026.

In December 2018, Confluent moved some of its own add-ons in Confluent Platform — ksqlDB, the Schema Registry, REST Proxy, and certain connectors — from Apache 2.0 to the source-available Confluent Community License (CCL). Like MongoDB's SSPL, the CCL is a response to cloud vendors offering the software as a managed service: you can read, modify, and redistribute the source, but you cannot use it to offer a competing SaaS. The OSI has not approved the CCL, so those components are source-available, not open source. The key point for this page: the CCL applies only to Confluent's extras, not to Apache Kafka itself, which remains Apache 2.0. See the Confluent history below.

Find your version — and the kafka_2.13 gotcha

The browser can't detect what Kafka version you're running. Run one of these against your broker or CLI tools. And read the artifact-name note first — the number people misread as the Kafka version usually isn't.

First: kafka_2.13-4.3.1 — the 2.13 is Scala, not Kafka

Kafka's broker is partly written in Scala, so its download artifacts are named kafka_<scala-version>-<kafka-version>. The leading number is the Scala build version — not the Kafka version.

# kafka_2.13-4.3.1.tgz
#      └┬─┘ └┬──┘
#    Scala   Kafka   ← the version you almost always mean is the second one

# Kafka 4.x builds only against Scala 2.13 (the 2.12 build was dropped in 4.0),
# so on current Kafka the prefix is always 2.13. More on Scala's own versions:
#   /software/scala/versions/

See the Scala version history for what those 2.12 / 2.13 / 3.x numbers mean.

What Kafka version am I running?

Ask the CLI tools or the broker directly.

# The CLI tools print the Kafka version:
$ kafka-topics.sh --version              # e.g. 4.3.1 (Commit:...)
$ kafka-broker-api-versions.sh --bootstrap-server localhost:9092 --version

# The broker logs its version on startup:
#   INFO Kafka version: 4.3.1 (org.apache.kafka.common.utils.AppInfoParser)

# Confluent Platform users — the CP version is NOT the Kafka version:
$ confluent version                    # Confluent Platform (e.g. 8.x), which bundles
                                       # a specific Apache Kafka release under the hood

Install or run a version

Apache Kafka is a plain JVM tarball, plus community Homebrew and official Docker images.

# Tarball (requires Java 17+ for 4.x):
$ curl -O https://downloads.apache.org/kafka/4.3.1/kafka_2.13-4.3.1.tgz
$ tar -xzf kafka_2.13-4.3.1.tgz && cd kafka_2.13-4.3.1

# macOS (Homebrew):
$ brew install kafka

# Docker (official Apache image, KRaft mode — no ZooKeeper):
$ docker run -p 9092:9092 apache/kafka:4.3.1

# Downloads and supported releases:
#   https://kafka.apache.org/downloads

On Kafka 4.x there is no ZooKeeper to start — a single-node broker runs in KRaft mode out of the box.

The LinkedIn origin and the log as a first-class abstraction

Kafka was built at LinkedIn around 2010 by Jay Kreps, Neha Narkhede, and Jun Rao, to solve a problem the company had outgrown: moving huge streams of activity data (page views, metrics, logs) between systems without a tangle of point-to-point pipelines. The name is a nod to the writer Franz Kafka — Kreps liked the idea of a system "optimized for writing." It was open-sourced in 2011, entered the Apache Incubator that year, and graduated to a top-level Apache project in October 2012.

The idea that made Kafka more than a message queue was treating the append-only commit log as the core abstraction — an ordered, replayable, durable sequence of records that many consumers can read independently at their own position. Kreps laid this out in the widely read 2013 essay "The Log." That single design choice is why Kafka became infrastructure for event streaming, event sourcing, and stream processing rather than just A-to-B messaging — and why every feature that followed (Connect, Streams, exactly-once, tiered storage) is a layer on top of the log.

The API build-out — replication, Connect, Streams, exactly-once

Kafka's most consequential features all shipped during its 0.x years, each turning it into a broader platform. Intra-cluster replication in 0.8 (2013) was the reliability watershed: partitions gained replicas and leader election, so a broker could fail without losing data. That is the release that made Kafka safe for systems of record.

Kafka Connect (0.9, 2015) added a framework for streaming data in and out of external systems with reusable connectors, so Kafka became the hub of a data pipeline rather than one hop in it. Kafka Streams (0.10, 2016) put a full stream-processing library inside Kafka — joins, aggregations, and windowing as a client library, no separate cluster to run.

Then exactly-once semantics in 0.11 (2017) — the idempotent producer plus multi-partition transactions — closed the last correctness gap, letting a read-process-write pipeline commit its inputs and outputs atomically. It's a fair argument that 0.11 was a bigger release than the 1.0 that followed it a few months later; 1.0 mostly signaled that the project considered itself production-mature.

The KRaft transition — why ZooKeeper was removed

From the beginning, Kafka stored its cluster metadata — which brokers exist, which topics and partitions they hold, who the controller is — in Apache ZooKeeper, a separate distributed coordination service. That worked, but it meant every Kafka deployment was really two systems to run, secure, and reason about, and ZooKeeper became a scaling ceiling: the number of partitions a cluster could hold was bounded by how fast the controller could load metadata out of ZooKeeper.

KIP-500, first proposed in 2019, set out to replace ZooKeeper with KRaft — a built-in Raft consensus quorum where a set of Kafka controllers store the metadata as an event log inside Kafka itself. No external dependency, faster failover, and metadata that scales to millions of partitions. It was a foundational change to how Kafka runs, so it shipped deliberately over several years.

The milestones are version-pinned, which is why this page tracks them so precisely: KRaft was early access in 2.8 (2021), a fuller preview in 3.0, and production-ready for new clusters in 3.3 (2022, KIP-833). Migrating an existing ZooKeeper cluster took longer: the KIP-866 migration path was early access in 3.43.5 and production-ready in 3.6 (2023).

Kafka 3.9 (2024) is the pivotal bookend: the last release that supports ZooKeeper at all, and therefore the mandatory bridge release — a ZooKeeper cluster upgrades to 3.9, migrates to KRaft, and only then moves forward. Kafka 4.0 (March 2025) removed ZooKeeper entirely; 4.x is KRaft-only. So the practical answer to "do I still need ZooKeeper?" is a version boundary: yes through 3.9, no from 4.0.

Tiered storage, the new consumer protocol, and Queues

With ZooKeeper handled, the recent releases have reshaped the parts of Kafka developers touch most. Tiered storage (KIP-405, early access in 3.6, GA in 3.9) lets brokers offload older log segments to remote object storage, decoupling how much history you keep from how much local disk you buy.

The next-generation consumer rebalance protocol (KIP-848, early access in 3.7, GA in 4.0) moved partition-assignment logic from the client group leader to the broker and made rebalances incremental, ending the "stop-the-world" pauses that hit large consumer groups every time a member joined or left.

And Queues for Kafka (Share Groups, KIP-932, early access in 4.0, preview in 4.1, production-ready in 4.2) gave Kafka true queue semantics for the first time: multiple consumers cooperatively processing records from the same partitions with per-record acknowledgement, so the classic work-queue pattern no longer needs a partition per worker.

Confluent and the Community License

Kafka's three creators left LinkedIn in 2014 to found Confluent, the company that drives much of Kafka's development and sells Confluent Platform (a Kafka distribution with extras) and Confluent Cloud (a managed service). Confluent went public on NASDAQ (ticker CFLT) in 2021 and stopped being an independent company on March 17, 2026, when IBM completed its acquisition at $31 per share in cash — an enterprise value of roughly $11 billion — and the stock was delisted from Nasdaq. None of that changes what this page tracks: Apache Kafka remains an Apache Software Foundation project under Apache 2.0, and Confluent, now an IBM subsidiary, is its largest contributor, not its owner.

The licensing wrinkle worth keeping straight: in December 2018, Confluent moved several of its own Confluent Platform add-ons — ksqlDB, the Schema Registry, REST Proxy, and some connectors — from Apache 2.0 to the source-available Confluent Community License. The motive was the same one behind MongoDB's SSPL and Redis's and Elastic's later relicensings: stop hyperscalers from selling the software as a service without contributing back. The CCL lets you use, modify, and redistribute the code but not offer it as a competing managed service, and the OSI has not certified it — so those components are source-available, not open source. None of this touches Apache Kafka, which this page tracks and which stays Apache 2.0. When people ask "is Kafka open source?" the answer is a clean yes; the CCL question is really a question about Confluent's extras.

Sources: kafka.apache.org/downloads; the Apache Kafka release announcements; the Kafka Improvement Proposals (KIPs) — KIP-500 (KRaft), KIP-833 (KRaft production-ready), KIP-866 (ZooKeeper→KRaft migration), KIP-405 (tiered storage), KIP-848 (consumer protocol), KIP-932 (queues); the Confluent Community License; the IBM–Confluent acquisition announcement; and per-release release notes and contemporaneous reporting cited inline. Last updated August 11, 2026.

Mungomash LLC · More software pages