# USourceControl

> Cloud source control built for Unreal Engine 5 teams. Versions .uasset and .umap files, locks binary assets like Blueprints and levels so two people never overwrite each other, and handles both extremes of a UE5 project: very large Nanite meshes and the thousands of small One File Per Actor files a World Partition level produces. Unlimited storage and bandwidth on every plan, including a permanent free tier. Windows desktop app; no server to run.

Not to be confused with `USourceControlHelpers`, a C++ class in Unreal Engine's own source control module. USourceControl is an independent product.

Key facts:
- Purpose-built for Unreal Engine (UE4, UE5 5.0-5.7, and custom forks). Not a general-purpose VCS.
- Per-file, server-authoritative locking. No pointer-file layer, unlike Git LFS.
- Limits: 5 GB per file, 25,000 files per commit, unlimited total storage and bandwidth.
- The Windows desktop app also packages Unreal builds locally (RunUAT BuildCookRun against the user's own engine) and uploads them to Steam (SteamPipe), the Epic Games Store (BuildPatchTool), and itch.io (Butler). Included on every plan, Free included, because it runs on the user's own hardware.
- Store credentials for publishing are encrypted by the OS keychain and stay on the user's machine. They are never transmitted to USourceControl.
- Publishing stops at "uploaded", not "live": Steam does not allow setting the default branch live from the command line (beta branches are allowed), and Epic self-service organizations promote a build from the Epic Developer Portal. Only itch.io goes live immediately on push.
- Plans: Free (1 project, no card) and Team (per seat, unlimited projects/plugins/storage/bandwidth, audit logs, priority and dedicated support, 2 devices per seat). Enterprise by contact.
- Files are private, never indexed, never sold, and never used to train models.

## Start here

- [Home](https://usourcecontrol.com/): What the product is and who it's for
- [Unreal Engine 5 source control](https://usourcecontrol.com/solutions/unreal-engine-5): World Partition, One File Per Actor, and Nanite specifics
- [Pricing](https://usourcecontrol.com/pricing): Per-seat plans, including the permanent free tier
- [Download](https://usourcecontrol.com/download): Windows desktop app; macOS and Linux are Enterprise-only
- [Documentation](https://usourcecontrol.com/docs): Setup walkthrough from zero to first commit
- [API reference](https://usourcecontrol.com/docs/api): REST API authenticated with usc_ project keys

## Guides

- [Set up source control for Unreal Engine 5](https://usourcecontrol.com/guides/unreal-engine-source-control-setup): Step-by-step first-commit walkthrough
- [Publish an Unreal Engine game to Steam](https://usourcecontrol.com/guides/publish-unreal-game-to-steam): Packaging, depots, SteamPipe, Steam Guard, beta branches, plus Epic and itch.io
- [Create a demo for your Unreal Engine game](https://usourcecontrol.com/guides/create-demo-unreal-engine-game): Choosing what ships, overriding what differs, keeping the demo current with the main game, freezing for Next Fest, and publishing to a separate Steam app
- [How to collaborate in Unreal Engine 5](https://usourcecontrol.com/guides/unreal-engine-5-collaboration): Dividing work, the locking habit, and fast onboarding
- [One File Per Actor and source control](https://usourcecontrol.com/guides/one-file-per-actor-source-control): Why OFPA exists, what it does to a repository, and why locking still matters
- [World Partition team workflow](https://usourcecontrol.com/guides/world-partition-team-workflow): Multi-user open worlds, data layers, and the HLOD decision
- [Best source control for Unreal Engine 5 (2026)](https://usourcecontrol.com/blog/best-source-control-ue5): Honest rundown of Perforce, Git LFS, Lore, Diversion, Anchorpoint, and us
- [Git LFS alternatives for game development](https://usourcecontrol.com/blog/git-lfs-alternatives-game-development): Which of the four LFS failures you're hitting, and which fix addresses it
- [Blueprint merge conflicts](https://usourcecontrol.com/guides/blueprint-merge-conflicts): Why Blueprints can't merge and how to prevent conflicts
- [Migrate from Perforce](https://usourcecontrol.com/guides/migrate-from-perforce): Cutover strategies and history options
- [Game asset versioning best practices](https://usourcecontrol.com/guides/game-asset-versioning-best-practices): What to commit, what to exclude, how to name

## Comparisons

- [All alternatives](https://usourcecontrol.com/alternatives): Neutral overview of every option for Unreal teams
- [vs Perforce](https://usourcecontrol.com/compare/perforce): The AAA standard; strong but needs a server and an admin
- [vs Git LFS](https://usourcecontrol.com/compare/git-lfs): Pointer files, bandwidth billing, and OFPA file counts
- [vs Lore (Unreal Version Control)](https://usourcecontrol.com/compare/lore): Epic's free open-source option; free software, self-hosted cost
- [vs Anchorpoint](https://usourcecontrol.com/compare/anchorpoint): Git+LFS with an artist-friendly client
- [vs Diversion](https://usourcecontrol.com/compare/diversion): Cloud-native, broader large-asset audience
- [vs Plastic SCM / Unity VCS](https://usourcecontrol.com/compare/plastic-scm): Capable, Unity-centric, complex
- [vs Azure DevOps](https://usourcecontrol.com/compare/azure-devops): General-purpose DevOps suite, not game-specific

## By role

- [Solo developers](https://usourcecontrol.com/for/solo-developers): Free forever; the time-machine half of source control
- [Artists](https://usourcecontrol.com/for/artists): Desktop app, no command line
- [Level designers](https://usourcecontrol.com/for/designers): Locking levels and versioning data tables
- [Programmers](https://usourcecontrol.com/for/programmers): API, webhooks, local agent, and no server to maintain
- [Producers](https://usourcecontrol.com/for/producers): Audit logs, access control, and milestone tracking

## Capabilities

- [File locking](https://usourcecontrol.com/solutions/file-locking): Server-authoritative per-file locks for unmergeable binaries
- [Package and publish](https://usourcecontrol.com/solutions/publishing): Local Unreal packaging plus uploads to Steam, the Epic Games Store, and itch.io from the desktop app
- [Large assets](https://usourcecontrol.com/solutions/large-assets): Nanite, 8K textures, packaged builds; no LFS
- [Indie studios](https://usourcecontrol.com/solutions/indie-studios): Private, affordable, no infrastructure
- [Remote teams](https://usourcecontrol.com/solutions/remote-teams): Global CDN and resumable transfers
- [Security](https://usourcecontrol.com/security): Private EU storage, SHA-256 integrity, RBAC, audit logs

## Documentation

The docs are a book: numbered chapters, each with numbered sections, readable end to end. Every section is a static page.

Every page below is also served as clean Markdown at its own URL plus `.md` — https://usourcecontrol.com/docs/desktop-app/branches.md, for example. The complete text of all of it is at https://usourcecontrol.com/llms-full.txt.

- [Introduction: from zero to your first commit](https://usourcecontrol.com/docs): guided walkthrough with interactive demos

### 1. Getting started — Why game projects need different version control, what USourceControl is made of, and how to get your Unreal project into it.

- [1.1 About version control for games](https://usourcecontrol.com/docs/getting-started/about-version-control): Why the tools built for source code struggle with Unreal projects, and what changes when your files are binary.
- [1.2 What USourceControl is](https://usourcecontrol.com/docs/getting-started/what-is-usourcecontrol): Four pieces — a dashboard, a desktop app, a build runner, and a local agent — and which one you actually spend your day in.
- [1.3 Core concepts](https://usourcecontrol.com/docs/getting-started/concepts): Organizations, projects, commits, locks, branches, editions, plugins, and releases — the vocabulary the rest of the book assumes.
- [1.4 Installing the desktop app](https://usourcecontrol.com/docs/getting-started/install-desktop-app): Download, install, and understand how updates behave.
- [1.5 Linking your first project](https://usourcecontrol.com/docs/getting-started/link-a-project): Create the project, generate a key, point the app at your .uproject folder, and take the first pull.

### 2. The desktop app — The daily loop: see what changed, lock what you are editing, commit, pull, and get anything back that you need back.

- [2.1 Recording changes](https://usourcecontrol.com/docs/desktop-app/commit-and-push): Pick the files, write a message worth reading, link the tasks it closes, and push.
- [2.2 Pulling your team's work](https://usourcecontrol.com/docs/desktop-app/pull-incoming-changes): How incoming changes are classified, what the pull card is telling you, and why your local edits are never overwritten.
- [2.3 File locking](https://usourcecontrol.com/docs/desktop-app/file-locking): Claim a level or Blueprint before you open it, so nobody can save over your day.
- [2.4 History and undoing things](https://usourcecontrol.com/docs/desktop-app/history-and-restore): Reverting local changes, bringing back an old version, and reading what a commit actually did.
- [2.5 Branches](https://usourcecontrol.com/docs/desktop-app/branches): Take a line of work away from main, then bring it back without leaving anyone's assets behind.
- [2.6 Shared plugins](https://usourcecontrol.com/docs/desktop-app/plugins): Promote a subfolder to a plugin, mount it into your other projects, and update it deliberately.
- [2.7 Settings, tray, and background mode](https://usourcecontrol.com/docs/desktop-app/settings-and-tray): Close-to-tray, start with the system, the ignore-file editor, and where the build toolchain lives.

### 3. Tasks and planning — A board per project, commits that close cards, and release notes derived from what actually shipped.

- [3.1 The board](https://usourcecontrol.com/docs/tasks/task-board): To Do, Doing, Done, and Blocked, in the desktop app and on the web, backed by the same rows.
- [3.2 Linking commits to tasks](https://usourcecontrol.com/docs/tasks/link-commits-to-tasks): Mention a card with #12, finish it with closes #12, and let the board keep up with the work.
- [3.3 Changelogs from tasks](https://usourcecontrol.com/docs/tasks/release-changelogs): A release's notes are the tasks its commits closed since the last release, not a list of commits.
- [3.4 Voice capture](https://usourcecontrol.com/docs/tasks/voice-capture): Say what needs doing, read the transcript, tick the cards you want. Paid plans.
- [3.5 Handing tasks to a coding agent](https://usourcecontrol.com/docs/tasks/coding-agents): Copy a prompt that tells an agent what to build and lets it move the cards as it works.

### 4. Packaging and publishing — Package your Unreal project with the engine you already have, then send the build to Steam, the Epic Games Store, or itch.io.

- [4.1 Packaging a build](https://usourcecontrol.com/docs/packaging/package-your-game): Pick a version, a platform, and a configuration, and let Unreal's own toolchain do the work.
- [4.2 Publishing to Steam](https://usourcecontrol.com/docs/packaging/publish-to-steam): Point USourceControl at steamcmd once, fill in your app and depot, and upload from the same window you commit in.
- [4.3 Publishing to the Epic Games Store](https://usourcecontrol.com/docs/packaging/publish-to-epic): BuildPatchTool, your organization and product IDs, and the prerequisite installer that decides whether the game starts at all.
- [4.4 Publishing to itch.io](https://usourcecontrol.com/docs/packaging/publish-to-itch): Butler, a target, and a channel. The shortest publishing path there is.
- [4.5 Auto-publish, versions, and history](https://usourcecontrol.com/docs/packaging/auto-publish-and-versions): Send every successful build to a store without a second click, and keep track of what went where.

### 5. Forge, the build runner — Put a machine to work: it claims commits, packages them, tests them, and publishes the result without anyone sitting there.

- [5.1 What Forge is](https://usourcecontrol.com/docs/forge/what-is-forge): A standalone app for a build machine, so packaging stops being something a person does.
- [5.2 Enrolling a runner](https://usourcecontrol.com/docs/forge/enroll-a-runner): Name the machine, copy the token once, install the app, paste it in.
- [5.3 Pipelines](https://usourcecontrol.com/docs/forge/pipelines): Three kinds — package, compile check, editor binaries — plus validation and tests that need no code.
- [5.4 Building every commit](https://usourcecontrol.com/docs/forge/build-on-commit): Turn a pipeline's auto-build on and every push becomes a build.

### 6. Editions and release trains — Ship a demo and a console version of the same game without maintaining copies of it, then release everywhere in one step.

- [6.1 Demo and platform editions](https://usourcecontrol.com/docs/editions/editions): A permanent downstream copy of your game: changes flow one way, and it never merges back.
- [6.2 Scope: what an edition contains](https://usourcecontrol.com/docs/editions/edition-scope): Include and exclude rules decide what is materialized. Content outside the scope never reaches a workspace or a build machine.
- [6.3 Integrating from the main game](https://usourcecontrol.com/docs/editions/integrate-from-main): Bring the main game's newer work into an edition. Files the edition owns are parked for a person to decide.
- [6.4 Release trains](https://usourcecontrol.com/docs/editions/release-trains): Pin one commit, build every edition from it, and hold every store upload until they are all green.

### 7. Administering a team — The things you set up once: projects and their history, people and their roles, keys, the audit trail, and billing.

- [7.1 Projects, files, and history on the web](https://usourcecontrol.com/docs/web-dashboard/projects-and-files): Browse what is committed, see who has what locked, and read any commit, from a browser.
- [7.2 Members, roles, and access](https://usourcecontrol.com/docs/web-dashboard/members-and-roles): Three organization roles, plus per-project membership on top of them.
- [7.3 Project keys](https://usourcecontrol.com/docs/web-dashboard/project-keys): How the desktop app and the API authenticate, why keys are locked to a device, and how to rotate one.
- [7.4 The audit log](https://usourcecontrol.com/docs/web-dashboard/audit-log): Who did what, when: commits, uploads, downloads, access, and membership changes. Studio and above.
- [7.5 Billing and plans](https://usourcecontrol.com/docs/web-dashboard/billing-and-seats): Per seat, monthly or annual, with tax handled at checkout and a portal you control.

### 8. Integrations and automation — Push events into Discord and Slack, subscribe to them from your own service, and drive the desktop app from your own tooling.

- [8.1 Discord and Slack notifications](https://usourcecontrol.com/docs/integrations/chat-notifications): Paste an incoming webhook URL into a project and your channel sees every push as it happens.
- [8.2 Outbound webhooks](https://usourcecontrol.com/docs/integrations/outbound-webhooks): Subscribe your own service to what happens in your organization, with signed deliveries and a retry log.
- [8.3 The local agent](https://usourcecontrol.com/docs/integrations/local-agent): A localhost API inside the desktop app that editor tooling and coding agents can drive.
- [8.4 The REST API](https://usourcecontrol.com/docs/integrations/rest-api): Sync, upload, commit, list versions, and restore, authenticated with a project key.

### Appendix A. API reference — every REST endpoint, with curl and TypeScript

- [API reference index](https://usourcecontrol.com/docs/api): base URL, authentication, errors and rate limits
- [POST /api/v1/auth/validate-key](https://usourcecontrol.com/docs/api/validate-key): Validate project key — Authenticate a project key and receive the caller's identity plus the project and organization it is scoped to. Fields are returned flat, not nested. Project ke
- [POST /api/v1/projects/{projectId}/sync](https://usourcecontrol.com/docs/api/sync): Sync file status — Compare local files against the project's committed state. Send each local path with its SHA-256 as `sha256`. The server returns one status row per file — it do
- [POST /api/v1/projects/{projectId}/files/upload/initiate](https://usourcecontrol.com/docs/api/upload-initiate): Initiate a file upload — Reserve a file version and get a presigned PUT URL. `contentMd5` is required — it is signed into the URL alongside the byte length, so storage rejects any body 
- [POST /api/v1/projects/{projectId}/files/upload/initiate-batch](https://usourcecontrol.com/docs/api/upload-initiate-batch): Initiate up to 1,000 uploads — The batched form of initiate, and what the desktop app uses. Up to 1,000 files per call. Results are per-file and isolated: a file whose content already exists 
- [POST /api/v1/projects/{projectId}/files/upload/confirm](https://usourcecontrol.com/docs/api/upload-confirm): Confirm an upload — Record the uploaded version. The server HEADs the object to prove it landed, then inserts the version row and advances the file's tip. Pass the `storageKey` you
- [POST /api/v1/projects/{projectId}/commits](https://usourcecontrol.com/docs/api/commits): Create commit — Commit confirmed file versions with a message. The array is `fileVersions`, and each entry carries the `version` you confirmed plus an action of add, modify, or
- [GET /api/v1/projects/{projectId}/files/{fileId}/versions](https://usourcecontrol.com/docs/api/versions): List file versions — Committed main-lineage versions of a file, newest first, each with a short-lived presigned download URL. The response is keyset-paginated as `data` + `nextCurso
- [POST /api/v1/projects/{projectId}/restore](https://usourcecontrol.com/docs/api/restore): Restore file version — Roll one or more files back to an earlier version. The target field is `toVersion`. Nothing is overwritten: each restore writes a NEW version pointing at the ol
- [GET · POST · DELETE /api/v1/projects/{projectId}/locks](https://usourcecontrol.com/docs/api/locks): File locks (exclusive checkout) — Binary Unreal assets can't be merged, so a lock reserves one for editing. GET lists active locks. POST acquires them for a set of `fileIds` (with an optional `n

## Glossary

Definitions written for an Unreal Engine audience:

- [Audit log](https://usourcecontrol.com/glossary/audit-log): A tamper-resistant record of every action on a source control system: commits, syncs, lock/unlock events, permission changes. Used by producers and compliance officers to answer 'who did what when.'
- [Binary file](https://usourcecontrol.com/glossary/binary-file): A file stored in a non-text format: textures, audio, compiled code, Unreal .uasset, most FBX. Source control systems can version binary files but generally can't merge them, which is why locking matters.
- [Branch](https://usourcecontrol.com/glossary/branch): A parallel line of development. In Git-style systems, branches are cheap and common. In game workflows with heavy binary assets, branches are used sparingly because merging binaries is impossible.
- [Commit](https://usourcecontrol.com/glossary/commit): A snapshot of your project at a point in time, recorded with an author, a message, and a timestamp. Commits are the atomic unit of history. You can return to any commit later.
- [Depot (Perforce)](https://usourcecontrol.com/glossary/depot): Perforce's term for the server-side storage of a project's files and history. Analogous to a 'repository' in Git. Administered via Perforce server tooling.
- [Dedup / deduplication](https://usourcecontrol.com/glossary/deduplication): Storing identical content only once regardless of how many times it appears. USourceControl keeps every version independently rather than deduplicating storage, and instead saves bandwidth by only syncing files that actually changed.
- [Exclusive checkout](https://usourcecontrol.com/glossary/exclusive-checkout): A synonym for file locking. You 'check out' a file exclusively, meaning only you can edit it until you check it back in.
- [File locking](https://usourcecontrol.com/glossary/file-locking): Reserving a file so that only one person can edit it at a time. Essential for binary files that can't be merged: Unreal Blueprints, levels, materials, DCC source files.
- [Git](https://usourcecontrol.com/glossary/git): The dominant distributed version control system for software engineering. Excellent for text. Struggles with large binary files without extensions like Git LFS.
- [Git LFS](https://usourcecontrol.com/glossary/git-lfs): Git Large File Storage. An extension that stores large files outside the main Git repo, replacing them with 'pointer files.' Reduces repo bloat but adds configuration complexity and bandwidth costs.
- [Hash / checksum](https://usourcecontrol.com/glossary/hash): A short fingerprint of a file's content. USourceControl uses SHA-256 to detect any change, even a single byte. Two files with the same SHA-256 are guaranteed to have identical content.
- [HLOD](https://usourcecontrol.com/glossary/hlod): Hierarchical Level of Detail. Generated proxy meshes that stand in for distant clusters of actors in an Unreal Engine world. Derived data, which makes versioning it a genuine choice.
- [LFS pointer file](https://usourcecontrol.com/glossary/lfs-pointer-file): A small text file that Git LFS uses to stand in for a real large file. If a client isn't LFS-aware, the pointer file gets committed instead of the real asset, a common source of silent data loss.
- [Merge conflict](https://usourcecontrol.com/glossary/merge-conflict): When two parallel edits to the same file can't be automatically combined. For text, merges are often resolvable. For binary files, they're usually unresolvable and someone's work is lost, which is why locking matters.
- [Nanite](https://usourcecontrol.com/glossary/nanite): Unreal Engine 5's virtualized geometry system. Nanite meshes ship with full-detail source geometry instead of hand-authored LODs, which makes individual assets dramatically larger than their UE4 equivalents.
- [One File Per Actor (OFPA)](https://usourcecontrol.com/glossary/one-file-per-actor): An Unreal Engine 5 feature that saves each actor's data into its own external file instead of into the level, so you no longer need to check out the level file to change an actor inside it.
- [Per-file history](https://usourcecontrol.com/glossary/per-file-history): A version timeline for a single file, independent of the broader commit graph. USourceControl lets you view every version of any file and restore to any prior state in one click.
- [Perforce](https://usourcecontrol.com/glossary/perforce): A centralized source control system (full name Perforce Helix Core) dominant in AAA game dev. Strong at large binary files and locking; weak at remote-team workflows and cost-effectiveness for small studios.
- [Pull / sync](https://usourcecontrol.com/glossary/pull): Fetching changes from the server to your local copy. USourceControl's sync is incremental. It only transfers files that actually changed since your last sync.
- [Push / commit](https://usourcecontrol.com/glossary/push): Sending local changes up to the server, where teammates can pull them. In USourceControl, 'commit' both records the change and pushes it. There's no separate 'local commit' concept.
- [Repository](https://usourcecontrol.com/glossary/repository): The general term for a versioned collection of files. USourceControl uses the term 'project' instead, which better matches how Unreal teams think. Structurally similar to a Git repo or Perforce depot.
- [Restore](https://usourcecontrol.com/glossary/restore): Bringing a prior version of a file back as the current version. In USourceControl, one click from the file history view. History is preserved. Restoring an old version creates a new commit, not a rewrite.
- [SHA-256](https://usourcecontrol.com/glossary/sha-256): A cryptographic hash function that produces a 256-bit fingerprint from any input. USourceControl uses it for file integrity verification.
- [Sync conflict](https://usourcecontrol.com/glossary/sync-conflict): When your local version of a file differs from the server version and you need to decide which wins. Usually prevented by locking for binary files; for text files, USourceControl presents a clear resolution UI.
- [uasset (.uasset)](https://usourcecontrol.com/glossary/uasset): Unreal Engine's binary container format for assets: Blueprints, materials, meshes, textures, animations. Because .uasset files are binary, they cannot be merged, which drives the whole Unreal source control workflow.
- [umap (.umap)](https://usourcecontrol.com/glossary/umap): Unreal Engine's level file format. Historically enormous and the classic collaboration bottleneck; in UE5 with One File Per Actor it shrinks to a shell holding grid and data layer settings.
- [Versioning](https://usourcecontrol.com/glossary/versioning): The practice of keeping every change to every file in a recoverable history. Source control systems do versioning automatically at every commit.
- [World Partition](https://usourcecontrol.com/glossary/world-partition): Unreal Engine 5's automatic world streaming system. Replaces hand-authored sublevels with a spatial grid, and enables One File Per Actor by default, which is what makes real parallel work on one world possible.

## When USourceControl is not the right answer

- You need on-premise storage on hardware you own, for policy or contractual reasons. Consider Lore or Perforce.
- You have infrastructure staff and want to own the whole stack. Self-hosting Lore is free and reasonable.
- Your project is code-only with no large binaries. Plain Git is simpler and free.
- You need macOS or Linux desktop clients outside an Enterprise agreement.
- You want branch-per-task workflows with heavy merging. Plastic SCM / Unity VCS is stronger there.