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 — plus 3.9, kept alive as the final ZooKeeper bridge release; older minors are effectively end-of-life. Longer commercial support (up to three years) is available through Confluent Platform. As of July 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 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 23, 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. Latest patch 4.3.1 (Jun 23, 2026) fixes a Kafka Streams RocksDB native-memory leak. 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), previewed in 4.0, 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 28, 2026).
Version
Kafka 4.1
KRaft-only
Sep 2, 2025
Queues / Share Groups continue toward production; new Streams rebalance protocol (KIP-1071, built on KIP-848); further consumer-protocol and KRaft hardening.
  • Share Groups progressed — the Queues-for-Kafka work (KIP-932) advanced from its 4.0 preview toward the production readiness it reached 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.
  • Continued hardening of the KIP-848 consumer group protocol (GA'd in 4.0) and KRaft; incremental Connect and Streams improvements. 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) preview; Java 8/11 and Scala 2.12 dropped.
  • 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 (preview) — Share Groups (KIP-932) shipped as a preview, bringing queue-style cooperative consumption to Kafka for the first time (production-ready in 4.2).
  • Toolchain floor raised — brokers and tools now require Java 17 (clients Java 11); the Scala 2.12 build was dropped, leaving Scala 2.13 as the only broker build. 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 receives extended patch releases (latest 3.9.2, Feb 2026) for exactly this reason.
  • 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 26, 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 26, 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 3, 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 13, 2023
ZooKeeper mode deprecated; ZooKeeper→KRaft migration in early access; KRaft recommended for new clusters; legacy MirrorMaker (MM1) removed.
  • ZooKeeper deprecated — with KRaft production-ready for new clusters (since 3.3) and a migration path in preview, 3.5 formally deprecated ZooKeeper mode, signaling the direction of 4.0.
  • Legacy MirrorMaker (MM1) removed in favor of MirrorMaker 2; Connect and Streams updates.
Version
Kafka 3.4
KRaft transition
Feb 6, 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
Sep 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). The 3.3.1 patch (Oct 3, 2022) was the recommended build.
  • KRaft feature catch-up (partition reassignment, SCRAM in KRaft coming in later minors); general performance and stability work.
Version
Kafka 3.2
KRaft transition
May 9, 2022
KRaft authorizer (StandardAuthorizer) for ACLs; log4j2 migration begins; idempotent producer refinements.
  • ACLs in KRaft — the StandardAuthorizer brought ACL support to KRaft mode, another parity step toward removing ZooKeeper.
  • Continued reliability and Streams / Connect improvements.
Version
Kafka 3.1
KRaft transition
Jan 21, 2022
Incremental KRaft, Connect, and Streams improvements; broker/consumer metrics additions.
  • A maintenance-and-refinement minor on the road to KRaft parity: metrics, Streams, and Connect improvements, with KRaft still in preview.
Version
Kafka 3.0
KRaft transition
Sep 20, 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 18, 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 19, 2020
Early KRaft groundwork (self-managed quorum controller, preview); TLS 1.3 support; throttling and quota improvements.
  • Groundwork for KRaft (the self-managed metadata quorum) landed here in preview form ahead of 2.8's early access; TLS 1.3 support; SASL and quota refinements.
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 14, 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 14, 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).
  • Fetch-from-closest-replica (KIP-392) for rack-aware, lower-latency reads.
Version
Kafka 2.3
ZooKeeper
Jun 24, 2019
Connect incremental cooperative rebalancing; Kafka Streams in-memory suppression; broker reconnect improvements.
  • Incremental cooperative rebalancing for Connect; Streams suppression operator; operational and reliability fixes.
Version
Kafka 2.2
ZooKeeper
Mar 22, 2019
Consumer group management improvements; default partitioner sticky behavior; CLI and admin refinements.
  • Consumer group and admin-client improvements; incremental Streams and Connect work.
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 28, 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
Oct 31, 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.

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, preview in 4.0, 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. Apache Kafka itself remains an Apache Software Foundation project under Apache 2.0; Confluent is the largest contributor, not the 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; and per-release release notes and contemporaneous reporting cited inline. Last updated July 2026.

Mungomash LLC · More software pages

Published 2026-07-03 by Hyperion — New page: verified 4.3 current (4.3.1 latest), KRaft-only since 4.0, ZooKeeper timeline, Apache-2.0/CCL boundary