Never wrestle Git LFS again
Unreal assets are big: gigabyte textures, .umap levels that outgrow a normal repo, packaged builds in the tens of gigabytes. USourceControl has no LFS: big files just sync, with no pointer files and no bandwidth packs. Every sync moves only what changed, so you never re-download a project to grab one texture.
Large files as a first-class citizen
No LFS: big files just sync
Packaged builds, 8K texture arrays, multi-hour audio sessions, game captures. All fit natively in a single commit.
Direct-to-storage transfers
Files move straight between your machine and storage over short-lived signed links, several at a time. No server sits in the middle of your 3 GB mesh, and there's nothing to deploy for a contractor in another country.
Incremental sync
Only changed files are transferred. No re-downloading a 50 GB project because a teammate touched two textures.
Integrity verified
Every file is SHA-256 hashed on upload and verified on download. Silent corruption is not an option.
No pointer files, ever
.umap levels and packaged builds commit as real files, not LFS pointers. The file you commit is the file stored, and every version is kept.
Bandwidth included
No LFS bandwidth packs, no overage fees, ever. Storage and bandwidth are unlimited on every plan, Free included.
Why Git LFS falls short
Git was built for small text diffs. Git LFS bolts large-file support on top using pointer files. A pointer file is a small text placeholder stored in the repo that points to the real binary on a separate server. This model creates a class of silent-failure bugs specific to LFS. If a teammate's client isn't LFS-aware, they commit pointer files instead of real assets. If LFS bandwidth is exhausted, pulls start failing halfway. If a host changes LFS pricing, your bill changes without any code change. USourceControl has no pointer layer. The file you commit is the file stored. Every sync retrieves real bytes, not proxy text files.
The cost math at scale
Git LFS bandwidth billing is the hidden tax. Hosts like GitHub sell extra bandwidth in metered packs (check their current pricing for the latest rates), and a team pulling multi-gigabyte builds burns through them fast. Picture a nightly 8 GB build pulled by five people: 40 GB a night, over a terabyte a month. On a metered LFS plan that stacks up pack after pack, month after month. USourceControl bundles unlimited storage and bandwidth into a flat per-user price (€25/user/mo on Indie). That same nightly-build scenario costs you nothing extra: no packs, no metering, no overage.
Why Unreal Engine 5 made this worse
The assumptions most version control was sized against came from UE4-era projects, and Unreal Engine 5 broke all of them at once. Nanite meshes ship with their full-detail source geometry instead of hand-authored LOD chains, so an asset that would have been 40 MB before now routinely lands in the hundreds of megabytes. Lumen removed baked lightmaps but pushed teams toward higher-resolution source material to feed it. Virtual textures encourage 8K and 16K inputs that would previously have been downsampled on principle. MetaHuman characters arrive with dense meshes, full groom data, and multi-gigabyte texture sets. Then World Partition and One File Per Actor changed the shape as well as the size: a populated open world level becomes thousands of small binary actor files under __ExternalActors__, on top of the handful of very large ones. Your version control now has to be good at both extremes simultaneously. This is the point where teams on Git LFS discover their storage tier. It is also why unlimited storage and bandwidth is not a marketing line for us but the only sane answer to a UE5 art budget.
What 'large' actually looks like
Files that fit natively, with no LFS config or typemap: • Nanite source meshes with full-detail geometry (200 MB – 3 GB each) • 4K and 8K source textures (100 MB – 2 GB each) • MetaHuman character assets with groom and texture sets (500 MB – 4 GB) • Raw WAV tracks and multi-track DAW sessions (500 MB – 3 GB each) • Substance Painter source files with full texture chains (200 MB – 1 GB each) • FBX character rigs with embedded animations (100 MB – 500 MB each) • Packaged build outputs for playtesting (2 – 5 GB) • Video captures and trailers (500 MB – 5 GB)
Common questions
Is 5 GB really the per-file limit?
Yes. 5 GB is a hard limit per individual file, the same on every plan including Enterprise. Total project size is unlimited, so this only bites on a single enormous file rather than on a big project.
How does USourceControl transfer large files?
The desktop app transfers straight to and from storage over short-lived signed links, several files at a time, with the concurrency tuned to file size. Failed transfers retry automatically. If a commit is interrupted it stays atomic — nothing partial lands, and when you run it again the files that already made it are recognised by their SHA-256 and skipped, so you only re-send what's actually missing.
Do I get charged extra for bandwidth?
No. Bandwidth is unlimited on every plan, Free included. Pull builds as often as your team needs, with no packs, no metering, and no overage charges.
How does incremental sync work?
The desktop app tracks file hashes and only uploads or downloads files that have changed. Unchanged files are skipped entirely, so syncs stay small and bandwidth stays low. Every version you commit is stored and remains fully recoverable.
Can I version 20 GB single files like raw video?
Not as one file — 5 GB is the per-file ceiling on every plan. Split it (a trailer project broken into scenes, a build into its component archives) and commit the pieces. There's no limit on how many pieces, and no limit on total size.
How large can a project get?
There's no storage cap on any plan. Multi-hundred-GB Unreal projects fit without a quota to manage.
Can it handle Nanite mesh file sizes?
Yes. Nanite assets carry full-detail source geometry rather than hand-authored LODs, so they are large by design, often several hundred megabytes and sometimes into the gigabytes. The per-file limit is 5 GB and total storage is unlimited on every plan, Free included.
What about thousands of small One File Per Actor files?
Handled the same way, and it's the other half of the Unreal Engine 5 problem. A populated World Partition level produces thousands of small binary actor files alongside your very large assets. Sync compares hashes and moves only what changed, and a single commit can carry up to 25,000 files. There's no pointer-file layer to bloat, which is where Git LFS starts to struggle.
Stop fighting your tools
From $25/user/mo. Start committing real files, not pointer files.
Create your first project