Epic ships Lore: the first credible Perforce challenger in 20 years

What happened

Epic Games quietly stood up lore.org and announced Lore — a new version control system aimed at the kind of repos that make Git fall over. The Hacker News thread hit 779 points in hours, which for a VCS launch is roughly the upper bound of what's possible without involving Linus Torvalds. The pitch is straightforward: a content-addressed VCS built for the 10TB-and-up repos that have been Perforce's exclusive territory for two decades.

The launch came with no fanfare from Epic's marketing arm, no Tim Sweeney keynote, no Unreal Engine integration announcement. Just a domain, a spec, and a working implementation. That tracks with how Epic has historically released developer infrastructure — see also Easy Anti-Cheat, the Epic Online Services SDK, and the Verse programming language. Build it because they need it, then make it available because the cost of competing with the rest of the industry on tooling is higher than the cost of sharing.

The "we need it" part is real. Epic ships Unreal Engine — a codebase that, with its content samples and demo projects, sits past 100GB. Every studio building on Unreal has the same problem at larger scale: Fortnite alone is a repository measured in terabytes of binary assets that change with every patch. For 25 years the only credible answer to that problem has been Perforce, and Perforce has known it.

Why it matters

The thing Git got right — content-addressed objects, immutable history, distributed clones — is exactly what breaks it at game-asset scale. A 50GB texture pack committed once becomes a 50GB blob in `.git/objects/` forever. Clone the repo, you copy the blob. Switch branches, you might write it to disk again. Git LFS papers over this with pointer files and a side-channel store, but it still inherits Git's assumption that history is something you keep locally. When history is petabytes, that assumption stops being a feature.

Perforce solved a different problem from the other direction: server-side file ownership, exclusive locks, sparse client workspaces. It works. It also costs five figures per seat at scale, ships a UI that predates the smartphone, and treats branching as something you ask politely for. The result is an entire industry — games, VFX, increasingly ML — paying a tax to a single vendor because nobody has had both the engineering depth and the install base to build a real alternative.

The existing alternatives have all hit one of two walls. Git LFS, Git Annex, and friends are bolt-ons; they still assume Git's model underneath. Plastic SCM was the closest thing to a true alternative — Unity bought it, which turned it into a feature of a competing engine. DVC is excellent for data-science pipelines but not a VCS in the source-tree sense. Mercurial with largefiles has a niche but no momentum. The market has been waiting for someone with both the scar tissue and the bandwidth to ship the real thing.

What's actually under the hood matters. The early reading from the HN thread and the lore.org docs suggests content-addressable storage with chunked deduplication (rolling-hash chunks rather than whole-file blobs), lazy fetch, and sparse workspaces as a first-class concept rather than an afterthought. That's the right shape. A 4GB asset edited in one corner should produce a few hundred KB of new chunks, not a new 4GB object — and your laptop should never download the chunks it doesn't need. If Lore delivers this with Perforce-quality lock semantics and a UX that doesn't require a 2007 Windows client, the moat collapses.

The interesting tell is who else this could matter to. ML teams are quietly living the same problem: model checkpoints, training datasets, fine-tuning artifacts, eval suites — all binary, all version-worthy, all currently scattered across S3 buckets with `v3_final_actually.bin` filenames because nobody has a real VCS for them. The current best answer is some combination of DVC, MLflow, Hugging Face Hub, and prayer. A general-purpose large-binary VCS that any team can `lore init` into is a strictly better primitive.

What this means for your stack

If you're shipping a game on Unreal or Unity, the calculation is simple: watch what Epic does next. If Lore lands in Unreal Engine 5.6 or 6.0 as the default VCS, Perforce's pricing power evaporates inside 18 months. That doesn't mean you migrate tomorrow — Perforce migrations are notoriously expensive and your build pipeline, CI, and ten years of accumulated changelist tooling are all wired to p4. But it changes the negotiation. Your next Helix Core renewal just got a credible BATNA.

If you're an ML platform team, this is worth a pilot. The pain of versioning 2TB of training data with current tooling is real, and the cost of being wrong about a new VCS for non-source artifacts is low — you're not betting the company's source tree on it. Spin up Lore against a single dataset, see whether the chunked dedup and lazy fetch deliver on commodity hardware. The honest answer in six months may be that DVC is still the right call, but knowing that beats not knowing.

If you're on Git for normal-shaped source code, nothing changes. Lore is not a Git replacement and isn't trying to be. Git won the source-code war on the strength of distributed history and trivial branching, and the parts of Lore's design that make sense for 10TB binary repos are exactly the parts that would be overkill for a 500MB monorepo. The two systems coexist the way SQL and object storage coexist — different problem shapes, different tools.

The open question is license. Epic has shipped tools under everything from MIT (Pixel Streaming bits) to source-available-with-revenue-sharing (Unreal itself) to fully proprietary (EOS). If Lore lands as Apache 2.0 or MIT it's a genuine Perforce-killer; anything more restrictive and it's a competitive moat dressed up as a gift. Watch the LICENSE file before you watch the benchmarks.

Looking ahead

The asset-pipeline VCS market has been frozen for roughly 20 years. Perforce raised prices, Plastic got absorbed, Git LFS shipped just enough to keep small teams off Perforce but not enough to displace it anywhere serious. Epic stepping into that gap with a real engineering team behind it is the first credible disruption since Mercurial. Whether Lore wins is a function of two things nobody can predict yet: how good the implementation actually is once teams hit production-scale workloads, and how aggressively Epic supports adoption outside their own ecosystem. But the ceiling is high, the incumbent is uniquely vulnerable, and for the first time in a long time the answer to "what VCS do you use for binary assets?" might not be "Perforce, regrettably."