Sqlite on Luther Monson

Clustered SQLite in ePHPm, Part 3: CDC Over the Cluster Channel

Tue, 15 Sep 2026 21:08:00 -0700

By the end of Part 2 ePHPm v0.7.0 ran exactly one SQLite engine in process. That was Turso, for single-node and clustered mode alike. The sidecar was gone. What I skipped over is how a replica actually gets the primary’s writes, and what happens when the primary dies with data on it. That’s this post.

Part 1: Replication by sidecar with sqld
Part 2: Adding Turso
Part 3: CDC over the cluster channel (this post)

CDC from the engine itself

Turso has change data capture built in. Turn it on for a connection and every committed change lands in a turso_cdc table. Each row has a monotonically increasing change_id, the table, the rowid, and before/after images of the record. The primary tails that table and ships transaction batches. Replicas apply them. That’s the whole design. It landed as an experimental path in #186 at the end of July. The tailer and applier live in litewire (litewire#10).

Calling Rust From PHP Without a Socket, Part 1: The Native Functions

Mon, 14 Sep 2026 20:40:00 -0700

ePHPm is a single Rust binary that embeds PHP. It carries its own KV store and its own SQLite-backed database in the same process. For a long time PHP code could only reach that KV store the same way it reaches Redis. It opened a TCP socket to the RESP listener ePHPm runs on localhost, encoded a command and waited for the reply. That works, and every PHP Redis client in existence already speaks it. But it is a strange thing to do when the hash map you’re talking to lives a few pointers away in the same address space.

Zero-Dependency Deployments - Single Binary for WordPress

Tue, 08 Sep 2026 20:25:00 -0700

The standard way to run a WordPress site is four services:

nginx for HTTP and TLS
php-fpm to run PHP
MySQL for data
Redis, once the site gets slow enough that someone installs an object cache plugin

That’s four processes and four config files. There are three sockets between them and four things to upgrade. For a big site that’s fine. For a brochure site or a staging copy it’s absurd. The same goes for a PR preview, a box at the edge, or a CI job that needs a real WordPress to test a plugin against.

Security and Performance Hardening of a Rust Database Proxy

Thu, 27 Aug 2026 20:30:00 -0700

litewire is the piece of ePHPm that lets PHP apps talk MySQL to a SQLite file. I wrote about how it works and about the MySQL quirks WordPress depends on. This one is the less visible half of August:

an audit pass on litewire
a multi-tenant mode that turned a database proxy into a security boundary
a performance regression I shipped and then had to go find

It’s written in Rust. Memory safety is supposed to be the part I don’t have to think about, and it mostly is. The use-after-free in this story was in a dependency. The worst bug wasn’t a memory bug at all.

What Does One More WordPress Site Cost?

Tue, 25 Aug 2026 20:20:00 -0700

ePHPm v0.7.0 shipped per-site multi-tenancy. Point [server] sites_dir at a directory and every Host maps to its own docroot and its own Turso database file. One process serves all of them. The first question anybody asks about that is “how many sites fit on a box?” The honest way to answer it is to turn the question around. What does one more site cost? If you know the marginal RAM, file descriptors, CPU and disk for a tenant, the box size falls out of arithmetic.

Clustered SQLite in ePHPm, Part 2: Adding Turso

Wed, 19 Aug 2026 20:37:00 -0700

Part 1 ended with ePHPm running two SQLite engines. rusqlite ran in-process for a single node, and an embedded sqld child process ran for a cluster. The sidecar fell off a cliff past four concurrent writers. The best fix I could ship was a semaphore set to 1. This post is about replacing both engines with one, and about how I decided that engine was ready.

Part 1: Replication by sidecar with sqld
Part 2: Adding Turso (this post)
Part 3: CDC over the cluster channel

The thesis

Turso Database is a rewrite of SQLite in Rust:

Faking MySQL's Quirks Well Enough to Fool WordPress

Sun, 16 Aug 2026 15:50:00 -0700

Last month I wrote about running SQLite behind a MySQL socket with litewire. I ended on “passing an install suite is not the same thing as behaving like MySQL”. That turned out to be accurate. On August 10th a few things happened at once:

I put a real WordPress 7.0.3 site through a benchmark on ePHPm.
I A/B tested the new in-process database bridge against the wire path.
I started building ephpm/db-wordpress, a wpdb drop-in that talks to the database in-process instead of over a socket.

Between them they produced six litewire issues in about three hours. None of them broke the install. All of them made WordPress quietly do the wrong thing.

Clustered SQLite in ePHPm, Part 1: Replication by Sidecar

Sat, 08 Aug 2026 20:14:00 -0700

Most PHP sites I have run in the last twenty years did not need a MySQL server. They needed a database, and MySQL was the one every framework spoke. With ePHPm I have been trying to get rid of that server for the common case. The piece that makes it possible is litewire. PHP connects with plain pdo_mysql. litewire speaks the MySQL wire protocol, and the queries land in a SQLite file. WordPress and Laravel don’t know the difference. No mysqld, no child processes, just ephpm and a .db file.

SQLite as a Production Database via Protocol Translation

Sat, 25 Jul 2026 20:40:00 -0700

Most of the PHP sites I’d put on ePHPm don’t need a MySQL server. A brochure WordPress, an internal Laravel tool, a preview environment that lives for an afternoon. What they do need is something that looks like MySQL, because mysqli and pdo_mysql are the only database drivers their code has ever been pointed at. I mentioned this in the ePHPm pragmatism post as a one-paragraph “because”. This is the longer version, now that WordPress 7.0 and Laravel 13 both install and run end to end on it.