How to solve “fatal: in unpopulated submodule” Error in Git

When working with Git repositories, especially those that include submodules, you might encounter a variety of issues. One such issue is the “fatal: in unpopulated submodule” error. This article aims to dissect the problem, explaining its root causes and offering practical solutions.

What is a Submodule?

Definition and Usage

In Git, a submodule allows a repository to contain another repository within it. This is useful when you have libraries or other types of code that should be shared across multiple projects. By setting a project as a submodule, you can easily manage its version control independently.

# Adding a submodule
git submodule add <repository_url> <path/to/submodule>

Where it’s Used

  • Large scale software projects
  • Microservice architectures
  • Open source projects that depend on external libraries

The “fatal: in unpopulated submodule” Error

When Does it Occur?

The “fatal: in unpopulated submodule” error is most likely to happen when you’ve cloned a repository but haven’t initialized and updated the submodules. This means that the submodule directories exist, but they are empty, thus “unpopulated.”

# Error message example
fatal: in unpopulated submodule 'path/to/submodule'

Root Causes

  1. Uninitialized Submodule: When a repository containing submodules is cloned, the submodules are not automatically initialized.
  2. Stale Submodule Path: The submodule path might be stale or incorrect, causing Git to fail when trying to populate it.
  3. Incorrect Git Operations: Performing Git operations that don’t account for submodules can also trigger this error.

Resolving the Issue

Initialize and Update Submodules

The most straightforward solution is to initialize and update the submodules.

# Navigate to your project directory
cd path/to/your/repo

# Initialize the submodules
git submodule init

# Update the submodules
git submodule update

By running these commands, you populate the submodule directories with the appropriate code, thus resolving the “unpopulated” issue.

Use Recursive Clone

When initially cloning a repository, you can populate submodules automatically by using the --recursive flag.

# Clone repository and submodules
git clone --recursive <repository_url>

This clones not only the main repository but also all its submodules and their submodules recursively.

Manual Cleanup and Re-initialization

If the submodule path is incorrect or stale, you might have to manually delete the submodule directory and then re-add it.

# Remove the submodule directory
rm -rf path/to/submodule

# Re-add the submodule
git submodule add <repository_url> <path/to/submodule>

By doing this, you make sure that the submodule is correctly linked and populated.

Advanced Solutions and Workarounds

Sometimes, the issue may persist even after you’ve tried the basic solutions. In such cases, a deeper understanding of the problem and more advanced solutions are needed.

Deinit and Reinit the Submodule

The Deinit Command

Deinitializing a submodule removes the submodule’s working directory but retains the submodule metadata. This can help in cases where the submodule initialization has gone awry.

# Deinitialize the submodule
git submodule deinit <path/to/submodule>

Reinitialization Steps

After deinitializing, you should reinitialize and update the submodule.

# Initialize and update the submodule
git submodule update --init <path/to/submodule>

Check for Configuration Issues

Validate .gitmodules File

Sometimes, the .gitmodules file may contain incorrect information. Open the file and verify that the submodule paths and URLs are correct.

# Sample .gitmodules content
[submodule "path/to/submodule"]
    path = path/to/submodule
    url =

Remove and Re-add Submodule in .gitmodules

If you find discrepancies in .gitmodules, you can remove the problematic submodule entry and then re-add it.

# Remove submodule entry from .gitmodules
git config --file=.gitmodules --remove-section submodule.<path/to/submodule>

# Add it back with correct information
git submodule add <correct_repository_url> <path/to/submodule>

Use Git Hooks for Automation

What are Git Hooks?

Git hooks allow you to run custom scripts whenever specific Git events occur. For example, you can automate the submodule update process whenever you pull the latest changes from the repository.

How to Implement

Create a script in the .git/hooks directory inside your repository. For instance, you could create a post-merge hook.

# Navigate to hooks directory
cd path/to/your/repo/.git/hooks

# Create a post-merge hook
echo 'git submodule update --init --recursive' > post-merge

# Make the hook executable
chmod +x post-merge

With this hook in place, the submodules will automatically update after you merge changes, reducing the chances of encountering the “unpopulated submodule” error.

Best Practices for Managing Submodules

Efficiently managing submodules can help you avoid the “fatal: in unpopulated submodule” error altogether. Here are some best practices that can keep you on the right track.

Keep Submodules Up to Date

Periodic Updates

Regularly update your submodules to their latest stable versions to ensure compatibility and avoid bugs.

# Update all submodules
git submodule foreach git pull origin master

Automated Version Tracking

Some package managers like npm or pip allow you to specify a range of acceptable versions for dependencies. Similarly, you can track specific branches or tags in your submodules.

# Set a submodule to track a branch
cd path/to/submodule
git checkout -b some-branch origin/some-branch
cd ..
git add path/to/submodule
git commit -m "Set submodule to track some-branch"

Use --recurse-submodules With Git Commands

How it Helps

Including the --recurse-submodules option with commands like git pull, git clone, and git push ensures that submodules are considered in these operations, reducing the likelihood of errors.

# Pull changes from remote including submodules
git pull --recurse-submodules

Beware of Overuse

Note that you might not always want to use this flag. For example, if you’re working on a parent repository and don’t want to modify the submodule, then automatically updating it could cause issues.

Document Submodule Usage

Why It’s Important

Not every team member might be familiar with how submodules work. Good documentation on how to initialize, update, and troubleshoot submodules can save a lot of time and prevent errors.

What to Include

  • Steps to initialize and update submodules
  • How to switch branches in submodules
  • Troubleshooting steps for common errors like “fatal: in unpopulated submodule”


Understanding and handling submodules efficiently is crucial for seamless Git operations. Errors like “fatal: in unpopulated submodule” can disrupt your workflow if not dealt with promptly and effectively.

Through a combination of basic troubleshooting, advanced solutions, and best practices, you can mitigate these challenges and keep your projects on track.

Related Posts: