How do I delete a file from a Git repository?

Question

How can I delete "file1.txt" from my repository?

Rollie

git rm is the right answer, but remember that the file will still be there in history. If you want to remove a file because it had sensitive information, you'll need to do something more drastic. (Changing history, especially for content you've already pushed, is a drastic action, and should be avoided if possible.) – Dannie

Note: on GitHub, you now can directly delete a file from the web interface (without having to even clone the repo). See my answer below. – Dishonorable

@KeithThompson what steps might that be if I desperately want to do that? – Shively

@lessthanl0l: https://mcmap.net/q/12313/-remove-sensitive-files-and-their-commits-from-git-history/827263 – Dannie

related help.github.com/articles/… – Lymphocyte

@Keith Thompson, git rm file.txt give me the error pathspec 'file.txt' did not match any files. But git status show me a line in green : "deleted: file.txt" so what is the right command if it's not git rm ? I also tried git add but it give the same error – Lonnie

Just something else - you could delete multiple files by using the github.dev interface by clicking . and then selecting multiple files, right-click delete, and then commit via source control on the left sidebar. – Patsy

Answer 1

Use git rm.

If you want to remove the file from the Git repository and the filesystem, use:

git rm file1.txt
git commit -m "remove file1.txt"

But if you want to remove the file only from the Git repository and not remove it from the filesystem, use:

git rm --cached file1.txt
git commit -m "remove file1.txt"

And to push changes to remote repo

git push origin branch_name

Ring

Also handy: git rm -r directory // To remove directory and content – Escolar

That's not going to get rid of that file in other commits though. – Linkoski

@SaulOrtega: That's correct. To remove a file from previous commits (changing past history), see GitHub's help page on Remove sensitive data. – Ring

Take note this will delete the file locally too. If you only want to delete it from the repo do: git rm --cached file1.txt – Temporary

@Juampi yeah quite sure pretty much everyone is just using a local repo, so posting it for that is the perfect way to go... – Brainbrainard

It's worth noting that if that file contained sensitive information (e.g. credentials) you should change those credentials immediately. To quote GitHub "Once you have pushed a commit to GitHub, you should consider any data it contains to be compromised. If you committed a password, change it! If you committed a key, generate a new one." – Finfoot

git rm is a very dangerous command it should be commented in bold that it deletes files from the system too. – Centipede

@Wideem: I don't see how that's anything other than the obvious behaviour of a command named rm. – Ring

@GregHewgill if it was rm command that was obvious but git rm name might suggest that it just removes files from the git, so especially windows users could accidentally delete their precious files – Centipede

@Wideem: If you "delete a precious file" using git rm, then it's still in git, so no problem. – Ring

How is git rm --cached different from gitignore? – Lying

@Shashwat: .gitignore applies only to files that are not tracked. – Ring

what if someone already pulled file1.txt and it is on their local repo. When I delete it (not using --cached), and push, will it be deleted from their local repo when they pull again? – Cruciform

git commit -m " file removed " file1.txt # don't forget to pass file names – Hunchback

Oh god for a right click option in any git tool that merely deletes the file from everywhere. I waste so much time on this godforsaken tool. I'm trying to use this to delete a folder and I get "fatal invalid pathspec did not match any files". I can see the power of this tool but I hate wasting half a day trying to work out how to delete a file. – Riot

Removing the file from git with git rm --cached filename worked perfectly. This --cached only removes files from the cache and not from the filesystem. Running git status shows that the file was deleted, which is exactly what I wanted. – Pent

I misunderstood this command and deleted the file from the remote repo too. I was looking for: git checkout HEAD^ -- /path/to/file https://mcmap.net/q/12390/-git-remove-committed-file-after-push. Git: Remove committed file after push – Concerted

doing a rm 'file' in linux will ony delete it from the fs, not git. Life Saver. – Ambidexter

In bitbucket, you need to do git rm --cached <name of the file to be deleted> and mail the team so that they can do a full removal from bitbucket by running git gc from their side (Ref). How does it work in GitHub? Do we need to contact the support team. My objective is to make sure that the deleted file is removed from entire commit history so that my GitHub size quota is not consumed by these files. – Pediatrics

@GregHewgill Whats the difference between git rm file.txt and manually deleting/removing file from the working directory subsequently committing this manual removal. – Nasty

Answer 2

git rm file.txt removes the file from the repo but also deletes it from the local file system.

To remove the file from the repo and not delete it from the local file system use:
git rm --cached file.txt

The below exact situation is where I use git to maintain version control for my business's website, but the "mickey" directory was a tmp folder to share private content with a CAD developer. When he needed HUGE files, I made a private, unlinked directory and ftpd the files there for him to fetch via browser. Forgetting I did this, I later performed a git add -A from the website's base directory. Subsequently, git status showed the new files needing committing. Now I needed to delete them from git's tracking and version control...

Sample output below is from what just happened to me, where I unintentionally deleted the .003 file. Thankfully, I don't care what happened to the local copy to .003, but some of the other currently changed files were updates I just made to the website and would be epic to have been deleted on the local file system! "Local file system" = the live website (not a great practice, but is reality).

[~/www]$ git rm shop/mickey/mtt_flange_SCN.7z.003
error: 'shop/mickey/mtt_flange_SCN.7z.003' has local modifications
(use --cached to keep the file, or -f to force removal)
[~/www]$ git rm -f shop/mickey/mtt_flange_SCN.7z.003
rm 'shop/mickey/mtt_flange_SCN.7z.003'
[~/www]$ 
[~/www]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   deleted:    shop/mickey/mtt_flange_SCN.7z.003
#
# Changed but not updated:
#   (use "git add <file>..." to update what will be committed)
#   (use "git checkout -- <file>..." to discard changes in working directory)
#
#   modified:   shop/mickey/mtt_flange_SCN.7z.001
#   modified:   shop/mickey/mtt_flange_SCN.7z.002
[~/www]$ ls shop/mickey/mtt_flange_S*
shop/mickey/mtt_flange_SCN.7z.001  shop/mickey/mtt_flange_SCN.7z.002
[~/www]$ 
[~/www]$ 
[~/www]$ git rm --cached shop/mickey/mtt_flange_SCN.7z.002
rm 'shop/mickey/mtt_flange_SCN.7z.002'
[~/www]$ ls shop/mickey/mtt_flange_S*
shop/mickey/mtt_flange_SCN.7z.001  shop/mickey/mtt_flange_SCN.7z.002
[~/www]$ 
[~/www]$ 
[~/www]$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#   deleted:    shop/mickey/mtt_flange_SCN.7z.002
#   deleted:    shop/mickey/mtt_flange_SCN.7z.003
#
# Changed but not updated:
#   modified:   shop/mickey/mtt_flange_SCN.7z.001
[~/www]$

Update: This answer is getting some traffic, so I thought I'd mention my other Git answer shares a couple of great resources: This page has a graphic that help demystify Git for me. The "Pro Git" book is online and helps me a lot.

Klaipeda

You'd then need to commit this with something like git commit -m "Just removing file1.txt" and then, if you have a remote repository, push the commit with something like git push origin master. – Skunk

Answer 3

First, if you are using git rm, especially for multiple files, consider any wildcard will be resolved by the shell, not by the git command.

git rm -- *.anExtension
git commit -m "remove multiple files"

But, if your file is already on GitHub, you can (since July 2013) directly delete it from the web GUI!

Simply view any file in your repository, click the trash can icon at the top, and commit the removal just like any other web-based edit.

Then "git pull" on your local repo, and that will delete the file locally too.
Which makes this answer a (roundabout) way to delete a file from git repo?
(Not to mention that a file on GitHub is in a "git repo")

---

(the commit will reflect the deletion of that file):

And just like that, it’s gone.

For help with these features, be sure to read our help articles on creating, moving, renaming, and deleting files.

Note: Since it’s a version control system, Git always has your back if you need to recover the file later.

The last sentence means that the deleted file is still part of the history, and you can restore it easily enough (but not yet through the GitHub web interface):

See "Restore a deleted file in a Git repo".

Dishonorable

You have to scroll to the bottom and hit "Commit changes" to commit the delete! – Sorbian

This does not work for large text files. The server tries to render the file as in the screenshot and then fails with a 500 error. – Exhilarate

This answer is refering to github, the question is about a git repo. Not how to use the github interface. – Paisano

Peter Marshall, i pushed files on github with secret information, for example. For example, some cache or venv. And I understood that I need to delete them from github as VonC wrote. So, I have deleted them, and then I need to pull the code. Will it delete my cache, venv from the local? How can I push after deleting via github interface in such situation without losing secret information from the local repo? – Essayist

@Essayist That will not delete the files from past commits though. For that, use git-filter-repo, as in here. And a git push --force (so make sure other collaborators know about your new repository history). – Dishonorable

VonC, wow, thank you. But I didn't want to overwrite all my commits, so I afraided using --force. And yesterday I pulled the code and it was worked. Very strange for me, cause earlier I pulled and it deleted my 3 pics from another local repo. It deleted pics which I have deleted from github via interface manually. – Essayist

@Essayist OK, no filter-repo then. – Dishonorable

Answer 4

This is the only option that worked for me.

git filter-branch -f --index-filter 'git rm --cached --ignore-unmatch *.sql'

Note: Replace *.sql with your file name or file type. Be very careful because this will go through every commit and rip this file type out.

EDIT: pay attention - after this command you will not be able to push or pull - you will see the reject of 'unrelated history' you can use 'git push --force -u origin master' to push or pull

Janettjanetta

This is a great answer, but note that in contrast to the other answers, this command rewrites the commit history and removes all trace of the files matching the pattern. This is particularly useful if you found you accidentally committed some sensitive information (and, if needed can successfully use --force to rewrite history of any remote repos this has been pushed to). – Dyestuff

That was exactly the problem that I had and it took some trial and error to get it right. A guy that I was working with had committed several large database dumps into a repo going back through many many commits. Which is why I used .sql in my example. My repo got so bloated and large that github wouldn't accept pushes anymore. – Janettjanetta

If you are using a remote master you need to force a commit and push it up with git push --force -u origin master – Sebiferous

@Sebiferous Sorry I wasn't specific. Github actually wouldn't accept the push because the repo was beyond their size limit. At least several GBs. They cut me off and emailed me about it. So, unfortunately, no amount of forcing a push would help at that point. – Janettjanetta

@JasonGlisson I've also faced that issue where a video got added to a repository by accident. – Sebiferous

@Sebiferous Yeah. I'm definitely not saying this is the ideal solution or the best solution but I've used it a number of times to clean repos that I've inherited. Most of my projects, for my daytime job at least, have moved to private git repos using Gitlabs so I don't have the issue of maxed out repo size limits. – Janettjanetta

Hi @JasonGlisson, after executing the code it immediately alters the commit history which we want. But how do we pushed this to the remote? I execute the code on a local development branch. – Angele

it let me end up in rebase and merge situation – Awning

@Angele Sorry I just saw this comment. Did you get it sorted? I think you'd need to force a git push. A few others mentioned this as well. Curious to hear if you were able to make it work for you. – Janettjanetta

Answer 5

Additionally, if it's a folder to be removed and it's subsequent child folders or files, use:

git rm -r foldername

Disfranchise

This remove the folder from the local as well! Use git rm --cached -r <foldername> – Doll

Answer 6

More generally, git help will help with at least simple questions like this:

zhasper@berens:/media/Kindle/documents$ git help
usage: git [--version] [--exec-path[=GIT_EXEC_PATH]] [--html-path] [-p|--paginate|--no-pager] [--bare] [--git-dir=GIT_DIR] [--work-tree=GIT_WORK_TREE] [--help] COMMAND [ARGS]

The most commonly used git commands are:
   add        Add file contents to the index
   :
   rm         Remove files from the working tree and from the index

Amygdalin

For more complex things, I find git help confusing, but it's good for the simple things :) – Amygdalin

It's not actually that great for git noobs because "index" is not a concept git noobs are familiar with. I speak from personal experience of being a git noob :) Also, I feel it's much less confusing to say that rm stages a file for deletion rather than removes from the index (though it's still meaningless for noobs). – Demoss

Agreeing with romkyns: The description "Remove files from the working tree and from the index" doesn't sound to me like it's a way to remove the file from the repo. Maybe if I understood git better it would. Instead it sounds like you're just unstaging files (and optionally removing them from the working tree -- would that necessarily affect the repo?) – Warwick

Answer 7

The answer by Greg Hewgill, that was edited by Johannchopin helped me, as I did not care about removing the file from the history completely. In my case, it was a directory, so the only change I did was using:

git rm -r --cached myDirectoryName

instead of "git rm --cached file1.txt" ..followed by:

git commit -m "deleted myDirectoryName from git"
git push origin branch_name

Thanks Greg Hewgill and Johannchopin!

Psychopathist

Answer 8

If you want to delete the file from the repo, but leave it in the the file system (will be untracked):

bykov@gitserver:~/temp> git rm --cached file1.txt
bykov@gitserver:~/temp> git commit -m "remove file1.txt from the repo"

If you want to delete the file from the repo and from the file system then there are two options:

1. If the file has no changes staged in the index:

   bykov@gitserver:~/temp> git rm file1.txt
   bykov@gitserver:~/temp> git commit -m "remove file1.txt"
   

2. If the file has changes staged in the index:

   bykov@gitserver:~/temp> git rm -f file1.txt
   bykov@gitserver:~/temp> git commit -m "remove file1.txt"
   

Unreliable

Answer 9

git rm will only remove the file on this branch from now on, but it remains in history and git will remember it.

The right way to do it is with git filter-branch, as others have mentioned here. It will rewrite every commit in the history of the branch to delete that file.

But, even after doing that, git can remember it because there can be references to it in reflog, remotes, tags and such.

If you want to completely obliterate it in one step, I recommend you to use git forget-blob

https://ownyourbits.com/2017/01/18/completely-remove-a-file-from-a-git-repository-with-git-forget-blob/

It is easy, just do git forget-blob file1.txt.

This will remove every reference, do git filter-branch, and finally run the git garbage collector git gc to completely get rid of this file in your repo.

Thoer

In 2021, I tried this and it didn't seem to work. I could still see the file history. Instead I ended up renaming the file with git mv, cleared all contents from the file committed it. – Companionable

This is a phishing attack. Do not click on the link! – Grishilde

Answer 10

According to the documentation.

git rm --cached file1.txt

When it comes to sensitive data—better not say that you removed the file but rather just include it in the last known commit:

0. Amend last commit

git commit --amend -CHEAD

If you want to delete the file from all git history, according to the documentation you should do the following:

1. Remove it from your local history

git filter-branch --force --index-filter \ "git rm --cached --ignore-unmatch PATH-TO-YOUR-FILE-WITH-SENSITIVE-DATA" \  --prune-empty --tag-name-filter cat -- --all
# Replace PATH-TO-YOUR-FILE-WITH-SENSITIVE-DATA with the path to the file you want to remove, not just its filename

2. Don't forget to include this file in .gitignore (If it's a file you never want to share (such as passwords...):

echo "YOUR-FILE-WITH-SENSITIVE-DATA" >> .gitignore
git add .gitignore
git commit -m "Add YOUR-FILE-WITH-SENSITIVE-DATA to .gitignore"

3. If you need to remove from the remote

git push origin --force --all

4. If you also need to remove it from tag releases:

git push origin --force --tags

Bigner

Answer 11

Another way if you want to delete the file from your local folder using rm command and then push the changes to the remote server.

rm file1.txt

git commit -a -m "Deleting files"

git push origin master

Cliffhanger

Answer 12

Note: if you want to delete file only from git use below:

git rm --cached file1.txt

If you want to delete also from hard disk:

git rm file1.txt

If you want to remove a folder(the folder may contain few files) so, you should remove using recursive command, as below:

git rm -r foldername

If you want to remove a folder inside another folder

git rm -r parentFolder/childFolder

Then, you can commit and push as usual. However, if you want to recover deleted folder, you can follow this: recover deleted files from git is possible.

From doc:

git rm [-f | --force] [-n] [-r] [--cached] [--ignore-unmatch] [--quiet] [--] <file>…​

OPTIONS

<file>…​

Files to remove. Fileglobs (e.g. *.c) can be given to remove all matching files. If you want Git to expand file glob characters, you

may need to shell-escape them. A leading directory name (e.g. dir to remove dir/file1 and dir/file2) can be given to remove all files in the directory, and recursively all sub-directories, but this requires the -r option to be explicitly given. -f --force

Override the up-to-date check.

-n --dry-run

Don’t actually remove any file(s). Instead, just show if they exist in the index and would otherwise be removed by the command.

-r

Allow recursive removal when a leading directory name is given.

--

This option can be used to separate command-line options from the list of files, (useful when filenames might be mistaken for

command-line options). --cached

Use this option to unstage and remove paths only from the index. Working tree files, whether modified or not, will be left alone.

--ignore-unmatch

Exit with a zero status even if no files matched.

-q --quiet

git rm normally outputs one line (in the form of an rm command) for each file removed. This option suppresses that output.

Read more on official doc.

Crossways

Answer 13

In my case I tried to remove file on github after few commits but save on computer

git filter-branch -f --index-filter 'git rm --cached --ignore-unmatch file_name_with_path' HEAD
git push --force -u origin master

and later this file was ignored

Relict

Answer 14

To delete a specific file

git rm filename

To clean all the untracked files from a directory recursively in single shot

git clean -fdx

Hosea

git clean -fdx <-- Beware as it will remove everything that is not tracked. – Jacklyn

@Jacklyn By To clean all the untracked files from a directory recursively I meant exactly same. – Hosea

Can be clarified in a better way imho. – Jacklyn

Answer 15

https://mcmap.net/q/14338/-how-do-i-delete-a-file-from-a-git-repository https://mcmap.net/q/14596/-gitignore-settings-included-in-commit Quite similar, tried both. Nothing. Git keeps tracking the file. (I use vscode so the file got instantly marked as U(untracked) or A(added))

Doing this https://mcmap.net/q/14597/-why-is-gitignore-not-ignoring-my-files to whole category solves the problem.

Do this to delete a file from git and make git forget about it:

**manually add the file name to .gitignore**

git rm --cached settings.py    
git commit -m "remove settings.py"
git push origin master
git rm -r --cached .
git add .
git commit -m "Untrack files in .gitignore"

ps: every time it failed I tried to delete file with sensitive info like tokens (.env and settings.py files). But it works fine with random files oO

Pussyfoot

If you have a new question, please ask it by clicking the Ask Question button. Include a link to this question if it helps provide context. - From Review – Greegree

Answer 16

If you have the GitHub for Windows application, you can delete a file in 5 easy steps:

• Click Sync.
• Click on the directory where the file is located and select your latest version of the file.
• Click on tools and select "Open a shell here."
• In the shell, type: "rm {filename}" and hit enter.
• Commit the change and resync.

Burgett

Answer 17

1. First,Remove files from local repository.

   git rm -r File-Name

   or, remove files only from local repository but from filesystem

   git rm --cached File-Name

2. Secondly, Commit changes into local repository.

   git commit -m "unwanted files or some inline comments"   
   

3. Finally, update/push local changes into remote repository.

   git push 
   

Bengal

would this remove everything related with the accidentally added and pushed file? – Herv

@Herv no it will remain in git history – Tetroxide

Answer 18

For the case where git rm doesn't suffice and the file needs to be removed from history: As the git filter-branch manual page now itself suggests using git-filter-repo, and I had to do this today, here's an example using that tool. It uses the example repo https://example/eguser/eg.git

1. Clone the repository into a new directory git clone https://example/eguser/eg.git

2. Keep everything except the unwanted file. git-filter-repo --path file1.txt --invert-paths

3. Add the remote repository origin back : git remote add origin https://example/eguser/eg.git. The git-filter-repo tool removes remote remote info by design and suggests a new remote repo (see point 4). This makes sense for big shared repos but might be overkill for getting rid a single newly added file as in this example.

4. When happy with the contents of local, replace remote with it.

   git push --force -u origin master. Forcing is required due to the changed history.

Also note the useful --dry-run option and a good discussion in the linked manual on team and project dynamics before charging in and changing repository history.

Petrarch

Answer 19

go to your project dir and type:

git filter-branch --tree-filter 'rm -f <deleted-file>' HEAD

after that push --force for delete file from all commits.

git push origin --force --all

Frugivorous

Answer 20

New answer that works in 2022.

Do not use:

git filter-branch

this command might not change the remote repo after pushing. If you clone after using it, you will see that nothing has changed and the repo still has a large size. This command is old now. For example, if you use the steps in https://github.com/18F/C2/issues/439, this won't work.

You need to use

git filter-repo

Steps:

(1) Find the largest files in .git:

git rev-list --objects --all | grep -f <(git verify-pack -v  .git/objects/pack/*.idx| sort -k 3 -n | cut -f 1 -d " " | tail -10)

(2) Strat filtering these large files:

 git filter-repo --path-glob '../../src/../..' --invert-paths --force

or

 git filter-repo --path-glob '*.zip' --invert-paths --force

or

 git filter-repo --path-glob '*.a' --invert-paths --force

or whatever you find in step 1.

(3)

 git remote add origin [email protected]:.../...git

(4)

git push --all --force

git push --tags --force

DONE!

Subjoinder

Answer 21

I tried a lot of the suggested options and none appeared to work (I won't list the various problems). What I ended up doing, which worked, was simple and intuitive (to me) was:

1. move the whole local repo elsewhere
2. clone the repo again from master to your local drive
3. copy back the files/folder from your original copy in #1 back into the new clone from #2
4. make sure that the problem large file is either not there or excluded in the .gitignore file
5. do the usual git add/git commit/git push

Armored

Answer 22

After you have removed the file from the repo with git rm you can use BFG Repo-Cleaner to completely and easily obliterate the file from the repo history.

Ugric

Answer 23

Just by going on the file in your github repository you can see the delete icon beside Raw|Blame and don't forget to click on commit changes button. And you can see that your file has been deleted.

Lucio

Answer 24

I have obj and bin files that accidentally made it into the repo that I don't want polluting my 'changed files' list

After I noticed they went to the remote, I ignored them by adding this to .gitignore

/*/obj
/*/bin

Problem is they are already in the remote, and when they get changed, they pop up as changed and pollute the changed file list.

To stop seeing them, you need to delete the whole folder from the remote repository.

In a command prompt:

1. CD to the repo folder (i.e. C:\repos\MyRepo)
2. I want to delete SSIS\obj. It seems you can only delete at the top level, so you now need to CD into SSIS: (i.e. C:\repos\MyRepo\SSIS)
3. Now type the magic incantation git rm -r -f obj
   • rm=remove
   • -r = recursively remove
   • -f = means force, cause you really mean it
   • obj is the folder
4. Now run git commit -m "remove obj folder"

I got an alarming message saying 13 files changed 315222 deletions

Then because I didn't want to have to look up the CMD line, I went into Visual Sstudio and did a Sync to apply it to the remote

Riot

Answer 25

if your file is sensitive (for example, settings or keys you accidently added and committed) then you can remove it from all versions.

To remove from all versions use the command below (warning: careful because you won't be able to restore the removed file in the repo if do not have a copy):

1. Using Git

git filter-branch --index-filter 'git rm -rf --cached --ignore-unmatch file.ext' HEAD

2. Using git-filter-repo (get it here, new recommended way by Git)

git filter-repo --path file.ext

Cursor

Answer 26

If you need to remove files from a determined extension (for example, compiled files) you could do the following to remove them all at once:

git remove -f *.pyc

Marchpast

Answer 27

Incase if you don't file in your local repo but in git repo, then simply open file in git repo through web interface and find Delete button at right corner in interface. Click Here, To view interface Delete Option

Conceal