Remove a file from a Git repository without deleting it from the local filesystem

Question

I want to remove a file from my repository.

git rm file_to_remove.txt

will remove the file from the repository, but it will also remove the file from the local file system. How do I remove this file from the repo without deleting my local copy of the file?

Buitenzorg

Duplicate of Stop tracking and ignore changes to a file in Git – Nubia

It's worth noting that the most upvoted answer is dangerous for some. If you are using a remote repo than when you push your local then pull elsewhere those files you removed from git only WILL BE DELETED. This is mentioned in one of the replies but not commented upon. – Illfated

to do it the right way: stackoverflow.com/questions/57418769/… – Binghi

Critical warning: Please read this answer before pasting accepted answer. https://mcmap.net/q/12673/-remove-a-file-from-a-git-repository-without-deleting-it-from-the-local-filesystem – Calistacalisthenics

@Binghi As far as I can see that linked question has no accepted answer. So what is the right way to do this?? – Batton

As you can see, there are many different variations depending on the desired end result and ramifications that apply to a public/shared repo vs private. Regarding the linked question, I assume both answers work - the one with most upvotes is mine, but the accepted answer uses a new method that did not exist when I wrote my solution. I have not tried the accepted answer. – Binghi

@Zahid Khan 6 years into my career and I still haven't learned to read before I run the command. lol at least this was just junk data, in my case. – Slider

Answer 1

The git rm documentation states:

When --cached is given, the staged content has to match either the tip of the branch or the file on disk, allowing the file to be removed from just the index.

So, for a single file:

git rm --cached file_to_remove.txt

and for a single directory:

git rm --cached -r directory_to_remove

Biweekly

Easily missed because it is not as self explanatory as svn rm --keep-local. – Jellied

But how do I preserve the files on remote servers? This keeps my local one, but if I push and pull from another server, the file gets deleted. I also added a .gitignore for the file, but it still get's removed – Birch

This still removes the files on git pull if you are behind the commit after git rm – Scolex

Maybe instead of git rm --cached mylogfile.log it should be git rm --unstage mylogfile.log for more clearance. – Angeliqueangelis

By switching to other branch, file is removed. – Foppish

Worth noting that, after running the command in the answer, you need to use git commit -m "Commit message" and git push. If you have any other staged changes (check with git status), they will also be committed at this time. – Diameter

Since this is the most accepted answer and doesn't do, what is asked for, i'll tell what I do. I use the command git rm --cached mylogfile.log and delete the file from the repository. To avoid losing the file on productive system i do a backup of the file and pull after this. The file get's deleted as mentioned before and need to be copied back from your backup. This is quite a pain, but i found no better solution for this problem. – Bertrando

For those that have missed in the question that the OP already added to .gitignore, please note that that's a necessary step to make sure the local file isn't deleted during a later merge or pull. You might find this answer helpful as well: https://mcmap.net/q/12673/-remove-a-file-from-a-git-repository-without-deleting-it-from-the-local-filesystem – Expander

Wow, the language in that man page entry is super convoluted. -- I could have read it three times and not realized that it was related to this topic. – Ruperto

@Ruperto That's git for ya! – Horaciohorae

Warning: if you use this method, the files WILL be deleted from any other clones of the same repo. They will ONLY be preserved on your local installation. For example, if you have a live production server and a local development server, removing from cached will affect your production server. – Tester

Answer 2

To remove an entire folder from the repo (like Resharper files), do this:

git rm -r --cached folderName

I had committed some resharper files, and did not want those to persist for other project users.

Malicious

Just an added note for future visitors: Don't use a GUI to "Sync" the commit back to the repo. That will pull the files back down into your local repo. You have to do a Git Push repo branch to actually remove the files from the remote. – Photina

Answer 3

To remove files from the repository based on .gitignore, without deleting them from the local file system:

git rm --cached `git ls-files -i -c -X .gitignore`

For Windows Powershell:

git rm --cached $(git ls-files -i -c -X .gitignore)

Januaryjanuisz

Does not work on Windows. git ls-files -i -X .gitignore works, but I dont know how to send the files to 'git rm'. Do you know how to do that? – Pinebrook

Works on Windows if you use Git Bash instead of cmd-console – Eucharis

Love this. Worked except that I had some files that ended up having spaces in filename. I modified solution here to this: git ls-files -i -X .gitignore | xargs -I{} git rm --cached "{}". Please consider modifying or adding this solution to the answer here, because it is a great tool to have... – Aladdin

I didn't try but it should be tested will it remove also files like .gitkeep which preserves an empty folder in repository. Eg. .gitignore contain folder uploads and repo is forced to keep track of .gitkeep. By removing all from repo under uploads it will remove also .gitkeep. – Foppish

This suggestion worked perfectly in powershell: git rm --cached $(git ls-files -i -X .gitignore) – Chincapin

If the .gitignore in subdirectories shall be evaluated as well, use --exclude-per-directory instead of -X. – Selenography

In CMD, use a for: for /f %x in ('git ls-files -i -X .gitignore') do git rm --cached %x – Frei

Does not work e.g. with git version 2.35.1: git ls-files -i -X .gitignore results in fatal: ls-files -i must be used with either -o or -c – Monetmoneta

What works for me is -c: git rm --cached $(git ls-files -i -c -X .gitignore) – Monetmoneta

Answer 4

As per my Answer here: https://mcmap.net/q/12979/-how-do-i-remove-a-directory-from-a-git-repository

To remove folder/directory or file only from git repository and not from the local try 3 simple steps.

---

Steps to remove directory

git rm -r --cached File-or-FolderName
git commit -m "Removed folder from repository"
git push origin master

---

Steps to ignore that folder in next commits

To ignore that folder from next commits make one file in root named .gitignore and put that folders name into it. You can put as many as you want

.gitignore file will be look like this

/FolderName

---

Callison

Will this delete other people's local files when they pull down your changes though? – Gullet

Answer 5

A more generic solution:

1. Edit .gitignore file.

   echo mylogfile.log >> .gitignore

2. Remove all items from index.

   git rm -r -f --cached .

3. Rebuild index.

   git add .

4. Make new commit

   git commit -m "Removed mylogfile.log"

Thermae

Will this actually delete the file ? – Lamentable

From GitHub? NO. If you have already pushed to github it will not remove it from the site. But it will update your local git repository. – Thermae

The comment you deleted was more eliminated actually :) The problem with the solution rm --cashed is that it will eventually delete the file when one pulls - right ? And this is not what people want when they say "Remove a file from the repository without deleting it from the local filesystem". Now why was the solution above accepted is beyond me - probably the OP was working alone and never pulled ? Dunno. I understand the github "once pushed always there" issue ofc – Lamentable

I don't think there is a 100% solution unless you ask github itself. For now stick to this. Copy file, Add to gitignore, do actual git rm -r, commit, push, restore file. Did you manage to find another solution? – Thermae

My problem is not github - it is that the file will actually be deleted from coworkers when they pull. I don't want the file to be deleted. This has caused me huge issues in the past. So I was wondering if there is really a solution that really does not delete the file. See also the comment inn the accepted answer : stackoverflow.com/questions/1143796/… – Lamentable

Sorry man. I'm stumped. Option 1. inlude a download script that adds files after a pull. Option 2. Configure git update-index --assume-unchanged instead of git rm. – Thermae

Since I'm terrified about destroying data, this answer would be better if it explicitly said whether or not mylogfile.log will be deleted locally at any of those steps. – Trainor

Answer 6

Also, if you have commited sensitive data (e.g. a file containing passwords), you should completely delete it from the history of the repository. Here's a guide explaining how to do that: https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/removing-sensitive-data-from-a-repository

Flung

This answer should include the required commands to complete this task instead of linking to another website. – Shilling

I would also note that I found using the git bfg repo cleaner tool easier and faster. – Collegian

Link is dead, which is why you always put the information in your post instead of just linking to external sites. – Distil

@Distil Thanks for the heads-up, I've updated the answer with current URL (can't really put all the information in the answer though, it's quite a long article). – Flung

Answer 7

Git lets you ignore those files by assuming they are unchanged. This is done by running the git update-index --assume-unchanged path/to/file.txt command. Once marking a file as such, git will completely ignore any changes on that file; they will not show up when running git status or git diff, nor will they ever be committed.

(From https://help.github.com/articles/ignoring-files)

Hence, not deleting it, but ignoring changes to it forever. I think this only works locally, so co-workers can still see changes to it unless they run the same command as above. (Still need to verify this though.)

Note: This isn't answering the question directly, but is based on follow up questions in the comments of the other answers.

Inundate

Hm, I do this but I see that the file can be overwritten if someone else makes changes to it on the repo. – Francklin

This is SUPER dangerous, as any conflicts in such file would prevent you from checking out, while assume locks you out from fixing the conflicts. – Kennet

@Kennet Would running --no-assume-unchanged kind of revert it? Just have to save the file somewhere before doing so? I'm curious because I have database settings files ignored in my local and haven't encountered the situation you described, though I might just be nuking it and just recreating it when I did encounter problems so it was a non-issue for me. – Inundate

@Inundate yeah, that's what I had to. Unasume, and resolve conflict. Or force checkout. If your database setting don't change in your origin that would explain lack of conflicts. – Kennet

Answer 8

If you want to just untrack a file and not delete from local and remote repo then use this command:

git update-index --assume-unchanged  file_name_with_path

Maintopmast

While this is a good answer, it's important to note this doesn't "untrack" a file in the sense that people usually use that word with Git, where an untracked file is one that isn't in the repository history and never has been. What this answer does is keep the file in the repository but prevent Git from noticing that changes have been made to it. That has some significant differences -- most importantly, the file is still present for others, and if someone else makes changes to it and you pull, your local copy can be overwritten without confirmation. – Felike

Answer 9

Ignore the files, remove the files from git, update git (for the removal).

Note : this does not deal with history for sensitive information.

This process definitely takes some undertanding of what is going on with git. Over time, having gained that, I've learned to do processes such as:

1) Ignore the files

• Add or update the project .gitignore to ignore them - in many cases such as yours, the parent directory, e.g. log/ will be the regex to use.
• commit and push that .gitignore file change (not sure if push needed mind you, no harm if done).

2) Remove the files from git (only).

• Now remove the files from git (only) with git rm --cached some_dir/
• Check that they still remain locally (they should!).

3) Add and commit that change (essentially this is a change to "add" deleting stuff, despite the otherwise confusing "add" command!)

• git add .
• git commit -m"removal"

Anathematize

see this questions for details of why this is a bad answer: stackoverflow.com/questions/57418769/… – Airily

@IlyaKolesnikov I looked at that answer and this answer addresses most of the concerns that is raises by using step 3 to commit the deletion change. – Anathematize

Answer 10

Above answers didn't work for me. I used filter-branch to remove all committed files.

Remove a file from a git repository with:

git filter-branch --tree-filter 'rm  file'

Remove a folder from a git repository with:

git filter-branch --tree-filter 'rm -rf directory'

This removes the directory or file from all the commits.

You can specify a commit by using:

git filter-branch --tree-filter 'rm -rf directory' HEAD

Or an range:

git filter-branch --tree-filter 'rm -rf vendor/gems' t49dse..HEAD

To push everything to remote, you can do:

git push origin master --force

Phantasmal

This combined with git rm -r --cached NAME is the trick to remove it from your local git repo and prevent it from affecting anyone who pulls later (by deleting history of the file or directory from git.) – Rinarinaldi

This rewrites git history and you would need to push --force after, this is a bit out of scope with the question I guess. On a public famous repo you can't just change the history line like that as everyone having already cloned the repo would get issues when pulling. – Majestic

From the man page "git filter-branch has a plethora of pitfalls .... Please use an alternative history filtering tool such as git filter-repo". Also, if you are going to rewrite history, I guess you could modify the ignore file at an early age so that the removed item(s) are ignored throughout the new history? – Scleroderma

Answer 11

I would like to add to the accepted answer of @bdonlan.

---

DON'T USE THIS ANSWER TO REMOVE FILE(S) THAT EXISTS ON REMOTE.

git rm --cached filename

---

What the answer is supposed to do?

It is supposed to remove some files from the local staged area that you have mistakenly committed in some previous commit(s).

1. And have not pushed to the remote.
2. And if pushed on remote, others don't care about those changes.

It moves files from Tracked 𝐭𝐨 Untracked state by that what I mean is, it deletes the files and adds them again.

So, git doesn't know about them anymore.

---

What could go wrong?

On remote, there is 𝐧𝐨 such thing as an 𝐮𝐧𝐭𝐫𝐚𝐜𝐤𝐞𝐝 𝐬𝐭𝐚𝐭𝐞, there is 𝐨𝐧𝐥𝐲 𝐭𝐫𝐚𝐜𝐤𝐞𝐝 𝐬𝐭𝐚𝐭𝐞 and that results in havoc.

---

Why?

When collaborating with the team, if you 𝐩𝐮𝐬𝐡 such changes up to remote it will delete those changes on remote and all the team who takes a 𝐩𝐮𝐥𝐥 from 𝐫𝐞𝐦𝐨𝐭𝐞 𝐰𝐢𝐥𝐥 𝐜𝐚𝐮𝐬𝐞 𝐝𝐞𝐥𝐞𝐭𝐢𝐨𝐧 𝐨𝐟 𝐭𝐡𝐨𝐬𝐞 𝐟𝐢𝐥𝐞𝐬 𝐰𝐡𝐢𝐜𝐡 𝐲𝐨𝐮 𝐡𝐚𝐯𝐞 𝐣𝐮𝐬𝐭 𝐫𝐞𝐦𝐨𝐯𝐞𝐝 𝐣𝐮𝐬𝐭 𝐟𝐫𝐨𝐦 𝐬𝐭𝐚𝐠𝐞𝐝.

Summary: You removed files from staged and then pushed them will result in the deletion of files on the collaborating team's local repository as well (𝘸𝘩𝘪𝘭𝘦 𝘺𝘰𝘶 𝘩𝘢𝘷𝘦 𝘵𝘩𝘰𝘴𝘦 𝘧𝘪𝘭𝘦𝘴 𝘢𝘷𝘢𝘪𝘭𝘢𝘣𝘭𝘦 𝘪𝘯 𝘵𝘩𝘦 𝘶𝘯𝘵𝘳𝘢𝘤𝘬𝘦𝘥 𝘴𝘵𝘢𝘨𝘦, 𝘧𝘰𝘳 𝘢𝘭𝘭 𝘵𝘦𝘢𝘮𝘴 𝘪𝘵 will be 𝘨𝘰𝘯𝘦. )

Calistacalisthenics

Without an alternate solution, this is a (very important) comment but not an answer. – Alexipharmic

But, doesn't git keep a history to this file? I mean, we could always revert back? – Mayonnaise

@RaynalGobel yes git has all the history available and you can revert back anytime. But the thing is should you do it? Like you delete your collaborator's file while you have that file available locally? In my case, the lead trusts me and merges my PR blindly. The application wasn't working on his machine while it was working on mine. Think about this scenario! – Calistacalisthenics

Agree with @BrianZ, this is a very important comment. It would be nice to complete it with a suggestion of the right way to do it! – Batton

The OP's question is precisely about removing a file from the Repo. I think this answer is out of place. – Wordbook

Answer 12

This depends on what you mean by 'remove' from git. :)

You can unstage a file using git rm --cached see for more details. When you unstage something, it means that it is no longer tracked, but this does not remove the file from previous commits.

If you want to do more than unstage the file, for example to remove sensitive data from all previous commits you will want to look into filtering the branch using tools like the BFG Repo-Cleaner.

Photoelectric

Answer 13

since rm --cache will delete files in the remote repository, you could use update-index instead
see: https://learn.microsoft.com/en-us/azure/devops/repos/git/ignore-files?view=azure-devops&tabs=visual-studio-2019

Skerry

Answer 14

I used the following simple method to remove some IDE-related files from git as they made the repo look cluttered.

Note: This doesn't remove them from the git history.

Note: If you've accidentially committed passwords the first thing to do is change those passwords.

• Commit or revert any local changes.
• Backup the files locally to another folder.
• Remove the files from your local repo.
• Commit the change where the files are removed.
• Edit your .gitignore file to list the files/folders.
• Copy the files locally back into their original location.
• Run git status and check that the files are not listed.
• Commit the change to .gitignore

Byroad

But when contributors pull your change their local version of the file will be deleted. – Francis

Answer 15

If you want to delete a file in the repository but not in the filesystem, it means that you do not want to keep trace of this file. In Git you have 4 alternatives (as specified here).

1. You can use a .gitignore file. In this case the file/folder is locally untracked.

2. You can edit .git/info/exclude in a similar way as the previous case. Here the difference is that the file is locally untracked.

3. You can use the git update-index assume-unchanged <filename> command to track a file, but the local changes are ignored.

4. You can use git update-index skip-worktree <filename> command to track a file, but the local changes are ignored.

Points 3 and 4 appear to do the same thing, but there are difference. At this link you can find an extensive list of tests about the behavior of these points. To summarize the differences we can say that the flag assume-unchanged assumes that a developer does not touch a file anymore. The flag skip-worktree instructs git to not touch the specific file anymore. It is useful when you add to the repository a configuration file, but you do not want to track its changes.

Shibboleth