2009 – 2026

MongoDB Versions

Every release of the MongoDB server — from the 10gen 1.0 release in 2009 through the 8.x line. MongoDB 8.0 (October 2024) is the current major; 8.3 (May 2026) is the latest quarterly Rapid Release on top of it. With ship dates, support/EOL state, and the headline changes per major version — the storage-engine arc (MMAPv1 → WiredTiger), the transactions arc (replica-set then sharded ACID), and the October 2018 relicensing from AGPL to the SSPL that this page exists to explain.

The license behind every release since 4.0

Is MongoDB open source? The SSPL relicensing.

On October 16, 2018, MongoDB relicensed the Community Server from the GNU Affero GPL v3 to its own Server Side Public License (SSPL) v1. SSPL keeps almost all of the AGPL's text but rewrites Section 13: anyone who offers MongoDB as a service to third parties must release the entire source of that service — management layer, APIs, and all — under the SSPL. The goal was to stop cloud providers from selling MongoDB-as-a-service without contributing back.

The catch is the “open source” question. MongoDB submitted SSPL to the Open Source Initiative for certification, then withdrew the submission in 2019; the OSI never approved it, holding that the Section 13 condition discriminates against a field of endeavor and so fails the Open Source Definition. So by the OSI's bar, MongoDB is source-available, not open source. Debian, Fedora, and Red Hat Enterprise Linux dropped MongoDB from their repositories over the license. Notably, only the server changed: the official drivers (PyMongo and the Node, Java, Go, and C# drivers) stay Apache 2.0. AWS answered in January 2019 with Amazon DocumentDB, a MongoDB-API-compatible managed service of its own. The change took effect mid-4.0.x — see the 4.0 row and the divider below it.

Era & support

Era

10gen (1.x – 2.x) — 2009–2014, the MMAPv1 era before WiredTiger
3.x — 2015–2017, the WiredTiger storage-engine era
4.x — 2018–2020, multi-document ACID transactions land
5.0+ — July 2021 onward, the yearly-major / cloud-first era

Support

Current — the latest GA major line
Maintained — within its support window, receiving patch releases
EOL — past its end-of-life date; no further updates

Since 5.0, MongoDB ships one yearly major (8.0, 7.0, 6.0…) plus quarterly Rapid Releases (8.1, 8.2, 8.3…) that fold into the next yearly major. The table below tracks the yearly majors; the current Rapid Release is called out in the top row. Major releases get a long support window (extended to 4 years for 7.0 and 5 years for 8.0); EOL dates follow the published software lifecycle schedule. Rapid Releases were Atlas-only until 8.2, when they became downloadable for self-managed Community / Enterprise too.

MongoDB version table

Version
MongoDB 8.0
5.0+
Current
EOL Oct 2029
Oct 2024
The performance major — large throughput and scaling gains; Queryable Encryption range queries; current line. Latest Rapid Release: 8.3 (May 2026).
  • “Raising the bar” on performance — MongoDB billed 8.0 as its fastest release ever: substantially faster reads and bulk writes, lower-latency time-series queries, and reduced memory use, with much of the gain from a rewritten internal query architecture. See the 8.0 engineering post.
  • Queryable Encryption range queries — the encrypted-field feature that shipped equality-only in 7.0 gained range query support, so encrypted numeric and date fields can be filtered server-side without the server ever seeing plaintext.
  • Sharding and resharding — faster, less disruptive resharding; improved default config and balancing; better horizontal-scale behavior on large clusters.
  • Rapid Releases on the 8.x line8.1 (Jun 2025) and 8.2 (Sep 2025) and 8.3 (May 2026, latest 8.3.4) are the quarterly Rapid Releases. Since 8.2 they are downloadable for self-managed Community / Enterprise, not Atlas-only. 8.3 added a public preview of Search and Vector Search for self-managed MongoDB, plus expanded query expressions.
  • Support window: 8.0's lifecycle was extended to five years (EOL Oct 2029). Latest 8.0 patch is 8.0.26 (Jun 2026). Confirm the live tip at the release-notes index.
Version
MongoDB 7.0
5.0+
Maintained
EOL Aug 2027
Aug 2023
Queryable Encryption GA; compound wildcard indexes; approximate counts; sharding and time-series improvements.
  • Queryable Encryption GA — the headline feature: encrypt selected fields client-side and still run equality queries on them, with the server never decrypting. The first general-availability database feature of its kind, after a 6.0 preview.
  • Compound wildcard indexes — combine a wildcard index with regular index fields, for flexible-schema collections where you index unknown sub-fields alongside known ones.
  • Approximate document counts via $count path improvements; $shardedDataDistribution stage; better time-series performance and bucketing.
  • Longer lifecycle — 7.0 was the first major to get an extended support window (four years, EOL Aug 2027) under MongoDB's longer-lifecycles policy. Latest patch 7.0.37 (Jun 2026).
Version
MongoDB 6.0
5.0+
EOL
Jul 2025
Jul 2022
Queryable Encryption preview; Cluster-to-Cluster Sync (mongosync); time-series densify / fill; change-stream improvements.
  • Queryable Encryption (preview) — the first public look at encrypted-and-queryable fields, which would reach GA in 7.0.
  • Cluster-to-Cluster Sync — the new mongosync tool for continuous replication between two separate clusters (migrations, DR, hybrid topologies).
  • Time-series maturity$densify and $fill for gap-filling sparse series; secondary and compound indexes on time-series collections; better query performance.
  • Change-stream improvements (pre- and post-images of modified documents); initial sync by file copy; new aggregation operators ($dateAdd, $dateSubtract, percentile accumulators). EOL'd Jul 2025; latest patch 6.0.29.
Version
MongoDB 5.0
5.0+
EOL
Oct 2024
Jul 2021
Time-series collections; live resharding; the Versioned API; and the yearly-major + quarterly Rapid Release versioning scheme.
  • The versioning-scheme change — 5.0 introduced the model the project still uses: one numbered major per year, plus quarterly Rapid Releases (5.1, 5.2, 5.3…) for incremental features. See the divider note and the versioning history below.
  • Time-series collections — a first-class collection type optimized for timestamped data, with automatic bucketing and columnar-style storage. A direct answer to the InfluxDB / TimescaleDB workloads.
  • Live resharding — change a collection's shard key on a running cluster without downtime, fixing one of the oldest operational sharp edges in MongoDB sharding.
  • Versioned API — pin your application to a stable API version so a server upgrade can't silently change query behavior; the foundation for safe rolling upgrades.
  • Default majority write concern; native window functions ($setWindowFields); $dateTrunc; long-running snapshot queries. EOL'd Oct 2024; latest patch 5.0.34.
Version
MongoDB 4.4
4.x
EOL
Feb 2024
Jul 2020
Refinable shard keys; hedged reads; union aggregation ($unionWith); mirrored reads; resumable initial sync.
  • Refinable shard keys — add suffix fields to an existing shard key to improve distribution without a full reshard. The pragmatic predecessor to 5.0's live resharding.
  • $unionWith — combine results from multiple collections in a single aggregation pipeline, MongoDB's answer to SQL UNION.
  • Hedged reads (send a read to two replicas, take the first answer) and mirrored reads (warm secondaries' caches) for lower tail latency; resumable initial sync that survives a transient network blip.
  • Officially a “dot” release rather than a new whole number — the last before 5.0 reset the cadence. EOL'd Feb 2024; latest patch 4.4.31.
Version
MongoDB 4.2
4.x
EOL
Apr 2023
Aug 2019
Distributed (sharded) transactions; client-side field-level encryption; wildcard indexes; $merge. MMAPv1 storage engine removed.
  • Distributed multi-document transactions — ACID transactions extended from replica sets (4.0) to sharded clusters. The completion of the multi-document-transaction story.
  • MMAPv1 removed — the original storage engine was deprecated in 4.0 and removed entirely in 4.2; WiredTiger is now the only on-disk engine (plus the Enterprise in-memory engine). The common “why did my upgrade change behavior” cause for old deployments. See the storage-engine history.
  • Client-side field-level encryption — automatic, per-field encryption performed by the driver, with keys the server never sees; the precursor to Queryable Encryption.
  • Wildcard indexes for unknown/arbitrary field names; on-demand materialized views via $merge; retryable reads on by default; $set / $unset aggregation stages. EOL'd Apr 2023; latest patch 4.2.25.
October 16, 2018 — The AGPL → SSPL relicensing. Releases above this divider (4.2 and later) were born under the Server Side Public License. Releases below it shipped originally under the GNU Affero GPL v3 — though 4.0's later patch releases (from 4.0.4, November 2018) and every version since carry the SSPL. The OSI never certified SSPL as open source; see the callout above and the SSPL history.
Version
MongoDB 4.0
4.x
EOL
Apr 2022
Jun 2018
Multi-document ACID transactions (replica sets); SCRAM-SHA-256; type conversions; non-blocking secondary reads. The relicensing landed mid-4.0.x.
  • Multi-document ACID transactions — the long-awaited headline feature: atomic transactions across multiple documents and collections on a replica set. (Sharded clusters followed in 4.2.) It answered the most common “but MongoDB has no transactions” objection of the prior decade.
  • The SSPL relicensing happened here — 4.0 GA'd in June 2018 under AGPLv3, but on October 16, 2018 MongoDB relicensed the server to the SSPL; the 4.0.x patch releases from 4.0.4 onward shipped under the new license. See the divider above and the SSPL callout.
  • Type conversions in the aggregation pipeline ($convert, $toInt, …); SCRAM-SHA-256 auth; non-blocking secondary reads; 40% faster shard migrations.
  • EOL'd Apr 2022; latest patch 4.0.28.
Version
MongoDB 3.6
3.x
EOL
Apr 2021
Nov 2017
Change streams; client sessions; retryable writes; JSON Schema validation; $expr / $lookup with pipelines. Localhost binding by default.
  • Change streams — subscribe to a stream of real-time changes to a collection, database, or cluster, without tailing the oplog by hand. The foundation for event-driven MongoDB apps.
  • Retryable writes and client sessions — the driver automatically retries a write that failed due to a transient network or election event; sessions are also the substrate transactions are built on in 4.0.
  • Security: bind to localhost by default — new installs no longer listen on all interfaces out of the box, a direct response to years of exposed-MongoDB data-breach headlines.
  • JSON Schema document validation; $expr (use aggregation expressions in queries) and $lookup with sub-pipelines; array update operators. EOL'd Apr 2021.
Version
MongoDB 3.4
3.x
EOL
Jan 2020
Nov 2016
Views; decimal128 type; collation; sharded $lookup / $graphLookup; faster balancer; zone sharding.
  • Read-only views — saved aggregation pipelines exposed as queryable collections.
  • decimal128 — an exact decimal numeric type for financial data, fixing the floating-point-rounding problem of storing money in doubles.
  • Collation for language-aware string comparison and sorting; $graphLookup for recursive graph traversal in the aggregation pipeline.
  • Zone sharding (data locality by tag); elections and replica-set failover made much faster; config servers required to be a replica set. EOL'd Jan 2020.
Version
MongoDB 3.2
3.x
EOL
Sep 2018
Dec 2015
WiredTiger becomes the default storage engine; $lookup (left outer join); document validation; partial indexes; replica-set config servers.
  • WiredTiger is now the default — introduced as an option in 3.0, WiredTiger became the default storage engine in 3.2, bringing document-level concurrency and compression to every new deployment. MMAPv1 remained selectable until its removal in 4.2.
  • $lookup — the first left-outer-join in the aggregation pipeline, softening the “you can't join in MongoDB” critique.
  • Document validation rules at the collection level (pre-JSON-Schema); partial indexes (index only documents matching a filter); $sample; text-search and numeric-aggregation improvements.
  • EOL'd Sep 2018.
Version
MongoDB 3.0
3.x
EOL
Feb 2018
Mar 2015
WiredTiger storage engine introduced; pluggable storage-engine API; document-level concurrency; the modern-era boundary. (The release that 2.8 was renamed to.)
  • WiredTiger arrives — from MongoDB's December 2014 acquisition of WiredTiger Inc. (whose founders had built Berkeley DB). It brought document-level concurrency control in place of MMAPv1's database- / collection-level locking, plus native compression — often a 7–10× write-throughput improvement on contended workloads. This is the boundary between legacy and modern MongoDB.
  • Pluggable storage-engine API — the architecture that let WiredTiger, MMAPv1, and the Enterprise in-memory engine coexist behind one interface.
  • The version that skipped 2.8 — the release was developed as 2.8 and renamed 3.0 at the last minute to signal how large a change WiredTiger was. Rows below are folded into the pre-3.0 collapsible, since 3.0 is the modern-era boundary.
  • Ops Manager launched alongside; faster replica-set failover. EOL'd Feb 2018.
Version
Pre-3.0 (1.x – 2.x)
10gen
EOL
2009 – 2014
The 10gen lineage: 1.0 (2009) through 2.6 (2014), on the original MMAPv1 storage engine. Replica sets, auto-sharding, and the aggregation framework all land here. Included for completeness.

MongoDB began at 10gen (later renamed MongoDB, Inc.). Version 1.0 shipped in August 2009, built around BSON documents, a flexible schema, and the memory-mapped MMAPv1 storage engine. These releases predate the WiredTiger / modern-era boundary at 3.0 and are listed here rather than as full rows:

  • 1.0 (Aug 2009) — first GA: BSON documents, ad-hoc queries, master–slave replication.
  • 1.6 (Aug 2010) — replica sets and auto-sharding reach production, the two features that defined MongoDB's scale-out story.
  • 1.8 (Mar 2011) — journaling for crash recovery.
  • 2.0 (Sep 2011) — index and replication performance; concurrency improvements.
  • 2.2 (Aug 2012) — the aggregation framework ($match / $group / $project pipelines), MongoDB's analytics workhorse.
  • 2.4 (Mar 2013) — text search and 2dsphere geo indexes; hashed shard keys; the V8 JavaScript engine.
  • 2.6 (Apr 2014) — query-system rewrite, bulk write operations, index intersection, $out; the last major before WiredTiger.

All of the above used MMAPv1 with database- or (from 2.2) collection-level locking. None receives updates; nothing here is what you would install today. The 2009 origin and the document model are covered in the history below.

Click any row to expand. Each row has a stable id for sharing — e.g. /software/mongodb/versions/#mongodb-8-0, #mongodb-4-2, #mongodb-pre-3-0. Per-version release notes and the live lifecycle table live at mongodb.com/docs/manual/release-notes and the lifecycle schedule.

The 2009 origin at 10gen and the document model

MongoDB began inside 10gen, a New York startup founded in 2007 by Dwight Merriman, Eliot Horowitz, and Kevin Ryan — veterans of the ad-tech company DoubleClick. Their original plan was a platform-as-a-service; MongoDB was the database component, and when the platform didn't take off the database did. The name comes from “humongous.” Version 1.0 shipped in August 2009.

The core idea was the document model: instead of rows in fixed-schema tables, MongoDB stores BSON (binary JSON) documents with a flexible schema, so a record can be a nested object that maps cleanly onto how application code already represents data. Combined with built-in horizontal sharding and replica sets (both production-ready by 1.6 in 2010), that model made MongoDB the default face of the “NoSQL” movement of the early 2010s. 10gen renamed itself MongoDB, Inc. in 2013, and the company went public on NASDAQ (ticker MDB) in October 2017.

The storage-engine arc — MMAPv1 to WiredTiger

For its first six years MongoDB ran on MMAPv1, a storage engine built on memory-mapped files. It was simple and fast for reads, but its concurrency model was its defining limit: a single global write lock at first, relaxed to database-level locking in 2.2 and never finer than that. Under write-heavy, multi-collection workloads, MMAPv1 became the bottleneck everyone hit.

In December 2014 MongoDB acquired WiredTiger Inc., whose founders Keith Bostic and Michael Cahill had previously built Berkeley DB. WiredTiger shipped as an option in 3.0 (March 2015) and became the default in 3.2 (December 2015). It brought document-level concurrency control and native compression, frequently a 7–10× improvement on contended write workloads. WiredTiger is the reason 3.0 is treated as the boundary between legacy and modern MongoDB.

MMAPv1 was deprecated in 4.0 and removed entirely in 4.2 (August 2019). Today the on-disk engine is always WiredTiger; MongoDB Enterprise additionally offers an in-memory engine for latency-sensitive workloads. An old deployment that “behaved differently after upgrading” almost always crossed the MMAPv1 → WiredTiger line.

The transactions arc — replica-set then sharded ACID

For most of its first decade, MongoDB's answer to “does it have transactions?” was “single-document operations are atomic, design your documents so you don't need more.” That was a real constraint, and a frequent reason teams chose a relational database instead.

MongoDB 4.0 (June 2018) changed the answer with multi-document ACID transactions across a replica set, built on the client-sessions machinery added in 3.6. 4.2 (August 2019) extended transactions to sharded clusters, completing the story. The feature was deliberately staged — replica-set first, then distributed — and it removed the single most-cited objection to using MongoDB for systems of record. (Best practice is still to model around the document so transactions are the exception, not the rule.)

The 5.0 versioning-scheme change and Rapid Releases

Through 4.x, MongoDB shipped a new numbered release every roughly 12–18 months. MongoDB 5.0 (July 2021) replaced that with a faster, more predictable cadence: one yearly Major Release (5.0, 6.0, 7.0, 8.0) plus quarterly Rapid Releases (5.1, 5.2, 5.3…) that deliver incremental features between majors and then fold into the next major.

Rapid Releases were originally available only inside MongoDB Atlas, MongoDB's managed cloud service — not as downloadable server builds. That changed with 8.2 (September 2025), after which Rapid Releases are downloadable for self-managed Community and Enterprise deployments too. So as of mid-2026 the current major line is 8.0 (long-term supported through October 2029), while the current downloadable tip is the 8.3 Rapid Release (May 2026). The practical upshot: the “current version” number drifts roughly every quarter, faster than a once-a-year database like PostgreSQL.

The October 2018 SSPL relicensing

By 2018, MongoDB's biggest commercial threat wasn't another database — it was cloud providers offering MongoDB as a managed service and capturing the revenue without contributing to the project. The server had been licensed under the GNU Affero GPL v3, whose Section 13 was meant to cover exactly the network-service case, but MongoDB argued its scope was ambiguous and untested in court.

On October 16, 2018, MongoDB issued the Server Side Public License. SSPL copies most of the AGPL but rewrites Section 13: offer the functionality of the software as a service to third parties, and you must release the complete source of the service you use to make it available — management software, APIs, monitoring, the lot — under SSPL. In practice that is an unmeetable condition for a hyperscaler, which is the point.

MongoDB submitted SSPL to the Open Source Initiative for certification and faced sustained objection on the OSI's license-review list that the condition discriminated against a field of endeavor, violating the Open Source Definition. MongoDB withdrew the submission in 2019; SSPL has never been OSI-approved. The accurate description of MongoDB today is “source-available”, not “open source.” Debian, Fedora, and Red Hat Enterprise Linux removed MongoDB from their package repositories over the license — which is why, to this day, you install MongoDB from MongoDB's own apt/yum repositories rather than your distro's, and why Homebrew serves it from a dedicated mongodb/brew tap rather than core.

Two things are worth keeping straight. First, only the server was relicensed; the official client drivers (PyMongo, and the Node, Java, Go, and C# drivers) remain Apache 2.0, so application code that merely talks to MongoDB is unaffected. Second, the move triggered a competitive response: AWS launched Amazon DocumentDB in January 2019, a service that emulates the MongoDB API on a different engine, sidestepping the license entirely. MongoDB's relicensing became the template a wave of other infrastructure companies followed — Elastic, Redis, HashiCorp, and others all later adopted source-available licenses for similar reasons. For the canonical text and MongoDB's own framing, see the SSPL and its FAQ.

MongoDB Atlas and the cloud-first turn

The same logic that drove the SSPL drove MongoDB's product strategy. In 2016 the company launched MongoDB Atlas, a fully managed database-as-a-service running on AWS, Google Cloud, and Azure. Rather than fight the cloud as a distribution channel, MongoDB became a cloud vendor itself — and Atlas grew into the majority of the company's revenue.

That turn shapes the version story directly. Rapid Releases debuted as an Atlas-only feature; several capabilities land in Atlas before the downloadable server; and features like Atlas Search and Atlas Vector Search were managed-service exclusives before 8.3 brought a self-managed preview of search and vector search in 2026. This page deliberately tracks the Community / Enterprise server version line — the thing you download and run — and treats Atlas, Compass, and Ops Manager as separate product tracks mentioned only where they intersect the server's history.

Find your version — in mongosh or the shell

The browser cannot detect what version of MongoDB you're running — there's no header or fingerprint that exposes it. Run one of these in your shell or in mongosh to see your real install.

What's running?

Print the server version, the shell version, and the build details.

$ mongod --version                     # server (mongod) version + build
$ mongosh --version                    # shell (mongosh) version

# Ask a running server directly:
$ mongosh --eval "db.version()"        # e.g. 8.3.4
$ mongosh --eval "db.serverBuildInfo().version"

# Inside mongosh:
test> db.version()
test> db.adminCommand({ buildInfo: 1 }).version

Pin a project to a specific MongoDB

Most projects pin via the official Docker image tag; the major (8.0) floats patches, an exact tag (8.0.26) freezes them.

# docker-compose.yml
services:
  db:
    image: "mongo:8.0"                  # floats patch releases of 8.0
    image: "mongo:8.0.26"               # pinned exact
    image: "mongo:8.3"                  # current Rapid Release tip

# Set the cluster's behavior compatibility after an upgrade:
test> db.adminCommand({ setFeatureCompatibilityVersion: "8.0" })

Upgrade one major at a time (e.g. 6.0 → 7.0 → 8.0) and advance the featureCompatibilityVersion only after the binaries are stable.

Install or upgrade a version

Because of the SSPL relicensing, MongoDB isn't in the distro repos — you add MongoDB's own repository (or its Homebrew tap).

# macOS (MongoDB's Homebrew tap, not core)
$ brew tap mongodb/brew
$ brew install mongodb-community@8.0
$ brew services start mongodb-community@8.0

# Debian / Ubuntu (MongoDB's own apt repository)
$ sudo apt-get install -y mongodb-org

# Fedora / RHEL (MongoDB's own yum/dnf repository)
$ sudo dnf install -y mongodb-org

# Docker (no repo setup needed)
$ docker run -d -p 27017:27017 mongo:8.0

# Repo setup + Community Server download:
# https://www.mongodb.com/try/download/community

Connect — and the Atlas version note

On Atlas (the managed service) you don't install a binary; you pick the major version per cluster and Atlas runs and patches it for you.

# Connect with mongosh (the version is the server's, not the shell's)
$ mongosh "mongodb+srv://cluster0.example.mongodb.net/" --username alice

# Then read the server version of the cluster you're on:
atlas> db.version()

# Atlas cluster version is set in the UI / API per cluster:
#   Atlas console - Cluster - Configuration - Version
# Drivers are versioned independently and stay Apache-2.0;
# check compatibility at mongodb.com/docs/drivers/

A driver released more than 3 years after a server version's EOL won't support that server — see the lifecycle schedule.

Sources: mongodb.com/docs release notes; software lifecycle schedule; the SSPL and its FAQ; the Open Source Initiative; github.com/mongodb/mongo; and per-version release notes and contemporaneous reporting cited inline. Last updated June 2026.

Mungomash LLC · More software pages

Last refreshed 2026-06-27 by Hyperion — New MongoDB versions page; SSPL relicensing