Skip to main content

Settings and commands

This guide covers Git commands and advanced settings available in Anchorpoint, including workflow commands, repository management, and configuration options.

Git Commands​

A Git workflow basically has commands that are executed continuously and commands that are needed from time to time.

Timeline Commands​

These commands are available in the Timeline.

Push​

The push uploads the commits (i.e. the project checkpoints) to the server. Once they are uploaded, the team can download them via a pull.

Pull​

The pull downloads commits from the server. After the pull, you are up to date. The pull also happens explicitly, so you can't break anything while working. If a commit has caused problems (e.g. the level in the game engine no longer loads), it can be undone via Undo Commit.

Submodules

After a pull, Anchorpoint also performs a submodule update if you have submodules in your repository.

Submitting New Changes​

These commands are available when clicking on "Changed Files" in the Timeline.

Commit​

This will "freeze" the file versions. A commit is so to speak a version of the project, so a kind of checkpoint. When committing, Anchorpoint duplicates the files in the changed files and puts them in a cache folder. So you can continue to work on the file, for example, overwrite it, because the committed version is practically secured.

Sync​

Sync combines a Commit+Fetch+Pull+Push in one command.

Restoring Previous States​

In Git, there are multiple ways to restore previous states of files.

Revert​

A revert resets your files to the last commit. This means that all changed files are removed. This is useful if you have made accidental changes to a project and want to jump back. Be careful with this operation because it cannot be undone.

Revert is often used when you are experimenting on a scene, for example. You download many assets to try out. When committing, you only want to commit the assets that are in the level. You can revert all unused files with this.

Undo Commit​

Undo commit reverts all file changes in the selected commit. If your commit has not yet been pushed, Undo commit simply reverts that commit. If your commit has already been pushed to the server, Undo commit will create reverted files.

If new files were added in the commit, Undo Commit removes them. They then show up as removed files in the changed files. If a file has been modified, Undo Commit restores the file to its previous state, creating a changed file.

If the changed files are then committed, the old commit has actually been undone. For commits that are not yet pushed to the Git server, Undo commit basically removes the commit so that you are in a state before you've entered the commit message.

Restore​

You can restore file versions from any commits. To do this, select a commit in your project. Select the files and choose "Restore" from the context menu. You have two options:

  • Overwrite: Overwrites the current file version with the version from the commit you selected.
  • Keep Original: Don't touch the current file version and create a new file with the appendix "_restored".

Checkout​

You can reset the entire project to a previous state. Click on a commit and select "Checkout". This command works only on repositories with access to remote. You must also have committed all changed files beforehand.

Other Commands​

Copy ID​

This command is available when you click on a commit, and copies the commit ID to the clipboard. This is useful if you want to use the Git command line.

Advanced Git Settings​

Joining a Git Repository​

Settings that are applied when cloning a Git repository.

Initialize Submodules​

Some Git repositories contain submodules (which are essentially linked Git repositories). You can tell Anchorpoint to clone these submodules if they are part of the repository. Anchorpoint will also update the submodule on every pull to the main repository.

If you need more granular control on each submodule, you have to disable this option and use the command line for controlling submodule behavior manually.

git submodule update --init --recursive SUBMODULENAME

This will only update the manual initialized submodules on Pull.

Limit Number of Commits​

This uses Git shallow clone. If you want to clone a repository that has a deep commit history, this process can take a long time. You can speed up the clone process by downloading only a set of recent commits. Sometimes this can also help to overcome server problems, since a shallow clone request requires fewer server resources.

If you want to make a Git repository "unshallow" and download the whole history later, you can use this Git command:

git fetch --unshallow

Reconcile Existing Files​

If you already have your files on your computer and want to join a Git repository, you don't have to download them again. Anchorpoint will check all the files in the folder you provide and reconcile them to match the correct version in the repository by checking the SHA of each file.

Connecting via SSH​

SSH (Secure Shell) is a protocol used to securely connect to remote systems over a network. In the context of Git, SSH allows you to authenticate and push/pull code without entering your username and password every time.

The main benefits of using SSH are:

  • Security: SSH uses public-private key encryption, which is more secure than passwords
  • Convenience: Once set up, authentication happens automatically without prompting for credentials
  • Compatibility: SSH works reliably across most Git providers and is especially useful for working with private or self-hosted servers

Anchorpoint supports SSH as an alternative authentication method to HTTPS for connecting to Git hosting providers—except Azure DevOps. If a project was created using an HTTPS URL, you can authenticate using either HTTPS or SSH. However, if the project was set up with an SSH URL (especially for self-hosted Git servers), then every team member must also authenticate via SSH.

Gitea Configuration

On self-hosted Gitea servers, you need to add this to your /conf/app.ini:

[server]
START_SSH_SERVER = true  
SSH_PORT = 222

Selective Checkout​

To save storage space, you can select which folders of a Git repository should be synchronized and which should not. This is useful if, for example, you store your art assets in the Git repository and the programmer in your team does not want to download the art assets.

Another benefit is that selective checkout improves your file tracking performance, especially if you have a repository with millions of files, but you only need to work on a subset of them.

Compatibility

Selective checkout (also called Git sparse checkout) does not work with other Git clients like GitHub Desktop. If you want to work with them in parallel, you will need to download the entire project.

Available Options​

Checkout Folder/Remove Folder​

This command is available in the context menu of the tree view on the left. Downloads the contents of the Git repository or frees up space.

Load Thumbnail​

If you're browsing an online-only folder (not checked out), you won't be able to see thumbnails immediately. To view them, you need to select the files and click the 'Load Thumbnail' button in the top right-hand corner. This will download the file to a cache location and generate a temporary thumbnail. This only works for binary files, not text-based files.

Create Empty Folder​

For example, if you want to create an asset in an "assets" folder (which is your database), but don't want to download all the content in it, you can simply create the empty folder (in this case "assets") as an empty folder, so you can create subfolders or add files to it.

You can customize how Git behaves in Anchorpoint. There are global and project-based settings which you can change.

Workspace Settings​

These settings are available under "Workspace Settings" → "Git" and are applied for all projects.

Show Notifications for New Commits​

As soon as Anchorpoint detects new commits on your Git server, you will receive a push notification.

Disable Git Safe Directory Check​

Off by default. Disabling Git's safe directory check is a security risk because it allows Git to operate in directories not owned by you. In multi-user environments—such as university computer labs or shared Windows systems—malicious users can place a .git directory in a commonly writable location (like /scratch/ or C:\) to exploit Git behavior. Simply navigating into such a directory can compromise your account if Git is triggered (e.g., through a Git-enabled prompt). The safe directory check prevents this by ensuring Git only trusts repositories in directories you own. Disabling it removes this protection and exposes you to potential privilege escalation attacks.

Auto Lock Deleted Files​

Anchorpoint can automatically lock files that are deleted or renamed in the Git repository, if Auto Locking is enabled in the Project Settings. This prevents other users from modifying these files until you push them to the Git repository.

This option has no effect if Auto Locking is disabled in the Project Settings.

Default Commit Operation​

This sets the default operation when committing changes. If set to Sync, Anchorpoint will automatically push and pull changes after committing. If set to Commit, you will need to manually push and pull changes.

Pull Merge Operation​

Anchorpoint provides three operations that are executed when you perform a pull.

  1. Merge: This creates a merge commit using pull fast-forward.
  2. Rebase is possible: This applies Git rebase when Anchorpoint foresees no conflicts and has local commits. If conflicts arise, the pull fast-forward method is applied. So before pulling commits, you have to commit all your files. (default)
  3. Rebase: This will always apply Git rebase and resolve conflicts in the interactive rebase state.

A fast forward merge creates a merge commit, even if there are no conflicts. It looks like a small side-branch was made and then joined back in. The history shows a "bump" with an extra commit that links the two branches.
Benefit: You don’t need to stash in Anchorpoint, and it’s faster.
Downside: You get an extra merge commit that clutters the history.

A rebase rewrites the history so it looks like your work happened directly on top of the main branch. The result is a straight, linear timeline—clean and easy to follow.
Benefit: Clean, readable history.
Downside: You have to stash changes (more file changes temporarily), and it’s slower.

Clear Git File Cache automatically​

The Git LFS stores committed files in a cache under the .git folder. This cache grows as your commit history grows. Anchorpoint can automatically clean it up, saving you disk space.

Open Git Console/ Terminal​

Allows you to open the Git command line. This version of Git is also set up correctly, uses Anchorpoint's version of Git LFS and also uses the shared Git configuration parameters (see below).

Edit Git Config​

The Git config allows you to adjust the parameters of how Git behaves by default. You often tweak it when something is not working the way you want it to. But when you have a team of 50 people, tweaking everyone's Git config can be daunting. That's why Anchorpoint allows you to add shared Git config parameters that are automatically applied to every Anchorpoint user in your workspace.

Say you're using a self-hosted Git server, and you need to adjust the postbuffer because large pushes don't work out of the box. If you add this parameter to Anchorpoint's shared Git config, it will automatically be applied to everyone else.

In general it's recommended to test parameters locally before you add them to the shared Anchorpoint Git config. Parameters that are setup in the Anchorpoint Git config will override the local Git config file.

Git Hooks

For example, if you want to set a custom hooks path using the centralized git config, you need to follow the instructions in the Git documentation, such as "core.hooksPath" as the key and then your directory as the value.

Project Settings​

These settings are available under "Project Settings" → "Git".

Repository URL​

Shows the remote URL. Normally you don't need to change that.

Create .gitkeep Files in New Folders​

By default, Git does not understand empty folders. If you want to create a folder structure with empty folders in a Git repository, Anchorpoint will add a hidden .gitkeep file so they can be uploaded to Git.

Automatically Track All Binary Files as LFS​

Anchorpoint creates the .gitattributes file automatically by adding all binary files which it detects in a commit. If you want to modify this file manually, disable the option.

Auto Lock Binary Files​

This will automatically lock all modified or deleted binary files. When you rename a binary file or folder containing them, Git will show these files as deleted and added. The deleted files will be locked. If Anchorpoint detects any deleted files, a pop-up will ask if you want to lock them.

Unreal Engine Integration

Using the Unreal Engine plugin will disable this option automatically, because locking will be controlled via the plugin.

Auto Lock Text Files​

Anchorpoint locks binary files by default because they cannot be merged. Text files can be merged, so locking is generally not necessary. However, there are some exceptions when it comes to complex document files, such as .unity or .ma (Maya ASCII) files that were edited by the application rather than a text editor. It often makes sense to lock them, because merging them would be extremely difficult in case of conflicts.

Disable on Branches​

The "Disable on Branches" feature allows you to prevent auto-locking from triggering on specific branches. By configuring patterns such as release/*, you can exclude release branches from auto-locking behavior.

Open Git Console/Terminal​

Opens a command line application, so you can use any Git commands. This is more suited for programmers or debugging purposes.

Clear Cache​

This will delete old versions from your hard drive, but not from the server, to free up space on your computer. It will only remove cached files that have already been pushed to your Git server. It will never remove local commits that have not yet been pushed.

This command is called "LFS prune" in Git parlance, and cleans up the entire LFS cache. Anchorpoint also does this automatically based on an interval set in "Workspace Settings" → "Git". By default it's removing cache files older than one week.

Update Credentials​

Opens the login interface where you authorize Anchorpoint with the Git hosting provider (GitHub, GitLab, Azure DevOps etc.). This is useful when you have changed your account.

Refresh Sparse Checkout​

If you see incorrect states in the tree view in the right pane of the Explorer (e.g., wrong cloud icon), you can update the selective checkout index so that Anchorpoint scans all files that have been checked out to show the correct state.