Release Schedule

Timeline of maintenance and support for Plone releases. Last major policy update: 2024-01-15.


  • All Plone 6 minor versions get security support until 2027-12-31, 5 years after Plone 6.0.0 was released.

  • Plone 6.0.x with Volto 16.x gets maintenance support until 2024-12-31, 2 years after Plone 6.0.0 was released. Use this for your site when your primary concern is stability.

  • Maintenance support for Plone 6.1.x stops once 6.2.0 is released. Maintenance for Plone 6.2.x stops once 7.0.0 is released. Use this for your site when you want the latest features and most modern approaches.

  • Plone 5.2.x is out of maintenance support. It gets security support until 2024-10-31. Older Plone versions are unsupported.

Plone release schedule in calendar format, explained in the table below it.



Python versions


Initial release

End of maintenance support

End of security support




end of life







end of life







end of life






2.7, 3.8

security support






maintenance support












Before we go to the release policy, we need some definitions.

Semantic versioning

We use semantic versioning for our releases and version numbering. Given a version number MAJOR.MINOR.PATCH, increment the:

  1. MAJOR version when we make incompatible API changes

  2. MINOR version when we add functionality in a backward compatible manner

  3. PATCH version when we make backward compatible bug fixes

Additional labels for pre-release and build metadata are available as extensions to the MAJOR.MINOR.PATCH format.
A SUB version may be created for security fixes.


  • Major release: 5.0.0 to 6.0.0

  • Minor release: 6.0.0 to 6.1.0

  • Patch release: 6.0.0 to 6.0.1

  • Sub release: 5.2.10 to states: “For this system to work, you first need to declare a public API.” For individual Plone packages, this is relatively straightforward:

  • If a change (either bugfix or feature) removes functionality, for example removing a Python module, it goes into a major version.

  • Dropping support for a Python version also means a new major version.

  • A new feature goes into a minor version.

  • Other changes go into a patch version.

For Plone as a whole, it is trickier, including for the main package that defines Plone on the backend, Products.CMFPlone. Since Plone stores its data in the ZODB (Zope Object Database), let’s treat it as our API:

  • If major functionality is removed (for example, Archetypes), functionality is changed in major ways (for example, resource registries), or a big upgrade to the database is needed (for example, Dexterity site root), this should go into a Plone major version. Add-ons likely need changes to work with a new Plone major version, and it may be hard or impossible to make one version of an add-on work across two Plone major versions.

  • If you cannot go back to a previous Plone version without restoring a ZODB backup, it should go in a minor version. For example in a minor version you can move a dependency from Products.CMFPlone to Plone, add a new registry interface, or change the way some data is stored or retrieved. Add-ons may need changes to work with a new Plone minor version, but the changes should be minor, and it should be easy to make an add-on compatible with all minor versions that have the same major version.

  • If a change can be reverted without needing to restore a ZODB backup, it can go in a patch version. For example, when you upgrade your site to Plone 6.0.8, you notice a problem with one of the changes, so you revert the code to Plone 6.0.7. This should work, although you may get a warning that there is a mismatch in versions between your Plone site and the code. Add-ons should not need changes to work with a new Plone patch version.

  • If security fixes are released for individual packages, the updated versions may go in a Plone sub version, for example

For packages that live “above” Products.CMFPlone, we are more lenient with the rules. For example in Plone 6.0.8 we upgraded plone.restapi from version 8 to version 9, which removed some long deprecated code that was in the way of progress.

State of a version

A version can be in one of these states:

  • Development: Also called "pre-release". For a major version, breaking changes may be added. For a minor version, new features are developed. Alpha and beta versions and release candidates are released in this state, and would follow a numbering pattern of, for example, 6.0.0a1, 6.0.0b1, or 6.0.0rc1.

  • Maintenance support: A final version has been released. Security and other bug fixes and small new features are added in patch versions. Around the end of maintenance support, a last patch version will be released. Releases in this state, for example, would have a version numbering designation moving, for example, from 6.0.0 to 6.0.1.

  • Security support: Plone security fixes for individual packages will be made available for this version. At the discretion of the Release Team and Security Team, either a patch release or a sub release of Plone will be made. The version numbering designation would move, for example, from 6.0.0 to (sub release) or 6.0.1 (patch release).

Release Policy

Security support

Each major version gets security support for 5 years from the date of its release.

The security support for each minor version within one major version ends at the same date as the security support for the major version.

Only the latest patch release within a minor version gets security support. Security fixes may work on an older patch release, but we cannot guarantee this.

Maintenance support

The first minor version gets maintenance support for two years from the date of its release.

The second and later minor versions get maintenance support until the next minor or major version is released.


The development of the Volto frontend is decoupled from the Plone releases to be able to move faster. Plone REST API provides an abstraction layer that spans across multiple Plone versions, allowing the use of more recent Volto versions, even with older Plone backend versions.

Volto has its own release cycle and release manager (Victor Fernandez de Alba). Volto uses semantic versioning to indicate breaking changes.

Plone 6.0.0 was released with Volto 16.4.0. For the Volto 16 major version, the same support policies apply as for the Plone 6.0 minor version, so Volto 16.* gets maintenance support until 2024-12-31 and security support until 2027-12-31.

Which version should I use?

The most important consideration is that you use a version that has security support.

On a production site, you should use a final version, for example 6.0.0 or 6.1.3, and not an alpha, beta, or release candidate version. All final versions are considered stable, and fit for production use.

Always use the most recent patch version within a minor version, as older patch versions have no guaranteed security support.

If you want the greatest stability, you should use the first minor version. From the date of the first final release, for example 6.0.0, this version has 5 years of security support and 2 years of maintenance support.

If you want the most features, you should use the latest minor version, and keep upgrading to the next minor version once it is released.

Changes from the previous Release Policy

This section summarizes the changes from the previous Release Policy:

  • Support for Volto (the default frontend in Plone 6) is integrated in the Plone release policy.

  • Instead of dropping security support on all but the last minor version once the next major version is released, we give security support to all minor versions within a major release until the same end date.

  • The first minor version, for example 6.0.x, now has longer maintenance support, with a fixed duration of 2 years from the date of its release.

  • Other minor releases (for example 6.1.x and 6.2.x) will drop maintenance support when the next minor or major version is final, instead of having an overlap. They get security support during the same period as the first minor version.

Release cadence

We aim to release a new major version roughly every 3 years.

We aim to release a new minor version roughly every 12-18 months. We will likely speed this up, starting with 6.1. We expect three or four minor versions, for example Plone 6.0, 6.1, and 6.2.

We aim to release a new patch version of a maintained Plone version every one or two months.


No single team is responsible for fixing bugs or backporting fixes to older versions. Bug fixes are the responsibility of the Plone community as a whole. The Release Team then makes sure that fixes are released on a regular basis.

All support, including security support, is done on a best effort basis. No one is getting paid by the Plone Foundation to work on fixes or to maintain infrastructure. If you need more guarantees, talk to your Plone service provider.

Plone is serious about its support, but we have no control over the level of support of our dependencies. A dependency may release a bugfix that we need in a version that contains backward incompatible changes that we cannot work with. This may force us to use an old, no longer supported version of this dependency. Or we may be forced to switch to a different dependency, possibly requiring changes in add-on modules.

Frameworks including Python, Node.js®, and React may drop support for older versions, forcing us to drop support for these versions as well. For example, Plone 6.0 works on Python 3.8, but this Python version reaches end of life in October 2024. At that point, Plone 6 will drop support for Python 3.8.

Supported versions

Plone 6.0

  • This is currently the main, stable version.

  • 6.0.0 released on 2022-12-12.

  • Maintenance support (regular releases) until 2024-12-31 (2 years)

  • Security support until 2027-12-31 (5 years).

  • Volto 16: same dates for end of support.

  • Current release:, 2024-05-08.

  • Next release expected: June 2024

  • Supports Python 3.8, 3.9, 3.10, 3.11, 3.12. Python 3.12 is officially supported since Plone 6.0.10.

  • Uses Zope 5.

  • An upgrade to Plone 6 is only possible from a 5.2 site running on Python 3.

Plone 5.2

  • 5.2.0 released on 2019-07-10.

  • Maintenance support until 2023-10-31.

  • Security support until 2024-10-31. Python 3.8 is end of life then.

  • Current release: 5.2.14, 2023-09-21.

  • Next release expected: none. The last maintenance release was planned for October 2023, but this was done one month earlier to get several security fixes in. If really needed for special reasons, it is still possible to create a new release.

  • Supports Python 2.7 and 3.8.

  • Python 2.7 is only recommended to use temporarily as a stepping stone while preparing to migrate to Python 3.

  • Python 3.6 and 3.7 should still work, we try not to break it, but they are no longer officially supported or tested. Especially you may be on your own in figuring out which extra package versions to use.

  • Python 2.7, 3.6, and 3.7 have reached end of life, and are continuously getting harder to test and support.

  • Note that Python 3.9 has never been supported and is not recommended.

  • Uses Zope 4.

  • An upgrade from Plone 5.1 and earlier is only possible on Python 2.7. Afterwards, the upgraded site can be upgraded to Python 3.

Future versions

Plone 6.1

  • 6.1.0a1 released 2024-01-26.

  • Current release: 6.1.0a3, 2024-04-26.

  • Next release expected: May 2024.

  • 6.1.0 final expected in summer 2024 (preliminary).

  • Supports Python 3.10, 3.11, 3.12.

  • Maintenance support until Plone 6.2.0 comes out.

  • Security support until 2027-12-31 (5 years from 6.0.0).

Plone 6.2

  • 6.2.0 expected in December 2024 (preliminary)

  • Maintenance support until Plone 6.3.0 or 7.0.0 comes out.

  • Security support until 2027-12-31 (5 years from 6.0.0).

Plone 7.0

  • 7.0.0 in March 2025 (preliminary)

  • Maintenance support until 2027-03-31 (preliminary, 2 years from 7.0.0)

  • Security support until 2030-03-31 (preliminary, 5 years from 7.0.0)

Unsupported versions

Plone 5.1
Plone 5.0
Plone 4.3