Reputation: 234654

How do I remove a submodule?

How do I remove a Git submodule? Why can't I do git submodule rm module_name?

Upvotes: 4692

Answers (30)

John Douthat

Reputation: 41189

In modern git (I'm writing this in 2022, with an updated git installation), this has become quite a bit simpler:

Run git rm <path-to-submodule>, and commit.

This removes the filetree at <path-to-submodule>, and the submodule's entry in the .gitmodules file. I.e. all traces of the submodule in your repository proper are removed.

As the docs note however, the .git dir of the submodule is kept around (in the modules/ directory of the main project's .git dir), "to make it possible to checkout past commits without requiring fetching from another repository".
If you nonetheless want to remove this info, manually delete the submodule's directory in .git/modules/, and remove the submodule's entry in the file .git/config. These steps can be automated using the commands

rm -rf .git/modules/<path-to-submodule>, and
git config remove-section submodule.<path-to-submodule>.

Caution: content below is older community wiki instructions. Ignore if you have a modern `git`:

Via the page Git Submodule Tutorial:

To remove a submodule you need to:

Delete the relevant section from the .gitmodules file.
Stage the .gitmodules changes:
git add .gitmodules
Delete the relevant section from .git/config.
Remove the submodule files from the working tree and index:
git rm --cached path_to_submodule (no trailing slash).
Remove the submodule's .git directory:
rm -rf .git/modules/path_to_submodule
Commit the changes:
git commit -m "Removed submodule <name>"
Delete the now untracked submodule files:
rm -rf path_to_submodule

See also: alternative steps below.

Upvotes: 4890

Wisdom Enifome

Reputation: 1

You have to swap the git rm --cached $path_to_submodule and git add .git modules no? I did get an error on the first command: fatal: Please stage your changes to .git modules or stash them to proceed because I had upstaged changes to .git modules. Doing the git add .git modules first solves that.

Upvotes: 0

Roscoe - ROSCODE

Reputation: 39

I wrote an article for how I did it

https://medium.com/@roscoe.kerby/how-to-get-rid-of-submodules-on-git-8294a5de75be

The other way for Windows:

move subfolder subfolder_tmp

git submodule deinit subfolder

git rm --cached subfolder

move subfolder_tmp subfolder

git add subfolder

Adapted from remove git submodule but keep files

Upvotes: 2

Chien-Wei Huang

Reputation: 1851

I recently find out a git project which include many useful git related command: https://github.com/visionmedia/git-extras

Install it and type :

git delete-submodule submodule

Then things are done. The submodule directory will be removed from your repo and still exist in your filesystem. You can then commit the change like: git commit -am "Remove the submodule".

Upvotes: 19

Ozymandias

Reputation: 2778

2024 Answer

Create a script called git_submodule_remove.sh with the following

#!/bin/bash

# https://github.com/panozzaj/conf/blob/master/common/bin/git-submodule-remove

# Quickly totally remove a git submodule. Since this takes a few
# steps, create a custom script to do this.

# See:
#  https://stackoverflow.com/questions/1260748/how-do-i-remove-a-submodule/36593218#36593218
#  https://gist.github.com/myusuf3/7f645819ded92bda6677

submodule_path=$1

[ -d "$submodule_path" ] || (echo 'Specify valid submodule path as first parameter' && exit 1)

# Remove the submodule entry from .git/config
echo "Deinitializing submodule $submodule_path"
git submodule deinit -f $submodule_path

# Remove the submodule directory from the superproject's .git/modules directory
echo "Removing .git/modules for $submodule_path"
rm -rf .git/modules/$submodule_path

# Remove the entry in .gitmodules and remove the submodule directory located at path/to/submodule
echo "Removing files for $submodule_path"
git rm -rf $submodule_path

Then chmod +x git_submodule_remove.sh

Then ./git_submodule_remove ./path/to/submodule

Upvotes: 4

daemondave

Reputation: 305

Because most things in github never go the way the commands tell you you should, you might have to go into the directory that can't be added and delete the .git folder and all it's contents with a command line like:

rm -fr .git*

and then try adding the folder again

git add folder/

That MIGHT work but with the poorly designed github commands it's a crap shoot...

Upvotes: -6

Mansur Ul Hasan

Reputation: 3606

In my opinion you can do this with below three steps

This command will delete content

git submodule deinit -f devops

Now remove the directory

rm -rvf devops

The last step is to remove entry from submodule file

git rm -f devops

This is not it delete module directory from .git hierarchy

cd .git/modules/ && rm -rvf devops

Upvotes: 15

Андрей Тернити

Reputation: 358

Using this post I made an example how to add a submodule, then remove and then add it again.

0) Clone my example repo

Simple way

git clone --remote-submodules --recurse-submodules -j8 https://github.com/AndreiCherniaev/AddsubmoduleRemovesubmoduleAddsubmodule.git
cd AddsubmoduleRemovesubmoduleAddsubmodule/

Or in several steps

git clone  https://github.com/AndreiCherniaev/AddsubmoduleRemovesubmoduleAddsubmodule.git
cd AddsubmoduleRemovesubmoduleAddsubmodule/
git submodule update --remote --merge

1) Add Buildroot as submodule

$ git submodule add -b master https://github.com/buildroot/buildroot myBuildroot/buildroot

2) Remove submodule Buildroot

$ git rm -f myBuildroot/buildroot

3) Add Buildroot as submodule again

$ git submodule add -b master https://github.com/buildroot/buildroot myBuildroot/buildroot
fatal: A git directory for 'myBuildroot/buildroot' is found locally with remote(s):
  origin    https://github.com/buildroot/buildroot
If you want to reuse this local git directory instead of cloning again from
  https://github.com/buildroot/buildroot
use the '--force' option. If the local git directory is not the correct repo
or you are unsure what this means choose another name with the '--name' option.

Because I already have folder 'myBuildroot/buildroot' in my computer, you can remove the folder:

rm -rf .git/modules/myBuildroot/buildroot
git config --remove-section submodule.myBuildroot/buildroot

And go to step 1). Another way to do step 3) is to remove the repo from your computer and clone again from Github, then you can do step 1). Tested with git version 2.34.1

Upvotes: 2

Stephen J

Reputation: 2397

I just found the .gitmodules hidden file, it has a list... you can erase them individually that way. I just had one, so I deleted it. Simple, but it might mess up Git, since I don't know if anything's attached to the submodule. Seems ok so far, aside from libetpan's usual upgrade issue, but that's (hopefully) unrelated.

Upvotes: 9

Sverre Jørn

Reputation: 139

I followed the instructions from this very same guide How do I remove a submodule?

$ git submodule deinit -f <submodule-name>
$ rm -rf .git/modules/<submodule-name>
$ git config -f .gitmodules --remove-section submodule.<submodule-name>
$ git config -f .git/config --remove-section submodule.<submodule-name>
$ git rm --cached <submodule-name>
$ git commit -m 'rm submodule: <submodule-name>'

But it kept saying:

fatal: no submodule mapping found in .gitmodules for path

So what I did is including the path in .gitignore like this (With no asterisk in the end of the path):

<path>

Then I modified any file and did a simple push:

$ git add .
$ git commit -m "Ignoring sharedlibs folder <path> on .gitignore"
$ git push -u origin master

Upvotes: 10

Doug

Reputation: 35206

To remove a submodule added using:

[email protected]:repos/blah.git
MOD_DIR=lib/blah
git submodule add $REPOSITORY $MOD_DIR

Run:

git rm $MOD_DIR

That's it.

For old versions of git (circa ~1.8.5, actually even in 2.26.2) use:

git submodule deinit $MOD_DIR
git rm $MOD_DIR
git config -f .gitmodules --remove-section submodule.$MOD_DIR

Upvotes: 121

justin.m.chase

Reputation: 13685

If you want to remove the submodule without deleting the folder from your local file system here is what worked for me:

MOD=example
git rm --cached -f apps/$MOD
git config -f .gitmodules --remove-section submodule.$MOD

Upvotes: 5

Picaud Vincent

Reputation: 10982

A simple solution using Magit

If you use Magit under Emacs you can proceed as follows:

Go to your project root, then

M-x, magit-list-submodules

then

M-x, magit-submodule-remove

You will be asked which submodule you want to remove.

That's it!

(My Magit version is v3.3.0)

Upvotes: 2

Ashish Sondagar

Reputation: 1093

The best way to remove a submodule from git:

$ git submodule deinit -f <submodule-name>
$ rm -rf .git/modules/<submodule-name>
$ git config -f .gitmodules --remove-section submodule.<submodule-name>
$ git config -f .git/config --remove-section submodule.<submodule-name>
$ git rm --cached <submodule-name>
$ git commit -m 'rm submodule: <submodule-name>'

Upvotes: 11

Tek Kshetri

Reputation: 2347

All the answers look outdated. I am using git version 2.28.0. One line answer is,

git rm path-to-submodule

However, even though the submodule is removed from source control, .git/modules/path-to-submodule still contains the submodule repository and .git/config contains its URL, so you still have to remove those manually:

git config --remove-section submodule.path-to-submodule
rm -rf .git/modules/path-to-submodule

Sometimes, you have to use the -f flag:

$ git rm -f img2vec

For example, because you might get an error like this:

$ git rm img2vec/
error: the following file has changes staged in the index:
    img2vec
(use --cached to keep the file, or -f to force removal)

Upvotes: 17

Black

Reputation: 20342

git submodule deinit <path to submodule>
Remove the section from .gitmodules
git rm <path to submodule>
Delete the module files which you need to remove from your project.
Add the deleted files to git and call git add .gitmodules
Commit and Push

Upvotes: 33

Pooja Singh

Reputation: 986

This worked for me. The above answers were showing this in the terminal and nothing else was happening

'fatal: not removing 'demolibapp' recursively without -r'

demolibapp is my submodule name that I want to remove
git submodule deinit demolibapp
git rm --cached demolibapp -r
rm -rf .git/modules/demolibapp
git add --all
git commit -m "removing extra submodules"
git push
rm -rf demolibapp

Upvotes: 5

thor

Reputation: 22530

Just a note. Since git 1.8.5.2, two commands will do:

git rm -r the_submodule
rm -rf .git/modules/the_submodule

As @Mark Cheverton's answer correctly pointed out, if the second line isn't used, even if you removed the submodule for now, the remnant .git/modules/the_submodule folder will prevent the same submodule from being added back or replaced in the future. Also, as @VonC mentioned, git rm will do most of the job on a submodule.

--Update (07/05/2017)--

Just to clarify, the_submodule is the relative path of the submodule inside the project. For example, it's subdir/my_submodule if the submodule is inside a subdirectory subdir.

As pointed out correctly in the comments and other answers, the two commands (although functionally sufficient to remove a submodule), do leave a trace in the [submodule "the_submodule"] section of .git/config (as of July 2017), which can be removed using a third command:

git config -f .git/config --remove-section submodule.the_submodule 2> /dev/null

Upvotes: 635

VonC

Reputation: 1328022

Since git1.8.3 (April 22d, 2013):

There was no Porcelain way to say "I no longer am interested in this submodule", once you express your interest in a submodule with "git submodule init".
"git submodule deinit" is the way to do so.

The deletion process also uses git rm (since git1.8.5 October 2013).

Summary

The 3-steps removal process would then be:

0. mv a/submodule a/submodule_tmp

1. git submodule deinit -f -- a/submodule    
2. rm -rf .git/modules/a/submodule
3. git rm -f a/submodule
# Note: a/submodule (no trailing slash)

# or, if you want to leave it in your working tree and have done step 0
3.   git rm --cached a/submodule
3bis mv a/submodule_tmp a/submodule

Explanation

rm -rf: This is mentioned in Daniel Schroeder's answer, and summarized by Eonil in the comments:

This leaves .git/modules/<path-to-submodule>/ unchanged.
So if you once delete a submodule with this method and re-add them again, it will not be possible because repository already been corrupted.

git rm: See commit 95c16418:

Currently using "git rm" on a submodule removes the submodule's work tree from that of the superproject and the gitlink from the index.
But the submodule's section in .gitmodules is left untouched, which is a leftover of the now removed submodule and might irritate users (as opposed to the setting in .git/config, this must stay as a reminder that the user showed interest in this submodule so it will be repopulated later when an older commit is checked out).

Let "git rm" help the user by not only removing the submodule from the work tree but by also removing the "submodule.<submodule name>" section from the .gitmodules file and stage both.

git submodule deinit: It stems from this patch:

With "git submodule init" the user is able to tell git they care about one or more submodules and wants to have it populated on the next call to "git submodule update".
But currently there is no easy way they can tell git they do not care about a submodule anymore and wants to get rid of the local work tree (unless the user knows a lot about submodule internals and removes the "submodule.$name.url" setting from .git/config together with the work tree himself).

Help those users by providing a 'deinit' command.
This removes the whole submodule.<name> section from .git/config either for the given submodule(s) (or for all those which have been initialized if '.' is given).
Fail if the current work tree contains modifications unless forced.
Complain when for a submodule given on the command line the url setting can't be found in .git/config, but nonetheless don't fail.

This takes care if the (de)initialization steps (.git/config and .git/modules/xxx)

Since git1.8.5, the git rm takes also care of the:

'add' step which records the url of a submodule in the .gitmodules file: it is need to removed for you.
the submodule special entry (as illustrated by this question): the git rm removes it from the index:
git rm --cached path_to_submodule (no trailing slash)
That will remove that directory stored in the index with a special mode "160000", marking it as a submodule root directory.

If you forget that last step, and try to add what was a submodule as a regular directory, you would get error message like:

git add mysubmodule/file.txt 
Path 'mysubmodule/file.txt' is in submodule 'mysubmodule'

Note: since Git 2.17 (Q2 2018), git submodule deinit is no longer a shell script.
It is a call to a C function.

See commit 2e61273, commit 1342476 (14 Jan 2018) by Prathamesh Chavan (pratham-pc).
^{(Merged by Junio C Hamano -- gitster -- in commit ead8dbe, 13 Feb 2018)}

git ${wt_prefix:+-C "$wt_prefix"} submodule--helper deinit \
  ${GIT_QUIET:+--quiet} \
  ${prefix:+--prefix "$prefix"} \
  ${force:+--force} \
  ${deinit_all:+--all} "$@"

Upvotes: 2684

yozniak

Reputation: 695

With git v2.7.4 simple 3 steps worked just fine.

git submodule deinit -f -- a/submodule    
git rm -f a/submodule
git commit

Upvotes: 12

Rahul Dapke

Reputation: 355

To summarize, this is what you should do :

Set path_to_submodule var (no trailing slash):

path_to_submodule=path/to/submodule

Delete the relevant line from the .gitmodules file:

git config -f .gitmodules --remove-section submodule.$path_to_submodule

Delete the relevant section from .git/config

git config -f .git/config --remove-section submodule.$path_to_submodule

Unstage and remove $path_to_submodule only from the index (to prevent losing information)

git rm --cached $path_to_submodule

Track changes made to .gitmodules

git add .gitmodules

Commit the superproject

git commit -m "Remove submodule submodule_name"

Delete the now untracked submodule files

rm -rf $path_to_submodule

rm -rf .git/modules/$path_to_submodule

If this fails

The commands above may fail due to following:

Your git is too old. Then use a newer git. (See below how to.)
You have uncommitted data and might lose data. Then better commit them first.
Your submodule is not clean in a git clean sense. Then first clean your submodule using that command. (See below.)
You have done something in the past which is unsupported by git. Then you are on the dark side and things get ugly and complicated. (Perhaps using another machine fixes it.)
Perhaps there are more ways to fail I am not aware of (I am just some git power-user.)

Possible fixes follow.

Use a newer `git`

If your machine is too old there is no submodule deinit in your git. If you do not want (or can) update your git, then just use another machine with a newer git! git is meant to be fully distributed, so you can use another git to get the job done:

workhorse:~/path/to/worktree$ git status --porcelain must not output anything! If it does, cleanup things first!
workhorse:~/path/to/worktree$ ssh account@othermachine
othermachine:~$ git clone --recursive me@workhorse path/to/worktree/.git TMPWORK && cd TMPWORK
Now do the submodule stuff
othermachine:~/TMPWORK$ git commit . -m . && exit
workhorse:~/path/to/worktree$ git fetch account@othermachine:TMPWORK/.git
workhorse:~/path/to/worktree$ git merge --ff-only FETCH_HEAD. If this does not work, use git reset --soft FETCH_HEAD
Now cleanup things, until git status is clean again. You are able to do so, because you have had it clean before, thanks to the first step.

This othermachine can be some VM, or some Ubuntu WSL under Windows, whatever. Even a chroot (but I assume that you are non-root, because if you are root it should be more easy to update to the newer git).

Note that if you cannot ssh in, there are trainloads of ways to transport git repositories. You can copy your worktree on some USB stick (including the .git directory), and clone from the stick. Clone the copy, just to get things in a clean fashion again. This might be a PITA, in case your submodules are not accessible from othermachine directly. But there is a solution for this, too:

git config --add url.NEWURLPREFIX.insteadOf ORIGINALURLPREFIX

You can use this multiply, and this is saved into $HOME/.gitconfig. Something like

git config --add 'url./mnt/usb/repo/.insteadof' https://github.com/

rewrites URLs like

https://github.com/XXX/YYY.git

into

/mnt/usb/repo/XXX/YYY.git

It's easy if you start to become accustomed to powerful git features like this.

Cleanup things first

Cleaning manually up is good, because this way you perhaps detect some things you forgot about.

If git complains about unsaved stuff, commit and push it somewhere safe.
If git complains about some leftovers, git status and git clean -ixfd is your friend
Try to abstain from options to rm and deinit as long as you can. Options (like -f) for git are good if you are a Pro. But as you came here, you probably are not so experienced in the submodule area. So better be safe than sorry.

Example:

$ git status --porcelain
 M two
$ git submodule deinit two
error: the following file has local modifications:
    two
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'two' contains local modifications; use '-f' to discard them
$ cd two
$ git submodule deinit --all
error: the following file has local modifications:
    md5chk
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'md5chk' contains local modifications; use '-f' to discard them
$ cd md5chk
$ git submodule deinit --all
error: the following file has local modifications:
    tino
(use --cached to keep the file, or -f to force removal)
fatal: Submodule work tree 'tino' contains local modifications; use '-f' to discard them
$ cd tino
$ git status --porcelain
?? NEW
$ git clean -i -f -d
Would remove the following item:
  NEW
*** Commands ***
    1: clean                2: filter by pattern    3: select by numbers    4: ask each
    5: quit                 6: help
What now> 1
Removing NEW
$ cd ../../..
$ git status --porcelain
$ git submodule deinit two
Cleared directory 'two'
Submodule 'someunusedname' (https://github.com/hilbix/src.git) unregistered for path 'two'

You see, there is no -f needed on submodule deinit. If things are clean, in a git clean sense. Also note that git clean -x is not needed. This means git submodule deinit unconditionally removes untracked files which are ignored. This is usually what you want, but do not forget about it. Sometimes ignored files might be precious, like cached data which takes hours to days to be calculated again.

Why never remove `$GIT_DIR/modules/<name>/`?

Probably people want to remove the cached repository, because they are afraid to run into a problem later. This is true, but running into that "problem" is the correct way to solve it! Because the fix is easy, and done right you will be able to live happily ever after. This avoids more cumbersome trouble than when you remove the data yourself.

Example:

mkdir tmptest &&
cd tmptest &&
git init &&
git submodule add https://github.com/hilbix/empty.git two &&
git commit -m . &&
git submodule deinit two &&
git rm two &&
git commit -m . &&
git submodule add https://github.com/hilbix/src.git two

The last line outputs following error:

A git directory for 'two' is found locally with remote(s):
  origin    https://github.com/hilbix/empty.git
If you want to reuse this local git directory instead of cloning again from
  https://github.com/hilbix/src.git
use the '--force' option. If the local git directory is not the correct repo
or you are unsure what this means choose another name with the '--name' option.

Why this error? Because .git/modules/two/ previously was populated from https://github.com/hilbix/empty.git and now shall be re-populated from something else, namely https://github.com/hilbix/src.git. You won't see this if you re-populate it from https://github.com/hilbix/empty.git

What to do now? Well, just do exactly as told! Use --name someunusedname

git submodule add --name someunusedname https://github.com/hilbix/src.git two

.gitmodules then looks like

[submodule "someunusedname"]
    path = two
    url = https://github.com/hilbix/src.git

ls -1p .git/modules/ gives

someunusedname/
two/

This way in future you can switch branches/commit forward and backward and will never get into any trouble again, due to two/ having two different (and possibly incompatible) upstream repositories. And the best is: You keep both cached locally, too.

This is not only true for you. It also is true for all others using your repository.
And you do not lose history. In case you forgot to push the very latest version of the old submodule, you can enter the local copy and do so later on. Note that it is quite common that somebody forgets to push some submodules (because this is a PITA for newcomers, until they became accustomed to git).

However if you removed the cached directory, both different checkouts will stumble upon each other, because you will not use the --name options, right? So each time you do the checkout you perhaps have to remove the .git/modules/<module>/ directory again and again. This is extremely cumbersome and makes it hard to use something like git bisect.

So there is a very technical reason to keep this module directory as a placeholder. People who recommend to remove something below .git/modules/ either do not know better or forget to tell you that this makes powerful features like git bisect nearly impossible to use if this crosses such a submodule incompatibility.

A further reason is shown above. Look at the ls. What do you see there?

Well, the 2nd variant of module two/ is not under .git/modules/two/, it is under .git/modules/someunusedname/! So things like git rm $module; rm -f .git/module/$module are totally wrong! You must either consult module/.git or .gitmodules to find the right thing to remove!

So not only most other answers fall into this dangerous trap, even very popular git extensions had this bug (it's now fixed there)! So better keep your hands of the .git/ directory if you do not exactly, what you are doing!

And from the philosophical view, wiping history is always wrong! Except for quantum mechanics, as usual, but this is something completely different.

FYI you probably guessed it: hilbix is my GitHub account.

Upvotes: 15

Porcupine

Reputation: 6475

A submodule can be deleted by running git rm <submodule path> && git commit. This can be undone using git revert.
- The deletion removes the superproject's tracking data, which are both the gitlink entry and the section in the .gitmodules file.
- The submodule's working directory is removed from the file system, but the Git directory is kept around as it to make it possible to checkout past commits without requiring fetching from another repository.
To completely remove a submodule, additionally manually delete $GIT_DIR/modules/<name>/.

Source: git help submodules

Upvotes: 1

rashok

Reputation: 13474

Removing git submodule

To remove a git submodule below 4 steps are needed.

Remove the corresponding entry in .gitmodules file. Entry might be like mentioned below

[submodule "path_to_submodule"]
    path = path_to_submodule
    url = url_path_to_submodule

Stage changes git add .gitmodules
Remove the submodule directory git rm --cached <path_to_submodule>.
Commit it git commit -m "Removed submodule xxx" and push.

Additional 2 more steps mentioned below are needed to clean submodule completely in local cloned copy.

Remove the corresponding entry in .git/config file. Entry might be like mentioned below

[submodule "path_to_submodule"]
    url = url_path_to_submodule

Do rm -rf .git/modules/path_to_submodule

These 5th and 6th steps does not creates any changes which needs commit.

Upvotes: -1

eQ19

Reputation: 10711

In case you need to do it in one line command with bash script as below:

$ cd /path/to/your/repo && /bin/bash $HOME/remove_submodule.sh /path/to/the/submodule

Create bash script file in the $HOME dir named i.e. remove_submodule.sh:

#!/bin/bash

git config -f .gitmodules --remove-section submodule.$1
git config -f .git/config --remove-section submodule.$1
git rm --cached $1
git add .gitmodules
git commit -m "Remove submodule in $1"
rm -rf $1
rm -rf .git/modules/$1
git push origin $(git rev-parse --abbrev-ref HEAD) --force --quiet

Upvotes: 1

Techradar

Reputation: 4154

I've created a bash script to ease the removal process. It also checks whether there are changes in the repo left unsaved and asks for confirmation. It has been tested on os x would be interesting to know if it works as is on common linux distros as well:

https://gist.github.com/fabifrank/cdc7e67fd194333760b060835ac0172f

Upvotes: 2

Thor Samsberg

Reputation: 2279

With git 2.17 and above it's just:

git submodule deinit -f {module_name}
git add {module_name}
git commit

Upvotes: 8

rashok

Reputation: 13474

In latest git just 4 operation is needed to remove the git submodule.

Remove corresponding entry in .gitmodules
Stage changes git add .gitmodules
Remove the submodule directory git rm --cached <path_to_submodule>
Commit it git commit -m "Removed submodule xxx"

Upvotes: 0

laser

Reputation: 1376

Here are the 4 steps that I found necessary or useful (important ones first):

git rm -f the_submodule
rm -rf .git/modules/the_submodule
git config -f .git/config --remove-section submodule.the_submodule
git commit -m "..."

In theory, git rm in step 1 should take care of it. Hopefully, the second part of OP question can be answered positively one day (that this can be done in one command).

But as of July 2017, step 2 is necessary to remove data in .git/modules/ for otherwise, you can't e.g. add the submodule back in the future.

You can probably get away with the above two steps for git 1.8.5+ as tinlyx's answer noted, as all git submodule commands seem to work.

Step 3 removes the section for the_submodule in the file .git/config. This should be done for completeness. (The entry may cause problems for older git versions, but I don't have one to test).

For this, most answers suggest using git submodule deinit. I find it more explicit and less confusing to use git config -f .git/config --remove-section. According to the git-submodule documentation, git deinit:

Unregister the given submodules ... If you really want to remove a submodule from the repository and commit that use git-rm[1] instead.

Last but not least, if you don't git commit, you will/may get an error when doing git submodule summary (as of git 2.7):

fatal: Not a git repository: 'the_submodule/.git'
* the_submodule 73f0d1d...0000000:

This is regardless of whether you do steps 2 or 3.

Upvotes: 10

errordeveloper

Reputation: 6912

Simple steps

Remove config entries:
git config -f .git/config --remove-section submodule.$submodulename
git config -f .gitmodules --remove-section submodule.$submodulename
Remove directory from index:
git rm --cached $submodulepath
Commit
Delete unused files:
rm -rf $submodulepath
rm -rf .git/modules/$submodulename

Please note: $submodulepath doesn't contain leading or trailing slashes.

Background

When you do git submodule add, it only adds it to .gitmodules, but once you did git submodule init, it added to .git/config.

So if you wish to remove the modules, but be able to restore it quickly, then do just this:

git rm --cached $submodulepath
git config -f .git/config --remove-section submodule.$submodulepath

It is a good idea to do git rebase HEAD first and git commit at the end, if you put this in a script.

Also have a look at an answer to Can I unpopulate a Git submodule?.

Upvotes: 241

How do I remove a submodule?

Answers (30)

Caution: content below is older community wiki instructions. Ignore if you have a modern git:

0) Clone my example repo

1) Add Buildroot as submodule

2) Remove submodule Buildroot

3) Add Buildroot as submodule again

A simple solution using Magit

The best way to remove a submodule from git:

Summary

Explanation

If this fails

Use a newer git

Cleanup things first

Why never remove $GIT_DIR/modules/<name>/?

Removing git submodule

Related Questions

Caution: content below is older community wiki instructions. Ignore if you have a modern `git`:

Use a newer `git`

Why never remove `$GIT_DIR/modules/<name>/`?