Large file support
Version control for large binary assets
Game assets are big. Textures measured in gigabytes, packaged builds in tens of gigabytes, multi-track audio sessions that refuse to fit in any repository. USourceControl was built around exactly these files.
Purpose-built
Large files as a first-class citizen
Up to 10 GB per file
Packaged builds, 8K texture arrays, multi-hour audio sessions, game captures — all fit natively in a single commit.
Global CDN delivery
Every download comes from the closest edge. A contractor in Seoul gets the same throughput as your studio in Montreal.
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.
Deduplication
Identical content is stored once, even if the same asset lives in multiple projects. You don't pay for duplicate bytes.
Bandwidth included
No LFS bandwidth packs, no overage fees on normal use. Your plan covers normal team-scale transfer volume.
Why Git LFS falls short
Git was built for small text diffs. Git LFS patches large-file support on top using pointer files — a small text placeholder stored in the repo that refers to the actual 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. GitHub sells 50 GB bandwidth packs at $5 each. A modest team of five pulling a few gigs per week burns through packs quickly — and a nightly build of 8 GB, downloaded by five people, is 40 GB per night, 1.2 TB per month, 24 packs, $120 in LFS fees alone. USourceControl pricing bundles storage and bandwidth into flat per-user tiers. The Indie plan ($25/user/mo) includes 2 TB of user bandwidth per month. For the same 5-person team, that's 10 TB collectively — eight times the LFS scenario above.
What 'large' actually looks like
Real files we see customers commit regularly: • 4K and 8K source textures (100 MB – 2 GB each) • 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 (5 – 10 GB) • Video captures and trailers (500 MB – 5 GB) All of these work natively. No LFS config, no typemap, no workarounds.
FAQ
Common questions
Is 10 GB really the per-file limit?
Yes, 10 GB is the hard limit per file on every plan. For very large single files, contact us — we've helped studios handle custom cases.
How does USourceControl transfer large files?
Uploads and downloads use a direct edge-CDN path with resumable transfers. Interrupted uploads resume from where they stopped; you don't restart a 6 GB transfer over a flaky connection.
Do I get charged extra for bandwidth?
Each plan includes generous per-user bandwidth (500 GB/mo on Solo, 2 TB/user/mo on Indie, 10 TB/user/mo on Studio). Sustained usage beyond that is rare; we contact you if it happens rather than surprise-billing.
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. Content-hash-based dedup means identical files across versions or projects don't pay storage twice.
Can I version 20 GB single files like raw video?
The native per-file limit is 10 GB. For larger individual files, you typically want to split them (e.g., a trailer project broken into scenes) or use the Enterprise plan, which supports custom limits.
What's the largest project you've seen?
Comfortably hundreds of GB to a few TB. The architecture doesn't hit limits until you cross the per-plan storage caps, which go up to 20 TB on Studio and are custom on Enterprise.
Stop fighting your tools
Free for solo developers. Start committing real files, not pointer files.
Start for free