How to Delete Files on Git [3 Effective Methods]

Written by

Reviewed by

Last updated: July 26, 2023

Expert verified

SVG Image


To delete files on Git, you can try these methods:

  1. Using the Git rm command: Delete files from your repository and update the staging area.
  2. Git Filter-Branch Command: Delete files from the entire commit history, modifying the commit history.
  3. Leveraging Git Extensions and GUI Clients: Use user-friendly interfaces to delete files.

When deleting files on Git, it’s crucial to avoid common errors to maintain a well-structured repository. These errors include accidentally deleting uncommitted changes, deleting files from the wrong branch, deleting files from the staged area only, providing an incorrect file path, and deleting files from previous commits. By committing changes, verifying branches, using correct file paths, and being cautious with history modifications, you can confidently delete files on Git without encountering unnecessary issues.

Read the article below to learn different ways to delete files on git and common errors that can occur during the process.

Deleting files on Git may seem like a straightforward task, but it plays a crucial role in maintaining a well-structured and efficient codebase. By strategically removing unnecessary files, you can declutter your repository, improve collaboration, and ensure smoother version control. However, understanding the different methods and potential pitfalls of deleting files on Git is essential to avoid unintended consequences. In this article, I will explore different methods to delete files on Git and common errors that can occur when deleting files on Git.

How to Delete Files on Git

To delete files on Git, you can use the git rm command, leverage the git filter-branch command, or utilize Git extensions and GUI clients like GitKraken. Each method offers a different approach to deleting files on Git, providing flexibility based on your preferences and requirements.

1. Using the Git rm Command

The git rm command is the standard method for deleting files on Git. It allows you to remove files from your repository and update the staging area. By using git rm, you can maintain a clean and accurate version history for your project. To delete files using the git rm command, follow these steps:

  1. Open your command-line interface.
opening terminal 29
  1. Navigate to the root directory of your Git repository.
navigating to root directory of git repository
  1. Run the following command: 

git rm file_path

Replace file_path with the path to the file you want to delete.

deleting file from git repository
  1. Confirm the deletion by running the command to see the changes:

git status

  1. The command will show the changes made to the repository.
verifying that the file is deleted or not
  1. Commit the changes using the command:

git commit -m “Delete file_name”

Replace file_name with the name of the deleted file.

commiting changes made to the repository

2. Git Filter-Branch Command

The git filter-branch command allows you to delete files from the entire commit history. It is a powerful but potentially dangerous method as it modifies the commit history. This method is used when you need to permanently remove files from the entire repository history, such as eliminating sensitive information or large files. Follow these steps:

  1. Back up your repository before performing filter-branch operations.
  2. Open your Terminal and navigate to the root directory of your Git repository.
  3. Run the following command to delete a file from the entire commit history: 

git filter-branch –force –index-filter ‘git rm –cached –ignore-unmatch file_path’ –prune-empty –tag-name-filter cat — –all

Replace file_path with the path to the file you want to delete.

removing specific file from the entire commit history
  1. Git will apply the filter-branch operation, removing the specified file from the entire commit history.

3. Leveraging Git Extensions and GUI Clients:

Git extensions and GUI clients, such as GitHub Desktop, SourceTree, and GitKraken, provide user-friendly interfaces for deleting files. These tools offer intuitive visualizations and streamlined workflows, making file deletion more accessible. Follow these steps:

  1. Go to official website of GitKraken ( ) and download the deb file for debian
downloading gitkraken deb file
  1. Go to the directory containing the downloaded deb file.
navigating to downloads directory 1
  1. Install GitKraken on your computer by running the command:

sudo dpkg -i gitkraken-package-name.deb

Replace gitkraken-package-name.deb with the actual name of the package file you downloaded.

installing gitkraken
  1. Now launch the application by running the command:


  1. The command will open gitkraken.
launching gitkraken
  1. Now click on the Let’s Open a Repository button.
opening repository in gitkraken
  1. Enter the required user detail of your git account. Then click on Use these for Git commits button to proceed further.
entering required details 1
  1. Open the GitKraken repository associated with the file.
click open repo button
  1. Locate the file you want to delete in the file tree.
choosing repository and opening it
  1. Check the View all files box to view all files of the repository then right-click on the file and select Delete.
deleting file using gitkraken
  1. Verify the deletion in the Unstaged Files section and add a commit message explaining the deletion. Now click on the Commit button to commit the deletion.
verifying and commiting deletion

5 Common Errors When Deleting Files on Git

Git provides various methods to delete files, but it’s important to be aware of potential errors that can occur during the process. By being mindful of these common errors and following best practices, you can confidently delete files on Git without encountering unnecessary issues and maintain a well-structured repository. Here are some common errors and their solutions:

  • Accidentally Deleting Uncommitted Changes: Accidentally deleting files without committing changes can lead to permanent loss. Always commit changes before deleting files to ensure they can be recovered if needed. Use git status to check for uncommitted changes before deletion. Remember to create a backup or stash changes if you’re unsure about committing them.
  • 🌳 Deleting Files from the Wrong Branch: Deleting files from the wrong branch can cause conflicts and disrupt your project’s workflow. Make sure you are on the correct branch and verify it using git branch before deleting files. It’s a good practice to switch to the intended branch explicitly using git checkout branch_name to avoid any accidental deletions.
  • 🚧 Deleting Files from Staged Area Only: Deleting files from the staging area only without committing the changes can lead to confusion. Always commit the changes after staging them using git commit -m “Delete file_name”. This ensures that the deletion is recorded in the commit history and can be easily tracked or reverted if necessary.
  • 🗺️ Incorrect File Path: Providing an incorrect file path while using the git rm command can result in failure to delete the intended files. Double-check the file path and use relative or absolute paths correctly to ensure successful deletion. You can use the git status command to verify the file path and confirm that Git recognizes the changes you intend to make.
  • ⚠️ Deleting Files from Previous Commits: Deleting files from previous commits can alter the commit history, causing conflicts and affecting collaboration. Exercise caution when using commands like git filter-branch and ensure you have proper backups and understand the consequences. It’s recommended to consult with your team and have a backup plan in place before modifying the commit history to avoid unintended side effects.

To Sum Up

In this article, I have explored various methods to delete files on Git, including using Git commands, leveraging GUI clients, and understanding Git file structure. While deleting files on Git, it’s important to be aware of common errors that can occur, such as accidentally deleting uncommitted changes, deleting from the wrong branch, and providing incorrect file paths.

To continue expanding your Git proficiency, here are some recommended articles to explore Advanced Git Branching Strategies, Effective Conflict Resolution in Git, and Git Hooks to Automate Workflows and Boost Productivity. By exploring these topics, you’ll enhance your understanding of Git and unlock new possibilities for efficient version control and collaboration. 

Frequently Asked Questions

Can I recover a deleted file in Git?

Yes, Git provides options to recover deleted files if they haven’t been purged from the commit history. You can use the command git checkout commit_hash — file_path to restore the deleted file from a specific commit. This command retrieves the file content from the specified commit and places it in your working directory. It’s important to note that the commit_hash represents the commit ID where the file was still present, and file_path represents the path to the deleted file within the repository. By leveraging this command, you can retrieve deleted files and restore them to your Git repository.

What happens if I delete a file without committing the deletion?

If you delete a file without committing the deletion, Git considers it a local modification. The file will appear in the Changes not staged for commit section when running git status. Git recognizes the deletion as a modification to the working directory but doesn’t reflect in the commit history. To remove the file completely from your repository, you need to commit the deletion using the command git commit -m “Delete file_name”. This creates a commit that records the deletion, and the file is permanently removed from the repository. Remember to provide an appropriate commit message, replacing file_name with the actual name of the deleted file.

What happens if I delete a file that is currently being used by other branches?

If a file is deleted from one branch but still exists in other branches, it can lead to conflicts when merging or switching branches. Git will consider the deletion as a change in one branch and the preservation of the file in other branches as conflicting modifications. When attempting to merge or switch branches, Git will prompt you to resolve the conflict manually. To handle this situation, ensure that all branches referencing the file are updated accordingly. You can either delete the file from all branches or employ proper branch management techniques such as rebasing or merging to synchronize the changes.



Ojash is a skilled Linux expert and tech writer with over a decade of experience. He has extensive knowledge of Linux's file system, command-line interface, and software installations. Ojash is also an expert in shell scripting and automation, with experience in Bash, Python, and Perl. He has published numerous articles on Linux in various online publications, making him a valuable resource for both seasoned Linux users and beginners. Ojash is also an active member of the Linux community and participates in Linux forums.



Akshat is a software engineer, product designer and the co-founder of Scrutify. He's an experienced Linux professional and the senior editor of this blog. He is also an open-source contributor to many projects on Github and has written several technical guides on Linux. Apart from that, he’s also actively sharing his ideas and tutorials on Medium and Attirer. As the editor of this blog, Akshat brings his wealth of knowledge and experience to provide readers with valuable insights and advice on a wide range of Linux-related topics.

Share this article
Shareable URL
Prev Post

How to Install AWS CLI on Ubuntu[17 Proven Steps]

Next Post

How to Install GNOME on Ubuntu [8 Easy Steps]

Leave a Reply

Your email address will not be published. Required fields are marked *

Read next