How to use Git LFS for managing large files

Are you tired of struggling with large files in your Git repository? Do you find yourself constantly hitting the file size limit and having to resort to workarounds like splitting files or using external storage solutions? Fear not, for Git LFS is here to save the day!

Git LFS (Large File Storage) is an extension to Git that allows you to manage large files (typically over 100 MB) more efficiently. Instead of storing the entire file in the Git repository, Git LFS stores a pointer to the file and the actual file content in a separate storage system. This means that your Git repository remains lightweight and fast, while still allowing you to version and track your large files.

In this article, we'll go over the basics of Git LFS and show you how to use it to manage your large files. We'll cover installation, configuration, and usage, as well as some best practices and tips for working with Git LFS.


Before you can start using Git LFS, you need to install it on your system. Git LFS is available for Windows, macOS, and Linux, and can be installed using various methods depending on your platform.


On Windows, you can install Git LFS using the official installer from the Git LFS website. Simply download the installer and run it, and Git LFS will be installed and configured for you.

Alternatively, if you're using Git for Windows, you can install Git LFS using the Git for Windows installer. Make sure to select the "Git LFS" component during installation.


On macOS, you can install Git LFS using Homebrew, the popular package manager for macOS. Simply run the following command in your terminal:

brew install git-lfs


On Linux, you can install Git LFS using your system's package manager. The exact command may vary depending on your distribution, but here are some examples:

Alternatively, you can download the binary release from the Git LFS website and install it manually.


Once you've installed Git LFS, you need to configure it for your Git repository. This involves telling Git LFS which files to track and where to store them.

Enabling Git LFS for a repository

To enable Git LFS for a repository, you need to run the following command in the repository's root directory:

git lfs install

This will enable Git LFS for the repository and create a .gitattributes file in the repository's root directory. This file is used to specify which files should be tracked by Git LFS.

Tracking large files

To track a large file with Git LFS, you need to add it to the .gitattributes file and commit the changes. The syntax for specifying a file to be tracked by Git LFS is as follows:

path/to/large/file.extension filter=lfs diff=lfs merge=lfs -text

Let's break down this syntax:

Here's an example .gitattributes file that tracks two large files:

path/to/large/ filter=lfs diff=lfs merge=lfs -text
path/to/large/file2.tar.gz filter=lfs diff=lfs merge=lfs -text

Once you've added the files to the .gitattributes file, you need to commit the changes:

git add .gitattributes
git commit -m "Enable Git LFS and track large files"

Configuring Git LFS storage

By default, Git LFS stores file content on the Git LFS server, which is hosted by GitHub. However, you can also configure Git LFS to use a custom storage system, such as Amazon S3 or your own server.

To configure Git LFS storage, you need to create a .gitconfig file in your home directory (or edit the existing one if it already exists) and add the following configuration:

    url =

Replace with the URL of your custom Git LFS server. You can also specify multiple URLs if you have multiple storage systems:

    url =
    url =


Now that you've installed and configured Git LFS, let's see how to use it in practice.

Cloning a repository with Git LFS

If you're cloning a repository that uses Git LFS, you need to make sure that Git LFS is installed and configured on your system before cloning. Once you've done that, you can clone the repository as usual:

git clone

Git LFS will automatically download the large files and replace the pointers in the repository with the actual file content.

Pushing large files to a repository

When you push changes to a repository that contains large files tracked by Git LFS, Git LFS will automatically upload the file content to the Git LFS server (or your custom storage system) and replace the file content with a pointer.

git add path/to/large/
git commit -m "Add large file"
git push

Pulling large files from a repository

When you pull changes from a repository that contains large files tracked by Git LFS, Git LFS will automatically download the file content and replace the pointers in the repository with the actual file content.

git pull

Checking the status of Git LFS files

You can check the status of Git LFS files in your repository using the git lfs status command. This will show you which files are being tracked by Git LFS and their current status (e.g. whether they're locked or unlocked).

git lfs status

Locking and unlocking Git LFS files

Git LFS allows you to lock and unlock files to prevent concurrent changes. When a file is locked, other users cannot make changes to the file until it is unlocked.

To lock a file, use the git lfs lock command:

git lfs lock path/to/large/

This will lock the file and prevent other users from making changes to it.

To unlock a file, use the git lfs unlock command:

git lfs unlock path/to/large/

This will unlock the file and allow other users to make changes to it.

Best practices and tips

Here are some best practices and tips for working with Git LFS:


Git LFS is a powerful tool for managing large files in Git repositories. By storing file content separately from the Git repository, Git LFS allows you to keep your repository lightweight and fast while still versioning and tracking your large files. With the installation, configuration, and usage tips we've covered in this article, you should be well on your way to using Git LFS effectively in your projects. Happy coding!

Editor Recommended Sites

AI and Tech News
Best Online AI Courses
Classic Writing Analysis
Tears of the Kingdom Roleplay
Hands On Lab: Hands on Cloud and Software engineering labs
GSLM: Generative spoken language model, Generative Spoken Language Model getting started guides
New Programming Language: New programming languages, ratings and reviews, adoptions and package ecosystems
Ethereum Exchange: Ethereum based layer-2 network protocols for Exchanges. Decentralized exchanges supporting ETH
Tactical Roleplaying Games - Best tactical roleplaying games & Games like mario rabbids, xcom, fft, ffbe wotv: Find more tactical roleplaying games like final fantasy tactics, wakfu, ffbe wotv