simhacker/moollm/artifactory

Artifactory 🏭

The Engine of Creation. It builds, edits, and destroys — including itself.

An artifactory is an artifact factory: a general-purpose constructor that reads, writes, edits, destroys, and persists artifacts — text, directories, characters, skills, graphics — across the filesystem and git. It is both abstract (an operator, like lambda) and concrete (a thing in the world, like Ubik). It is class and instance at once: a description of how to build, and a built thing that builds.

[!TIP]

This is the operational engine other skills call. play-learn-lift decides what to make;

the artifactory makes it, versions it, and can unmake it.

Why it exists

Most tooling splits creation, editing, and deletion into unrelated commands. The artifactory treats them as one composable operation set over a persistent, versioned store:

• Tokens in, artifacts out. Reading consumes tokens; writing generates them. The artifactory

is where LLM work becomes durable, inspectable, versioned objects.

• Persistence is first-class. State lives in files and git — the tape outlives the run.
• Self-reproduction with a governor. It builds shows, skills, and characters that build more

— but it knows when to stop (the anti-Autofac clause below).

The axis of eval

The deepest idea: an artifact sits on the instructions ↔ data ↔ graphics axis, and the artifactory moves it along that axis.

It is homoiconic: one pass's output is the next pass's program. This is eval/apply for the filesystem — a skill is a lambda, INSTANTIATE is application, and construction is evaluation.

Operations

Creation, editing, and destruction are the same engine at different signs.

Git as the construction timeline

The artifactory doesn't just write files — it writes history. Branch to try a construction, merge when it works, open a PR to propose one, file an issue to request one, use discussions to deliberate. Branch timelines are experiments; merges are decisions; PRs are proposals. Every artifact arrives with a commit that says why.

Git is time flowing over a static universe (no, literally)

The filesystem tree is a static snapshot of a universe-state at one instant — in MOOLLM, the actual universe: rooms, characters, objects, journals, rules. A commit freezes that entire tree, content-addressed by hash, immutable forever. Git is the directed acyclic graph of those snapshots — a trans-dimensional representation of time laid over otherwise timeless static file trees. Not a line: a branching, merging, many-worlds graph. Branches are parallel timelines; merges reconcile them; checkout teleports you to any instant in that space-time.

The artifactory is the transition rule that runs on this. It reads the representation of the universe (snapshot N), applies CREATE / EDIT / DESTROY, and writes the next universe (snapshot N+1); git records the trajectory. So the claim "it runs the creation simulation on the representation of the universe" is not poetry — it's a plain description of the mechanics. No shit, it actually does.

Many-worlds, precisely — and that's why this works

The many-worlds framing is not a loose metaphor; it precisely describes git in its full glory. Everett's interpretation is a branching tree of self-consistent histories — no collapse, every possibility a real world. Git is that structure made of content-addressed snapshots:

Git even has one superpower physics doesn't: in standard many-worlds, branched worlds never recombine — but `merge` reconciles divergent timelines into one. Git is many-worlds plus a join operator.

Put plainly: git is a parallel-universe timeline editor — checkout picks which world you stand in, branch spawns one, merge rejoins two, the reflog means none is ever lost. It inverts PKD's "Faith of Our Fathers" (where the drug enforces a single consensus reality and the hidden truth is plural): with git the plurality is the reality, editable and safe, not a horror to be hidden. Most people use git daily without noticing they're operating a many-worlds machine — so naming it this way is a small calm-technology win: you already live in parallel timelines; here is the editor — a powerful, learnable, industry-standard tool made visible instead of drugged and hidden.

This precision is exactly why the artifactory works. Because git faithfully realizes a branching space of immutable, recoverable worlds, the engine can run the creation simulation across many candidate worlds at once — try a construction in one branch, a different one in another, keep what survives, and never destroy a world (it's still in the reflog). Speculative, fearless construction is only safe because the substrate is honestly many-worlds. Get the cosmology right and the safety, reversibility, and parallel experimentation fall out for free.

This is also von Neumann's picture, already in the lineage: the filesystem tree is the tape / CA grid, the artifactory is the constructor / transition function, and git is the space-time diagram of the computation. It's also homoiconic with the axis of eval — the universe-representation is also the program, so the artifactory evaluates the universe to produce the next universe.

And it's exactly why the governor matters: you are running a creation simulation on a real representation of a world. Edits are physics; deletes are entropy; git is an arrow of time you can walk backward. Reversibility, provenance, and a stop condition aren't bureaucracy — they're the conservation laws that keep the simulation from collapsing into Autofac.

Pocket universes, local time, and massively-single-player sharing

Many-worlds isn't only the main timeline branching. A branch (or a tag, for a frozen snapshot release) can be a Donnie Darko pocket universe — a long-lived, independently-named, polymorphically-typed ref like MicropolisCity_HaightAshbury that floats free with its own history and lifecycle, evolving outside the main branch — even in a different repo / fork entirely. It exists on its own terms, and when (if) it's ready, it can merge back into another branch, object, or timeline. A ref is just a named slot pointing at a world; branches, tags, objects, and timelines are interchangeable enough that you treat them polymorphically — spin one off, let it live, splice it in later, or never.

There is no global clock, and that's a feature — celebrate it. Git orders commits by causality (the parent-edge happens-before DAG), a partial order, not a global tick; wall-clock timestamps are mere metadata and can even disagree. So time genuinely slips by at different rates in different pocket universes — one fork races ahead, another sits frozen for years, a tag is a world stopped dead — and nothing breaks, because correctness rides on the causal graph, not a shared now. This is relativity, not a bug: no absolute simultaneity, just local histories and the events that connect them.

That is also the right collaboration model — call it massively-single-player, the way Spore did it. Spore didn't synchronize players in real time; it synchronized content — creatures, vehicles, buildings flowed asynchronously between everyone's private single-player universes (Sporepedia). Git is the same bet: you share objects, branches, and creations — not clocks. fetch/pull/PR is importing another universe's content into yours on your own schedule; everyone plays at their own rate, timestamp-independent, and the world is stitched together from shared artifacts, not synchronized time. Rate-independent, merge-when-ready, gloriously asynchronous.

What Spore forces: rethink multiplayer, time, and ownership

Spore's real provocation isn't graphics — it's that it quietly breaks three assumptions we treat as absolute. Each one fragments from a single global thing into many local things, and the artifactory inherits all three: