On Tuesday, Epic Games pushed a new repository to GitHub: Lore, an MIT-licensed version control system written in Rust, designed from the ground up for projects where files are measured in gigabytes, not kilobytes. The official line, as Phoronix reported and The Register confirmed, is that Lore exists for “games and entertainment purposes with large file sizes” — a tool purpose-built for an industry that has contorted itself around Git for two decades despite Git never being built for binaries.

That’s the press-release story. Here’s the one Epic can’t say out loud: the biggest tech companies in the world are quietly concluding that Git — the closest thing software has to universal infrastructure — doesn’t work for the things they actually build anymore.

Epic didn’t release Lore out of open-source idealism. It released Lore because it has Fortnite. Fortnite is not a codebase. It’s a warehouse of 3D assets, textures, audio files, cinematic sequences, and Unreal Engine project directories that would choke any Git repository not propped up by an elaborate scaffolding of LFS, custom hooks, and prayer. Epic solved its own problem, and it’s now giving the solution away because getting other studios, AI labs, and simulation builders to adopt the same tool creates an ecosystem where Epic’s workflow is the default.

This is not charity. This is infrastructure capture by a company that understands that whoever defines how large assets get versioned defines how the next decade of software gets built.

Git Won the War. It’s Losing the Peace.

Git’s dominance is total. Stack Overflow surveys put it above 93% market share among developers. GitHub is the de facto résumé for engineers. The tooling ecosystem — CI/CD pipelines, code review workflows, IDE integrations — treats Git as the substrate everything else sits on top of.

The problem is that Git was designed for the Linux kernel mailing list in 2005. It handles text patches beautifully. It handles a 4K texture map the way a sedan handles a gravel quarry — it’ll get there, technically, but nobody would call it graceful.

Git LFS was the bandage. It stores pointers in the repository and offloads actual binaries to a separate server. But anyone who’s administered a Git LFS setup at scale knows the experience degrades into a series of unpleasant discoveries: bandwidth bills that surprise your finance team, merge conflicts on binary assets that are functionally unresolvable, and a permissions model that treats a 6GB Unreal Engine level the same way it treats a 40-line config change.

Epic’s bet — and it’s not alone — is that the next decade of high-value software doesn’t look like a monorepo of microservices. It looks like AI model weights. It looks like simulation environments. It looks like digital twins of factories and cities. These are all asset-heavy projects where the binary is the product, not an artifact of the build.

“None of the Git platforms have cracked this,” one build-infrastructure engineer at a major game studio told me over Slack DM on Tuesday, minutes after the Lore repo went live. “We’ve all built our own crap on top of Git for years. Someone was going to standardize it eventually. I’m just surprised it was Epic and not Microsoft.”

The Centralization Nobody Wants to Talk About

Lore is centralized. Epic says so explicitly: it uses a “centralized server-of-record for durability, access control, and conflict resolution.” This is a design choice, not a compromise, and it’s going to make a certain kind of developer recoil on instinct. Distributed version control is a moral commitment in some circles, not a technical trade-off.

But look at how large organizations actually use Git. They don’t treat it as distributed. They treat it as centralized, with GitHub or GitLab or Bitbucket as the server-of-record, because the alternative — every developer maintaining a full copy of a repository that includes terabytes of binary assets — is operationally absurd. Git’s decentralization is a feature almost nobody at scale uses. Lore just stops pretending.

The honest version of the conversation the industry needs to have is this: distributed version control was optimized for a world where storage was cheap, bandwidth was plentiful, and the artifacts being versioned were human-readable patches. That world is not the world AI and game development live in. Lore concedes the point and designs around it, which is more intellectually honest than Git LFS’s “distributed in theory, centralized in practice” architecture.

The Real Audience Is AI Labs, Not Game Studios

Epic framed Lore as a game-development tool, and that’s the natural home for it. But the audience that should be paying closest attention is the AI sector.

Foundation model training involves versioning datasets that span petabytes, configuration files that determine training runs costing millions of dollars, and model weights that are the single most valuable asset a company owns. Git is the wrong abstraction for all of this. DVC and similar tools have tried to bridge the gap, but they’re layers on top of Git, inheriting its conceptual model of commits and diffs applied to things that don’t diff meaningfully.

Lore’s “fragment-level deduplication” — the ability to recognize that two versions of a 6GB asset share most of their data and store only the delta — is the kind of feature that matters when your dataset updates daily and your storage bill has nine figures in it. If an AI lab adopts Lore internally, the pressure on tooling vendors to support it becomes real. That’s the ecosystem play.

Epic is not competing with GitHub. It’s betting that GitHub’s model — Git repositories plus a marketplace of add-ons — is insufficient for the highest-value software being built, and that the company that provides the right substrate gets to define the workflow for a generation of builders who find Git’s limitations before they learn its virtues.

The Standard You Build Is the Standard You Control

There is a pattern here that extends well beyond version control. Epic releases Unreal Engine for free until you make a million dollars. It operates a storefront that takes a smaller cut than Steam. It fights Apple and Google over platform fees in courtrooms and regulatory filings, positioning itself as the ally of developers against gatekeepers.

Each of these moves is framed as generosity. Each is, looked at coldly, a play to define the infrastructure layer on which other businesses depend — and to ensure that when those businesses scale, Epic is the default partner, not a cost to be negotiated away.

Lore fits the pattern. An MIT license means no copyleft obligations. Any studio, lab, or enterprise can adopt it without legal friction. That lowers the barrier to entry to zero — and raises the switching cost once a team’s entire asset pipeline is built around Lore’s object model, its deduplication strategy, its server architecture.

The industry has spent two decades converging on Git because convergence is valuable. A universal version control system means interoperable tooling, transferable skills, and predictable infrastructure costs. But convergence is only valuable if the converged-upon tool actually solves the problem. For the projects where the artifact being versioned is not source code — and those projects are increasingly the ones that matter economically — Git is a legacy compatibility layer held together by custom scripts and hope.

Epic saw the gap. It built a bridge. And it handed the blueprints to everyone for free. The only question is when the rest of the industry notices that free infrastructure, in the hands of a company that knows exactly what it’s doing, is never just free.

Sources