DEV Community

Rijul Rajesh
Rijul Rajesh

Posted on

Git LFS: The Developer’s Solution to Large File Chaos

#webdev #tutorial #git

If you have ever tried pushing large files like videos, datasets, or design assets into a Git repository, you probably know the pain. Git slows down, the repo size balloons, and cloning takes forever. That is where Git LFS (Large File Storage) comes in.

Git LFS is a simple but powerful extension that helps Git handle large files efficiently. Instead of storing the actual file contents inside your repository, it replaces them with small text pointers and moves the real files to a separate remote storage.

The Problem with Large Files in Git

Git is great at managing code. It tracks changes line by line, stores diffs efficiently, and lets you go back in time with commits. But it was never built for large binary files like images, audio, or videos.

When you commit a 500MB video, Git treats it like any other file. Every version of that file stays in your .git history forever, even if you delete it later. Over time, your repository becomes huge and slow to clone or push.

That’s where Git LFS steps in.

What Git LFS Actually Does

When you install Git LFS and track a file type (for example, *.mp4 or *.zip), something clever happens.

  1. Git LFS replaces the actual file with a pointer file. Instead of the full binary, the repository now stores a small text file that looks something like this: 
   version https://git-lfs.github.com/spec/v1
   oid sha256:fe3b0b8...
   size 26483923
Enter fullscreen mode Exit fullscreen mode

This pointer just says, “Hey, the real file is stored somewhere else, and here’s how to find it.”

  1. The real file is uploaded to LFS storage.
    When you push to GitHub (or GitLab, Bitbucket, etc.), Git LFS sends the large files to a special LFS storage space instead of the main Git repository.

  2. When you clone or pull, Git LFS fetches the real files.
    The pointer files get replaced with the actual binaries on your machine automatically.

The result is a much smaller Git repo that remains fast and easy to manage, even with big assets.

Installing Git LFS

If you are new to Git LFS, getting started is quick.

git lfs install
Enter fullscreen mode Exit fullscreen mode

Then tell Git which files to track. For example:

git lfs track "*.psd"
git lfs track "*.mp4"
Enter fullscreen mode Exit fullscreen mode

This adds patterns to a .gitattributes file. You should commit that file so others on your team use the same LFS settings.

From here on, whenever you add or commit a file matching those patterns, Git LFS will automatically manage it.

Where the Files Actually Live

When you push your repository, the small pointer files go to the main Git repo.
The real large files go to a separate LFS storage managed by your Git hosting service.

  • On GitHub, each repository has its own LFS storage quota.
  • On GitLab, LFS files are stored alongside your project’s other artifacts.
  • You can also host your own LFS server if needed.

So your Git history stays lightweight, and the big files live outside the main version tracking system.

Benefits of Using Git LFS

  • Smaller repositories: You can clone and pull faster since large files are fetched only when needed.
  • Efficient storage: Git history stays clean without redundant copies of large files.
  • Team friendly: Everyone gets the correct versions of large files without bogging down the repo.

It’s especially useful for teams working in game development, machine learning, or design—basically anywhere large binaries are part of the workflow.

A Quick Example

Let’s say you are working on a project that includes video tutorials.

  1. You install and configure Git LFS: 
   git lfs install
   git lfs track "*.mp4"
Enter fullscreen mode Exit fullscreen mode
  1. You commit a new video file: 
   git add lesson1.mp4
   git commit -m "Add intro video"
   git push
Enter fullscreen mode Exit fullscreen mode
  1. Git stores a tiny pointer file in your repository, while the actual video is uploaded to LFS storage.

When your teammate clones the repo, Git LFS automatically downloads the correct video file for them.

Checking File Sizes and Status

If you ever want to see which files are tracked by LFS, you can run:

git lfs ls-files
Enter fullscreen mode Exit fullscreen mode

To view the size of files stored through LFS on GitHub, visit your repository’s Settings → Git LFS section. It will show total usage and per-file statistics.

A Few Notes

  • Git LFS does not automatically compress files; it just stores them efficiently outside Git history.
  • If you later remove files from LFS, you might still need to prune old references using: 
  git lfs prune
Enter fullscreen mode Exit fullscreen mode
  • GitHub gives a limited amount of free LFS storage. Beyond that, you may need to purchase extra quota.

Wrapping up

Git LFS bridges the gap between Git’s text-based version control and the modern need to store large, non-text files.

It keeps repositories lean, speeds up cloning and fetching, and ensures your workflow stays smooth even with massive assets.

If your project involves videos, datasets, or large binaries, Git LFS is absolutely worth enabling. It’s one of those tools that quietly saves you from a lot of future headaches.

If you’ve ever struggled with repetitive tasks, obscure commands, or debugging headaches, this platform is here to make your life easier. It’s free, open-source, and built with developers in mind.

👉 Explore the tools: FreeDevTools

👉 Star the repo: freedevtools

Top comments (0)