Tarantool End of Life (EOL) Dates and End of Support (EOS) Dates
Tarantool end of life (EOL) and end of support (EOS) dates: 12 Tarantool versions have reached EOL, including Tarantool 3.2 (EOL date: Aug 26, 2026) — no longer receiving security updates or patches. Tarantool 3.4 reaches its End of Support date on Apr 14, 2027 — plan your upgrade path now. Tarantool 3.9.0 is the current supported release — 7 versions in active support. Also see ArangoDB EOSL information for related end-of-life information.
Currently Supported Tarantool Releases - Active EOS/EOSL Support (7)
| Release | Released | Support Status | Latest | LTS |
|---|---|---|---|---|
| 3.9 | (4 weeks and 1 day ago) | Active | 3.9.0 (4 weeks and 1 day ago) | - |
| 3.8 | (4 months ago) | Active | 3.8.2 (4 weeks and 1 day ago) | - |
| 3.7 | (6 months ago) | Active | 3.7.2 (4 weeks and 1 day ago) | - |
| 3.6 | (11 months ago) | Active | 3.6.4 (4 months ago) | - |
| 3.5 | (1 year and 2 months ago) | Active | 3.5.2 (5 months ago) | - |
| 3.3 | (1 year and 11 months ago) | (in 1 week and 1 day) | 3.3.5 (5 months ago) | - |
| 2.11 (LTS) | (3 years and 5 months ago) | (in 6 months) | 2.11.11 (2 days ago) | LTS |
Tarantool Releases Nearing End of Life - Support Ending Soon (1)
| Release | Released | Support Status | Latest | LTS |
|---|---|---|---|---|
| 3.4 | (1 year and 7 months ago) | (in 4 months) | 3.4.2 (1 year ago) | - |
Tarantool End of Life (EOL) Releases - No Longer Supported (12)
| Release | Released | Support Status | Latest | LTS |
|---|---|---|---|---|
| 3.2 | (2 years and 2 months ago) | (2 months ago) | 3.2.4 (5 months ago) | - |
| 3.1 | (2 years and 7 months ago) | (2 years and 2 months ago) | 3.1.2 (2 years and 2 months ago) | - |
| 3.0 | (2 years and 10 months ago) | (2 years and 7 months ago) | 3.0.2 (2 years and 7 months ago) | - |
| 2.10 | (4 years and 5 months ago) | (3 years and 2 months ago) | 2.10.8 (3 years and 2 months ago) | - |
| 2.8 | (5 years and 10 months ago) | (4 years and 6 months ago) | 2.8.4 (4 years and 6 months ago) | - |
| 2.7 | (6 years ago) | (5 years and 3 months ago) | 2.7.3 (5 years and 3 months ago) | - |
| 2.6 | (6 years and 4 months ago) | (5 years and 7 months ago) | 2.6.3 (5 years and 7 months ago) | - |
| 2.5 | (6 years and 7 months ago) | (5 years and 10 months ago) | 2.5.3 (5 years and 10 months ago) | - |
| 2.4 | (6 years and 10 months ago) | (6 years ago) | 2.4.3 (6 years ago) | - |
| 2.3 | (7 years and 3 months ago) | (6 years and 4 months ago) | 2.3.3 (6 years and 4 months ago) | - |
| 2.2 | (7 years and 7 months ago) | (6 years and 7 months ago) | 2.2.3 (6 years and 7 months ago) | - |
| 1.10 (LTS) | (8 years and 8 months ago) | (3 years and 5 months ago) | 1.10.15 (3 years and 9 months ago) | LTS |
The Tarantool end of life date depends on the release series you run, and series 3.3 reaches end of life (EOL) on 29 November 2026. Tarantool is an open source, in-memory database and Lua application server platform, and its release policy gives every series a fixed support window. This guide lists the date for each series, explains the rules behind it and shows you how to plan an upgrade.
Tarantool End of Life Dates by Release Series
Every series moves from active support to EOL on a published schedule, and the public release calendar is the quickest way to check where your version stands. The table below shows the status of each recent series as of late October 2026, so you can see at a glance which version of the software still receives fixes.
| Release series | First released | Support status | EOL date |
|---|---|---|---|
| 3.8, 3.7, 3.6, 3.5 | Aug 2025 to Jul 2026 | Supported | Not yet announced |
| 3.4 | 15 Apr 2025 | Supported | 14 Apr 2027 |
| 3.3 | 29 Nov 2024 | Supported | 29 Nov 2026 |
| 3.2 | 26 Aug 2024 | Ended | 26 Aug 2026 |
| 3.1 | 16 Apr 2024 | Ended | 26 Aug 2024 |
| 3.0 | 26 Dec 2023 | Ended | 16 Apr 2024 |
| 2.11 (LTS) | 24 May 2023 | Supported | 24 May 2027 |
| 2.10 | 22 May 2022 | Ended | 14 Sep 2023 |
| 1.10 (LTS) | 7 Mar 2018 | Ended | 24 May 2023 |
Series 2.11 is the long-term support release and carries four years of maintenance, which makes it the longest-lived option on the list. A feed in Atom and iCalendar formats and a JSON API on the public schedule page let you pull these dates into your own monitoring.
Supported Release Series Today
Series 3.5 through 3.8 are all in active support, together with 3.4, 3.3 and the 2.11 LTS series. Your version should be one of the latest patch numbers in its series, because a customer running an older patch gets no extra protection from the series still being supported.
Unsupported Versions That Already Reached EOL
Series 3.0, 3.1, 3.2, 2.10 and everything older are unsupported versions. The official EOL versions page keeps their release notes for reference only, so a bug found there will not be fixed in the same series.
Tarantool Release Policy and Version Lifecycle
The Tarantool release policy is built around release series, each with its own pre-release and release versions. A series is a sequence of development and production-ready versions that evolve toward a defined roadmap, with compatibility guarantees inside the series and toward other series. The intended support time for each series is at least two years from its first release. The policy follows a SemVer-style scheme, so the lifecycle of a series is easy to read from its version numbers.
A release version has gone through testing and adoption in internal projects until nobody doubted its stability. It has no known bugs in typical scenarios, and a major release shows no degradation from the previous series. Those stability rules are why a series can be trusted in production.
How a Release Version Is Labeled
Each label has three numbers, MAJOR.MINOR.PATCH. The first release of a series always ends in .0.0, and every later number tells you what changed.
Major, Minor and Patch Release Rules
- A major release opens a new series, adds features and may break backward compatibility with an older series, as in 3.0.0.
- A minor release adds a few features and keeps compatibility, as in 3.1.0.
- A patch release only fixes bugs from an earlier release, as in 3.0.2.
Pre-Release Versions Before the First Release
Pre-release builds are for testing and evaluation, never for production. A development build reflects the current state of work, an alpha version has only some of the planned features, and a beta version has all of them but may still carry a known bug. A release candidate has the same features as the last beta and is the right choice for a staging server. Stabilization starts with the first release candidate, and from then on the feature set does not change. None of these builds is covered by a support or EOL commitment, so run them only for evaluation.
Early Development Stage
The early development stage runs until the first major release. Features can still be added or removed while alpha and beta builds are published, and the series is not yet an object of any support promise. A series in this stage has no EOL date at all, because the support clock only starts with the first release.
End of Support Versus EOL Status
A series passes through four stages: early development, support, end of life and end of support. People often use the terms as synonyms, but the policy treats them as two separate dates, and the gap between them affects your plans for the whole series.
The Support Stage and What It Fixes
The support stage begins with the first release. During it the series receives only backward compatible changes, with all known security problems and degradations since the previous series being fixed. Whether a specific bug is fixed depends on its impact, the risk to backward compatibility and the effort of backporting a fix. New Linux distributions are added to the build infrastructure throughout the support period, and new features may arrive if they remain compatible.
What End of Life Means for a Series
A series reaches EOL when its last release is published, and it then gets no further updates. Modules, connectors and tools no longer carry a support guarantee for it. The policy adds a safeguard: a series cannot reach EOL until the vast majority of production environments covered by commitments and SLAs have moved to a newer series.
Why the EOS Date Follows the Support Period
The end of support (EOS) date comes after the EOL date. At EOS the vendor stops technical support and no longer answers support-related inquiries from customers, so the calendar is your signal to plan an upgrade before then.
Upgrading With Release Notes Before a Version Reaches EOL
Treat the EOL date as a deadline for the whole team, not just for the developer who owns the database. Start with the release notes of every series between yours and your target, because a major release can contain backward-incompatible changes that a patch release never has. Read the documentation on compatibility guarantees, then list the modules and connectors your application depends on and confirm each one supports the new series.
Back up your data first, then rehearse the move on a staging cluster that mirrors production. Replay real traffic, compare latency, confirm that all data is still readable, and check that your Lua code and stored procedures behave the same. If you are on a series with a near date, such as 3.3, moving within the 3.x line is usually the smallest step. If you value a longer window instead, the 2.11 LTS series runs until 24 May 2027, though you will eventually face the same decision again. Finally, subscribe to the schedule feed so that the next date never surprises you.
Tarantool Versions Explained: In-Memory Database and Lua Application Server
Knowing what the platform stores and runs tells you what an upgrade between versions puts at risk. It is released under the Simplified BSD license. As an in-memory system it keeps all data in RAM, so reads are fast, and it protects that data through write-ahead logging and snapshotting, so a restart does not lose it. Its size is limited by the RAM of the node, which is the trade-off of any in-memory design. The basic storage unit is a tuple, which plays the role of a row, and every tuple has a primary key plus optional secondary indexes. Replication is asynchronous, and the platform also offers an on-disk engine for databases larger than memory and an SQL interface. It ships with Debian, Fedora and Ubuntu, and other Linux, FreeBSD and macOS builds are available from the project. As a NoSQL, key-value capable platform it differs from classic stores, because your application logic runs inside the server in Lua. The way data is persisted and the Lua runtime are the two parts that most affect which versions you can safely move between, because they decide whether your stored data and your code both survive an upgrade.
Redis or Tarantool When a Version Reaches EOL
An EOL date sometimes prompts a bigger question: stay on Tarantool or move to Redis. Both are in-memory stores that work well as a cache, but they differ in several ways. Redis is a key-value data structure store with primary key access and a Lua stored procedure engine, while Tarantool supports documents, a relational model, any number of indexes and a Lua application server.
| Area | Redis | Tarantool |
|---|---|---|
| Indexes | Primary key only | Secondary indexes |
| Scaling | Redis Cluster sharding | Sharding in a cluster |
| Procedures | Lua scripts in Redis | Lua stored procedures |
Performance and Reliability Compared
Raw speed depends on the test, so measure your own workload rather than trusting a headline figure, and compare persistence and replication guarantees before choosing between an upgrade and a migration. For reliability, Redis and Tarantool both rely on replication and persistence, and both use sharding for scaling when hot data no longer fits in one node's RAM. A cache that restarts cold can take the main database down, so persistence matters for Redis as much as for Tarantool.
Data Model, Indexes and Transactions
Redis stores data structures under keys and offers no secondary indexes, whereas Tarantool tuples can carry several indexes of type TREE, hash, bitmap or R-tree. Transactions also differ in style: Tarantool runs cooperative multitasking without locks, and Redis executes commands on a single thread. That is the real migration cost of leaving Tarantool at EOL: if your application relies on indexes beyond the primary key, moving to Redis means redesigning the data.
Persistence, Replication and Connectors
Both products persist to disk and replicate to other nodes, yet Tarantool supports synchronous replication while Redis replication is asynchronous by default. Redis has a wider ecosystem of connectors, and Tarantool modules are distributed through LuaRocks. Before leaving Tarantool at EOL, verify replication behaviour and check that every client library your team uses exists for the target, since a missing connector is a larger cost than the migration itself. Redis wins on ecosystem breadth, while Tarantool wins when the application server and database must live together.