15 November 2026 · a change to the design

More than one engine.

The first design said a MelodyDB application would run only on MelodyDB’s own storage engines. That has changed. An application will be able to run on Postgres, and on other engines after it.

The original idea

Score never names a storage engine. The compiler reads every query an application runs, so it can choose an engine and indexes for exactly that workload. My plan was to build those engines myself, for three reasons.

I still think those are good reasons.

What people told me

Since the design went up on 11 November I have talked it through with several people who build or run production systems. Most of them told me, strongly, that they would only consider Postgres for production. They did not put it as a preference. It was a condition.

The compiler and the operations story landed. The new storage engine is where they stopped. One of them put it this way: it is hard to get an enterprise to look at anything else.

That is hard to ignore. The problem MelodyDB is built for is operations, and solving it doesn’t depend on which engine stores the rows.

An experiment with Postgres

On 14 November I translated a demo application to PostgreSQL 18 by hand, to see how much of a MelodyDB application Postgres can carry. It is a small approval application with 34 functions: a person submits a request, an agent reports on it, and a manager approves or rejects it.

The data side of the application translated almost completely. The open part is workflows. For a workflow step and its data to commit together, the workflow’s history has to live in the same Postgres database, and that isn’t designed yet.

This was one application, translated by hand. Crash recovery, data changes between versions and speed were not tested.

Other engines

MelodyDB’s native engine is first class too. It probably won’t be ready for production for a while, but it is meant for production servers, not only for a laptop or a browser tab. I think it can do things no other engine can or will. It only has to serve the queries one application needs, so it can be built for exactly those, for the hardware it runs on, and for spreading across machines as the application grows.

If it compiles, it moves

Engines are not the same. The experiment found two differences in how single values behave. Postgres text can’t hold the zero character, and Score text can. Postgres says a floating-point “not a number” equals itself, and Score says it doesn’t.

The compiler should know every difference like these. An application that doesn’t rely on one moves between engines unchanged. An application that relies on something an engine doesn’t support does not compile for that engine, and the compiler says where.

That is the first principle on the home page: trust the compiler. If it builds for an engine, it runs there with the same answers.

None of this is built yet. The compiler does not write SQL today.

Leave an email to hear when there is something to run.

© 2026 Douglas Tarr · [email protected] · Follow on X