You Only Own What You Can Still Run

OpenMW 0.51.0 landed last week — an open-source reimplementation of the engine behind The Elder Scrolls III: Morrowind. The release notes read like any active project: a Lua scripting API that lets modders build magic effects from scratch, terrain vertex painting in the content editor, a pile of crash fixes, better controller support. The team even dropped the legacy fixed-function rendering path entirely, because the future is shaders, and they're building for it.

Here's the part worth stopping on. Morrowind shipped in 2002. Bethesda's original engine was built for the hardware and operating systems of that year. OpenMW runs the same game — your same data files, your same mods — on Windows, macOS, and Linux, on GPUs that didn't exist when the game was new, with capabilities the original never had. The game got better two decades after its maker moved on.

That's not nostalgia. That's a lesson about what ownership actually is.

i · you own the data. did you own the engine?

When you "own" Morrowind, what you own is a set of data files — the world, the dialogue, the art, the rules. What you do not own is the thing that turns those files into a playable game. The original engine was proprietary. It ran as long as Bethesda's code ran on an OS that would still host it. The day a Windows update drops support for something that engine depends on, your data files become a box you have the key to but no door for.

OpenMW splits those two things apart. The data stays yours. The engine becomes a community-owned, open-source artifact that anyone can read, fix, and carry forward. You bring the files you legally own; OpenMW supplies a runtime that no single vendor can switch off.

Say it plainly, because it generalizes far past video games: you only own what you can still run. A file you can't open is not a possession. It's a hostage to whoever controls the runtime.

ii · most of what you "own" is rented

Once you see the split between artifact and runtime, you start seeing it everywhere, and it's uncomfortable.

• The ebooks in your library open in exactly one app, and only while that company's license server answers.
• The project files for your design tool are a format only that tool reads — and the tool is now subscription-only.
• Your photos are "yours," sitting in a proprietary cloud whose export button produces something lossy, if it produces anything.
• That old project you finished is trapped in a file format whose only reader stopped shipping for your OS three versions ago.

In every case you feel like an owner. Functionally you're a tenant, and the lease can be revoked by a server shutdown, a pricing change, or an OS that quietly drops 32-bit binaries. The artifact is yours. The runtime belongs to someone whose incentives are not your incentives.

This is what makes OpenMW more than a hobby project. It's a demonstration that the tenancy is not inevitable.

iii · the engine died. the pattern didn't.

Coherenceism has a phrase for this: nothing vanishes — it transforms. The form changes; the pattern persists. Bethesda's original Morrowind engine is, for all practical purposes, dead — frozen at its last build, slowly drifting out of compatibility with every machine made since. But the pattern it expressed — that world, those rules, the experience of walking through Vvardenfell — didn't die with it. The community composted a defunct proprietary runtime into a living open one, and the living one now does things the original never could.

That's a living tradition in the most literal sense. The forms adapt — Lua scripting, modern GPUs, three operating systems — while the pattern endures. The only real death, in this frame, is a pattern that ends without feeding anything else: a game whose engine rots and takes the whole world down with it because no one was allowed to look inside. OpenMW is the opposite. It's a leaf that fell and became soil.

And it compounds. Eighteen years of volunteer work didn't just preserve a 2002 game in amber — it built a platform that's more capable every release. That's the agency river's whole creed: build once, use forever. The work doesn't depreciate toward the vendor's end-of-life date. It appreciates, because the people maintaining it are the people who use it.

iv · what you can do with this tomorrow

The point isn't "go install OpenMW" (though if you own Morrowind, do). The point is a test you can run against anything you depend on. Before you trust something with your data, your work, or your memories, separate the artifact from the runtime and ask:

1. Can I get the raw artifact out, whole? If the export is lossy or there's no export at all, you don't own it — you're visiting it.
2. Who controls the runtime? A single vendor's proprietary binary is a countdown clock. An open format or an open-source engine is a runtime that outlives the company.
3. Could someone rebuild the runtime without permission? If the format is documented or the code is open, the answer is yes, and you're safe even if the original maker disappears. If it's a black box, you're betting on a corporation's lifespan.
4. Is there already an open reimplementation or open standard? For more than you'd guess, there is. Prefer it — even at a small cost in polish — because you're buying durability, not features.

Run that test and your choices shift. You start preferring plain text over proprietary documents, open formats over slick lock-in, self-hostable tools over services that hold your data on their terms. Not out of ideology — out of arithmetic. The open path is the one where the work you put in this year still runs in twenty.

A handful of volunteers kept a 24-year-old world alive and made it better, on hardware its creators never imagined, because the engine was something a community could keep. That's the difference between owning a thing and owning the right to keep using it. Decide which one you actually have — and when you get the choice, choose the engine you can keep.