Git LFS (Git Large File Storage) is an extension for Git designed specifically to handle large files. Standard Git is highly efficient for managing and versioning source code, but it struggles with large binary files or assets like high-resolution images, videos, datasets, and compiled assets. Git LFS offers a workaround by keeping big files off of the main Git repository, which keeps the main repository quick and light.
Why Do We Need Git LFS (Git Large File Storage)?
When using Git to manage projects with large or frequently changing files, you may run into several challenges:
- Repository Size: Git stores a complete history of all changes, so committing large files repeatedly (like modified images or datasets) can balloon the repository size. This makes cloning, fetching, and pulling take significantly longer.
- Slow Performance: With many large files, Git operations become slower. Actions like cloning and pushing are impacted as Git has to handle all historical versions of these files.
- Binary Files and Merging: Git is optimized for text-based files, making it great for source code but less effective for binary files like images, audio, or video. Binary files can’t be efficiently compared (diffed) or merged by Git, so handling them in version control becomes cumbersome.
- Storage Limits on Platforms: Platforms like GitHub, GitLab, and Bitbucket often have repository size limits or charge extra for larger repos. Using Git LFS, you can keep the main repo size smaller and avoid these limitations.
How Git LFS Works
Instead of storing the entire large file in the repository, Git LFS replaces the file with a small “pointer file” that references the large file. The actual large file is stored separately in a specialized LFS storage location. Here’s how it works in practice:
- Large files tracked by Git LFS are stored on a different Git LFS server, and Git replaces them with a reference in the repository.
- When someone clones or pulls the repository, Git LFS automatically fetches the large files separately from the main Git data, keeping operations fast and efficient.
Example: Setting Up Git LFS on Ubuntu
1. Install Git LFS
First, use the package manager to install Git LFS:
:~$ sudo apt update
:~$ sudo apt install git-lfs
2. Initialize Git LFS in Your Project
You must initialize Git LFS in your project when it has been installed:
:~$ git lfs install
This command configures your repository for Git LFS tracking. This command should only be used once per system.
3. Track Specific File Types with Git LFS
Use git lfs track to specify the types of large files you want to store with Git LFS. For example:
:~$ git lfs track "*.psd" # Track Photoshop files
:~$ git lfs track "*.mp4" # Track video files
:~$ git lfs track "*.zip" # Track zip files
This command creates or updates a .gitattributes file in the root of your project. The .gitattributes file contains instructions for Git LFS on which files to track.
4. Add, Commit, and Push Files
Now, add, commit, and push your files as usual. Git LFS will handle the large files according to the patterns defined in .gitattributes.
:~$ git add . # Stage all changes, including large files
:~$ git commit -m "Add large files with Git LFS" # Commit with a message
:~$ git push origin master/main # Push to the remote repository named “main or master”
5. Clone and Pull Large Files
When someone else clones the repository or pulls updates, Git LFS will automatically download the large files separately from the regular Git data. Ensure they have Git LFS installed on their system to get the actual content of large files instead of pointer files.
:~$ git clone
When to Use Git LFS
Git LFS is ideal if your project includes:
- Large media files (e.g., high-resolution images, video files).
- Binary assets (e.g., compiled application files, executable binaries).
- Large datasets for data science or machine learning projects.
- Any file that changes frequently and doesn’t work well with Git’s standard diff and merge capabilities.
By using Git LFS, you can avoid the limitations of standard Git for large files, enabling you to manage all your project assets more effectively.
