The Name "Mere," and What It Is

Five parts described a working language without ever quite settling what to call it. That was deliberate. The project ran for a long time under a placeholder name, with an explicit note that the placeholder would be reconsidered once the core — the memory model, the effects, the types — actually worked. This part is about the crossing from a private experiment to a public thing, and it opens where that crossing begins: with a name.

Naming, deferred until it was earned

A language does not need a name to be built; it needs one to be used. So the name was held off, on the same principle that governed everything else in the project: commit when you know, not before. A placeholder is an honest statement — “I don’t yet know what this is” — while a premature name is a guess you then have to live with, a label that may not fit the thing that eventually emerges. You name a language once its character has settled, because the name should describe what it turned out to be, not what you hoped it would become.

By the point the core design questions were mostly resolved and the implementation ran across all its backends, the character was settled, and naming became the natural next act. What the language was had stopped being a question, which is exactly when the answer can be put on a label.

Mere: a modest word over an exact core

The name chosen was Mere — Old English for a lake, a still pool. One syllable, four letters, a file extension of .mere, a command called mere. On its surface it is a quiet, even self-deprecating word: mere, as in “just a—,” a name that declines to announce itself.

Underneath the modesty is a backronym that is not decoration but a compressed statement of the whole thesis:

Mere — Make Explicit Region-bound Effects.

Each word carries one of the load-bearing decisions the series has spent five parts on. Make — the language is a tool for active construction, a verb. Explicit — the first principle, explicitness over brevity, the refusal of hidden behavior. Region-bound — the memory model, values whose lifetimes are managed by regions and views under the Trivial constraint. Effects — capability passing, side effects that travel as visible values rather than ambient power. Four letters, four of the decisions that define the language. The name is the shortest possible summary of everything built so far.

That pairing — a humble surface over a precise core — is not accidental; it is the language’s own aesthetic performed by its name. Mere does not present as ambitious or clever; it presents as plain, and is exact underneath. A modest name over a clear content is the same posture the language takes toward code: nothing showy, everything legible.

Why a lake, of all the words

The choice was made from a long list of small landscape words — glens and coves and tarns and lochs, all of them bounded pieces of terrain, because the memory model’s central idea is a region, an area bounded from its surroundings. Several were strong. A glen names a region directly and has a brisk, Scots sturdiness; a cove is a calm bounded inlet. Mere won for reasons that are about fit rather than force.

A lake is the metaphor that maps most completely onto the design. It is an area bounded from what surrounds it — a region, with a lifetime of its own. Its surface is still enough to see through — the visibility that capability passing and explicit types are after, flow you can watch rather than infer. And a mere is a small, plain, unshowy body of water, which matches a minimal ML-family language with a deliberately small core, and matches the quiet the whole design is built on: not cleverness, but certainty accumulated by static checking. The name was not picked for its sound alone. It was picked because the picture it draws — bounded, still, clear to the bottom — is a picture of the language.

The name as a threshold

Renaming from the placeholder was, mechanically, a sweep through the codebase and the docs — the repository, the module names, the extension on every example, the front matter of every design note. But the mechanics are not the point. The point is what a name is for a piece of software crossing into public: it is the moment the thing becomes addressable. Before a name, a project is “the thing I’m working on”; after, it is something others can search for, refer to, depend on, adopt. The name is the first act of the crossing, not because it changes the code, but because it changes what the code can be to other people.

The language now has an identity — a word, a metaphor, a compressed manifesto in four letters. What it does not yet have is a public existence: a place to live, a way for someone who has never heard of it to find it, learn it, and try it. Having a name is not the same as being available. Next: going public — the site, the tutorial, the registration that makes a language show up as a language, and what it takes to open a private experiment to the world.