# MySQL 8.0 is end of life: upgrade to 8.4 or move to MariaDB?

> Oracle stopped patching MySQL 8.0 on April 30, 2026. Here is what actually breaks on the way to 8.4 LTS, 9.7 LTS or MariaDB, how long each one is supported, and which move fits which app.

Published: 2026-11-17
Canonical: https://layerbase.com/blog/mysql-8-0-end-of-life-upgrade-or-mariadb

Short version: MySQL 8.0 stopped getting security fixes on April 30, 2026. If your app runs fine on 8.0 and nothing else is bothering you, upgrade in place to 8.4 LTS. It is the cheapest move by a wide margin. Move to MariaDB when you have a reason beyond the deadline, because MariaDB is a dump-and-restore migration, not an upgrade, and that is where most of the cost of this decision sits.

The rest of this post is the detail behind that: what each path breaks, how long each one buys you, and the situations where MariaDB is the better call.

## Contents

- [What ended on April 30](#what-ended-on-april-30)
- [The three realistic destinations](#the-three-realistic-destinations)
- [What breaks going to 8.4](#what-breaks-going-to-84)
- [What breaks going to MariaDB](#what-breaks-going-to-mariadb)
- [The Oracle question](#the-oracle-question)
- [When MariaDB is the better move](#when-mariadb-is-the-better-move)
- [When to stay on MySQL](#when-to-stay-on-mysql)
- [Doing either one on Layerbase](#doing-either-one-on-layerbase)
- [FAQ](#faq)

## What ended on April 30

MySQL 8.0 shipped in April 2018. Oracle's Premier Support for it ended on April 30, 2025, and Extended Support ended on April 30, 2026 ([endoflife.date](https://endoflife.date/mysql), which tracks Oracle's lifetime support policy). The last community release in the series was 8.0.46. Nothing after that gets a CVE fix from Oracle.

"End of life" does not mean your server stops. It means the next security advisory that lists 8.0 as affected will not come with a patch for it. For a database behind a private network with one application talking to it, that risk builds slowly. For anything reachable from the internet, or anything an auditor looks at, it is already a finding.

Some managed services bought their customers time. Oracle's own HeatWave service, for example, [keeps patching 8.0.46 DB systems until April 2027](https://blogs.oracle.com/mysql/post/endoflife-of-heatwave-mysql-80-version) and then upgrades the stragglers to 8.4 automatically. If you run your own server, or your host simply ships what upstream ships, there is no such cushion.

## The three realistic destinations

| Destination      | Kind of move           | Supported until                                 |
| ---------------- | ---------------------- | ----------------------------------------------- |
| MySQL 8.4 LTS    | In-place upgrade       | Premier April 2029, Extended April 2032         |
| MySQL 9.7 LTS    | In-place upgrade       | Premier April 2031, Extended April 2034         |
| MariaDB 11.8 LTS | Dump and restore       | June 2028                                       |
| MariaDB 12.3 LTS | Dump and restore       | June 2029                                       |

Dates are from [endoflife.date](https://endoflife.date/mysql) for MySQL and [endoflife.date](https://endoflife.date/mariadb) for MariaDB, checked 2026-11-17.

Two things in that table are easy to miss.

First, MySQL 9.7 is an LTS. Oracle moved to a two-track model where most 9.x releases are short-lived Innovation releases and every so often one becomes a long-term line. 9.7, released in April 2026, is that line. If you are going to absorb an upgrade anyway, 9.7 buys two more years of support than 8.4 does. It also removes `mysql_native_password` entirely (it was deleted in 9.0), so it is a bigger jump.

Second, MariaDB's community LTS windows got shorter. Releases up to 11.4 got five years. Starting with 11.8, a community LTS gets three, and MariaDB now names one LTS a year (the `.3` release of each major, starting with 12.3). So MariaDB 11.8 actually runs out nearly a year before MySQL 8.4's Premier Support does. Plan on another MariaDB upgrade around 2028 or 2029. Within the MariaDB line that is a normal in-place upgrade, so it is less painful than the one you are doing now.

The column that matters most is "kind of move". MySQL 8.0 to 8.4 is a supported in-place upgrade: you install the new binaries over the same data directory and the server upgrades its data dictionary on first start. MariaDB cannot open a MySQL 8 data directory at all. MySQL 8 introduced a transactional data dictionary that MariaDB never adopted, so the only road across is a logical dump and a restore.

## What breaks going to 8.4

Oracle's [What Is New in MySQL 8.4 since MySQL 8.0](https://dev.mysql.com/doc/refman/8.4/en/mysql-nutshell.html) page is the authoritative list. The items that actually stop applications, in the order I would check them:

**`mysql_native_password` is off by default.** Users created with it can no longer log in until you either convert them to `caching_sha2_password` or start the server with `mysql_native_password=ON`. Old drivers and old PHP builds are the usual casualties. The setting is a bridge, not a fix: in 9.x the plugin is gone.

**`default_authentication_plugin` is removed.** A `my.cnf` that still sets it will refuse to start the server. The replacement is `authentication_policy`.

**The `MASTER` and `SLAVE` replication statements are gone.** `CHANGE MASTER TO`, `SHOW SLAVE STATUS`, `START SLAVE` and friends are now syntax errors. Their `SOURCE` and `REPLICA` spellings have existed since 8.0.22 and 8.0.23, so the fix is mechanical, but it lives in the places nobody reads: monitoring checks, failover scripts and backup tooling.

**Foreign keys on non-unique or partial keys are rejected for new DDL.** `restrict_fk_on_non_standard_key` is `ON` by default. Existing tables upgrade fine, with a warning listing the offending keys, but a migration that recreates one of those tables will fail.

**`AUTO_INCREMENT` on a `FLOAT` or `DOUBLE` column fails the upgrade.** Rare, but Oracle's notes say plainly that you must fix those tables before upgrading.

**A batch of InnoDB defaults changed.** The adaptive hash index is now off, change buffering is off, `innodb_io_capacity` went from 200 to 10000, and `innodb_flush_method` prefers `O_DIRECT` on Linux. These do not throw errors. They change performance, usually for the better on SSDs, sometimes not for a workload that leaned on the hash index. Benchmark the queries you care about rather than assuming.

Smaller removals round it out: `expire_logs_days` (use `binlog_expire_logs_seconds`), `mysqlpump`, `mysql_upgrade`, `FLUSH HOSTS` and the old `keyring_file` plugin.

Run MySQL Shell's upgrade checker (`util.checkForServerUpgrade()`) against the 8.0 server before you do anything else. It reports most of the above from your actual schema and configuration.

## What breaks going to MariaDB

MariaDB keeps its own list, [Incompatibilities and Feature Differences Between MariaDB 11.8 and MySQL 8.0](https://mariadb.com/docs/release-notes/community-server/about/compatibility-and-differences/incompatibilities-and-feature-differences-between-mariadb-11-8-and-mysql-8). Your drivers and ordinary CRUD carry over: `mysql2`, PDO, Prisma, Drizzle and the `mysql` client all speak to MariaDB unchanged. What breaks is narrower and lives in a few places.

**JSON is text.** MariaDB's `JSON` type is an alias for `LONGTEXT` with a validity check, and JSON values compare as strings. MariaDB 11.8 does not support the `->` and `->>` operators, so every query using them needs rewriting to `JSON_EXTRACT` and `JSON_UNQUOTE(JSON_EXTRACT(...))`. MariaDB's notes put operator support in 13.1. There is also no equivalent of MySQL's multi-valued indexes on JSON arrays, which is the difference most likely to hurt at scale.

**Authentication.** MySQL 8 creates users with `caching_sha2_password`. MariaDB added a server plugin for it, aimed at migrations, only in [11.4.9, 11.8.4 and 12.1](https://mariadb.com/docs/server/reference/clientserver-protocol/1-connecting/caching_sha2_password-authentication-plugin). On an older release those users cannot log in. Either way, a dump does not carry users and grants, so plan to recreate them.

**GTIDs are a different format.** MariaDB's GTIDs are not compatible with MySQL's, so you cannot hang a MariaDB replica off a GTID-based MySQL 8 primary and promote it. A low-downtime cutover is still possible with binlog-position replication, but the common path is a dump, a restore and a short write freeze.

**Missing MySQL 8 features.** No X Protocol or document store, no `SET PERSIST`, no `FOR SHARE` (use `LOCK IN SHARE MODE`), and no `MAX_EXECUTION_TIME` optimizer hint (MariaDB uses `max_statement_time`).

**Collations.** This one used to stop every restore with `Unknown collation: 'utf8mb4_0900_ai_ci'`. From MariaDB 11.4.5 the 0900 names are aliases for MariaDB's own UCA 14 collations, so a default MySQL 8 dump restores. On 10.11 it still fails. [Moving a MySQL dump into MariaDB](/blog/mysql-dump-into-mariadb) walks through that error and the rest of the restore, including `DEFINER` clauses and the two `mysqldump` flags people usually learn about from an error.

Add it up and the MariaDB move is a real migration with a test cycle. For a typical web app that does not use the JSON operators or the document store, it is a day or two of work. For an app built around MySQL's JSON features, it can be weeks, and you would be giving up indexes you rely on.

## The Oracle question

The reason this is a live question in 2026, and not just a version bump, is Oracle. Several things happened in roughly a year:

- Oracle's layoffs in September 2025 were widely reported to have hit most of the MySQL engineering team. The commonly cited figure is 60 to 70 percent, though Oracle has not confirmed a number.
- Public commit activity on MySQL in 2025 was the lowest since the project's first years, around 2000.
- Oracle answered in early 2026 with a published community strategy, the LTS and Innovation release model, and a commitment to keep features in the Community Edition ([heise](https://heise.de/-11179437) covered it). 9.7 LTS shipped on schedule in April.

So the pessimistic read (MySQL is dying) is not supported by what Oracle has actually shipped, and the optimistic read (nothing changed) ignores a much smaller team. What I take from it: MySQL 8.4 and 9.7 will very likely get their security fixes through their support windows. Whether MySQL keeps gaining features at its old pace is a separate bet, and a fair reason to prefer MariaDB on a new project. It is a weak reason to migrate a working app under deadline.

MariaDB has its own story. MariaDB plc went private in 2024 under K1 Investment Management, and it briefly planned to drop Galera from Community Server 12.3 before reversing course after community pushback. The MariaDB Foundation, which owns the open source server, is separate from the company and is the better signal for the community releases. Neither project is risk-free.

## When MariaDB is the better move

You are rewriting anyway. If the 8.0 retirement lands on top of a framework upgrade, a host move or a schema overhaul, the dump-and-restore cost mostly disappears into work you were already doing.

You want what MariaDB has and MySQL does not. `CREATE SEQUENCE` replaces the locked counter table, system-versioned tables replace an audit table plus triggers, and `UUID`, `INET4` and `INET6` are real column types. [MySQL vs MariaDB](/blog/mysql-vs-mariadb) has runnable examples of each.

Your platform already leans that way. Debian's `default-mysql-server` package installs MariaDB, Fedora and RHEL ship MariaDB alongside MySQL, and WordPress, Drupal, Nextcloud and most PHP software treat it as a first-class target. If your servers are installed from distro packages, check which one you are actually running: you may already be on MariaDB.

You do not want your database's future tied to one vendor's staffing decisions. That is a governance choice, not a technical one, and it is a legitimate one.

## When to stay on MySQL

You use MySQL's JSON features heavily: the `->>` operator everywhere, multi-valued indexes, JSON columns you filter on. MariaDB is a slower substitute there, not a drop-in.

You depend on MySQL-specific tooling: X DevAPI clients, MySQL Shell's dump and load utilities, InnoDB Cluster or Group Replication, or HeatWave.

Your managed provider is pushing you toward MySQL. Azure [retired Azure Database for MariaDB](https://learn.microsoft.com/en-us/azure/mariadb/whats-happening-to-mariadb) on September 19, 2025 and points customers to MySQL Flexible Server, so on Azure the question answers itself.

Or the deadline is the only reason you are touching the database. Then take the in-place upgrade to 8.4, run the upgrade checker first, fix the auth plugins and the replication scripts, and get back to your product. If you can absorb a slightly bigger jump, 9.7 buys more runway.

## Doing either one on Layerbase

If you would rather not run the upgrade yourself, both destinations are a create away on [Layerbase Cloud](https://cloud.layerbase.com/create).

New MySQL databases are created on 8.4 LTS or 9.7 LTS (8.0 is not offered). [MariaDB](/db/mariadb) is offered on 10.11, 11.4, 11.8 (the default), 12.3 and the 13.0 rolling release, and it is on the Free plan. MySQL starts on Solo. Either way, the [migration wizard](/migrate) takes a MySQL connection string from wherever 8.0 runs today (RDS, a VPS, another host), runs `mysqldump` once, and copies the schema and data into a MySQL or MariaDB target. One catch: MariaDB's dump tools cannot yet read a MySQL 8 server on the default `caching_sha2_password` auth, so for that source pick a MySQL target, or switch the migration user to a plugin MariaDB's tools can read.

If you land on one and change your mind, the Convert tab in the dashboard switches a database between MySQL and MariaDB in either direction. It copies into a new database and leaves the original untouched, runs a pre-check for features that will not survive the trip, compares row counts table by table afterwards, and can move your original host, port and password onto the new database so nothing gets redeployed. Expect about a minute of downtime at the handover. The [converting engines docs](/docs/converting-engines) cover the caveats in each direction.

## FAQ

### Does MySQL 8.0 stop working after end of life?

No. Your server keeps running exactly as before. What stops is Oracle's security patches, so each new MySQL CVE that affects 8.0 stays unfixed on your server.

### Can I upgrade MySQL 8.0 directly to 8.4?

Yes. 8.0 to 8.4 is a supported in-place upgrade. Run `util.checkForServerUpgrade()` from MySQL Shell first, and check for `mysql_native_password` users, `MASTER`/`SLAVE` replication statements in your scripts, and a `default_authentication_plugin` line in your config.

### Can I upgrade MySQL 8.0 directly to 9.7?

Oracle supports upgrading from the previous LTS (8.4) to the next one, so the documented route is 8.0 to 8.4 to 9.7. Moving to 9.7 also removes `mysql_native_password` entirely, so every user and client has to be on `caching_sha2_password` first.

### Can MariaDB read a MySQL 8.0 data directory?

No. MariaDB cannot use a MySQL 8 data directory, because MySQL 8's data dictionary format was never adopted by MariaDB. Moving from MySQL 8.0 to MariaDB means a logical dump and restore, plus recreating users and grants.

### Is MariaDB a drop-in replacement for MySQL 8.0?

For drivers, the wire protocol and ordinary SQL, mostly yes. For JSON operators, multi-valued indexes, the document store, `SET PERSIST`, GTID replication and `caching_sha2_password` users on older MariaDB releases, no. Check those before you plan the move.

### Which MariaDB version should I move to?

11.8 LTS (supported to June 2028) or 12.3 LTS (to June 2029). Use 11.4.5 or newer at minimum so MySQL's `utf8mb4_0900_ai_ci` collation resolves, and 11.8.4 or newer if you want to keep `caching_sha2_password` users. Avoid 10.11 for a MySQL 8 migration: its collation support stops the restore.

### Is MySQL dying?

Not on the evidence. Oracle cut the team sharply in 2025, but it has kept shipping releases and named 9.7 an LTS with support into the 2030s. The real question is how fast MySQL gets new features, which is a better reason to pick MariaDB for a new project than to migrate a working one.
