Creating a new empty branch for a new project

Question

We are using a git repository to store our project. We have our branches departing from the original branch. But now we want to create a small new project to track some documentation. For that we would want to create a new empty branch to start storing our files, and I would want other users of the network to clone that branch.

How can we do that?

I tried some things, but they didn't work.

$ mkdir proj_doc; cd proj_doc
$ git init
$ git add .
$ git commit -m 'first commit'
$ git br proj_doc
$ git co proj_doc
$ git br -d master
$ git push origin proj_doc

It seems to push the branch ok, but when I do a fetch or pull, it downloads information from other branches, and then I also get some extra files from other projects. What's the best solution?

Why do you need to store this in a branch? Branches are usually for some deviations from the same code base. Maybe just starting a new repository would be a better solution. — Benjamin Bannier, Dec 20 '12 at 09:38
Well, we did it before, IIRC, and I would like to do it again, so I'm curious ;) — fazineroso, Dec 20 '12 at 09:44
**"for a new project"** - As @honk I would suggest to put this in a new repository. Two options from there to integrate them. Make it a [`submodule`](http://git-scm.com/book/en/Git-Tools-Submodules) in the original project, e.g. `docs/` pointing to that other repo. Or, if you want to merge the code later, add it as a remote. — gertvdijk, Dec 20 '12 at 23:29
One additional downside of the _orphan_ approach is that you need to keep your `.gitignore`'d files, and also constantly switch between the two roots (branches). So I'm also for the new repo approach, in a new folder, having the same remotes, and pushing to another branch. — simo, Oct 01 '14 at 06:53
possible duplicate of [In git, is there a simple way of introducing an unrelated branch to a repository?](http://stackoverflow.com/questions/1384325/in-git-is-there-a-simple-way-of-introducing-an-unrelated-branch-to-a-repository) — Don Kirkby, Jul 23 '15 at 20:54
we needed a pull request to pull in an older code branch than our repo had a copy of. I needed an empty branch to make sure the PR would create a clean version without history from the newer branch. This helped a lot. — Paul Hodges, Mar 19 '20 at 17:41

score 813 · Accepted Answer · edited Apr 30 '14 at 23:44

813

You can create a branch as an orphan:

git checkout --orphan <branchname>

This will create a new branch with no parents. Then, you can clear the working directory with:

git rm --cached -r .

and add the documentation files, commit them and push them up to github.

A pull or fetch will always update the local information about all the remote branches. If you only want to pull/fetch the information for a single remote branch, you need to specify it.

edited Apr 30 '14 at 23:44

Alter Lagos

12,090
1
70
92

answered Dec 20 '12 at 09:57

Hiery Nomus

17,429
2
41
37

21

Nice answer, but it's kind of annoying that the new branch starts out with all of the files (from the previous branch) staged. – Matt Fenwick Nov 11 '13 at 15:08
I have one issue with this, you cannot cherry-pick into this new branch because you cannot cherry-pick into and empty HEAD. – Ray Jan 18 '14 at 20:42
1

@Ray: If you need to cherry-pick, them branch out of the oldest common parent you need. Cherry picking into an empty repo sound like branching, honestly. – WhyNotHugo Oct 18 '14 at 20:06
just for the reference: upon committing to the branch, one have to push it to the origin: `git push origin ` – Anaderi May 29 '15 at 04:37
14

When issueing `git checkout --orphan `; I don't see any listing of in `git branch`. – Santosh Kumar Jul 25 '15 at 04:43
62

After `git checkout --orphan` one can use `git reset --hard` to delete left over files. – Ilya Kozhevnikov Mar 31 '16 at 09:52
21

The reason why you don't see the branch after `git checkout --orphan ` is because it does not have any commits yet. After the first commit `git branch` prints the new branch. – Krøllebølle Apr 07 '16 at 10:34
1

Thanks @Krøllebølle, for explaining that. It's a very confusing "feature". – Mars Jul 10 '16 at 13:30
15

git clean -fd removes untracked files. – Stephane Gosselin Feb 15 '17 at 17:36
1

If youre trying to create a github PR with all your projects files in it, this wont work. Github wont compare two different histories – light24bulbs Jun 11 '18 at 20:18
Correct @light24bulbs. But that wasn't the intention of the question nor the answer. For a PR just base a branch of master or whichever branch. – Hiery Nomus Jun 14 '18 at 11:20
3

`git clean -f -i -d` To remove literally every thing – Jan 15 '20 at 02:15
Is it possible to create an empty branch on github.com or in Github Desktop? – Nixinova Mar 06 '20 at 06:02
1

As of Git 2.23 `git switch --orphan ` is the preferred way to create orphan branches. – maxrodrigo Jan 13 '22 at 18:21

score 76 · Answer 2 · edited May 18 '20 at 14:40

The correct answer is to create an orphan branch. I explain how to do this in detail on my blog._{(Archived link)}

...

Before starting, upgrade to the latest version of GIT. To make sure you’re running the latest version, run
which git
If it spits out an old version, you may need to augment your PATH with the folder containing the version you just installed.

Ok, we’re ready. After doing a cd into the folder containing your git checkout, create an orphan branch. For this example, I’ll name the branch “mybranch”.
git checkout --orphan mybranch
Delete everything in the orphan branch
git rm -rf .
Make some changes
vi README.txt
Add and commit the changes
git add README.txt
git commit -m "Adding readme file"
That’s it. If you run
git log
you’ll notice that the commit history starts from scratch. To switch back to your master branch, just run
git checkout master
You can return to the orphan branch by running
git checkout mybranch

It's DANGEROUS to just remove everything in the working directory, because any non-trivial project will have untracked files (configuration, environment, cache, etc). — Slava Fomin II, Aug 29 '17 at 11:18

score 31 · Answer 3 · answered Jan 13 '22 at 18:19

2022 Update

As of Git 2.23, you can use git switch --orphan <new branch> to create an empty branch with no history. Unlike git checkout --orphan, all tracked files will be removed.

Once you actually have commits on this branch, it can be pushed to the remote repository:

git switch --orphan <new branch>
git commit --allow-empty -m "Initial commit on orphan branch"
git push -u origin <new branch>

score 16 · Answer 4 · answered Dec 20 '12 at 23:25

16

Make an empty new branch like this:

true | git mktree | xargs git commit-tree | xargs git branch proj-doc

If your proj-doc files are already in a commit under a single subdir you can make the new branch this way:

git commit-tree thatcommit:path/to/dir | xargs git branch proj-doc

which might be more convenient than git branch --orphan if that would leave you with a lot of git rm and git mving to do.

Try

git branch --set-upstream proj-doc origin/proj-doc

and see if that helps with your fetching-too-much problem. Also if you really only want to fetch a single branch it's safest to just specify it on the commandline.

answered Dec 20 '12 at 23:25

jthill

55,082
5
77
137

2

This answer is interesting because it allows you to start another branch/root with totally empty first commit. – Stéphane Gourichon Dec 30 '18 at 19:15
Another way to make an empty branch if you don't mind switching to it is `git checkout --orphan new-branch; git reset --hard` – jthill Apr 30 '19 at 20:33
What's the use of the `xargs`? – Flux Jan 16 '20 at 01:27
@Flux it's just another way of getting the tree id subbed in as a commit-tree arg. – jthill Jan 16 '20 at 02:14
1

I really like this approach, as this allows to create an empty new branch, without leaving your current branch, plus that fact there's an empty commit as a start point. – bric3 Apr 11 '20 at 19:32
1

By the way if the remote branch does not exists, instead of `git branch --set-uptream-to` you can push the empty branch on remote using `git push --set-upstream origin proj-doc:projdoc` (from you current branch). – bric3 Apr 11 '20 at 19:39

Kamal Hossain · Answer 5 · 2020-09-24T09:47:40.217

The best solution is to create a new branch with --orphan option as shown below

git checkout --orphan <branch name>

By this you will be able to create a new branch and directly checkout to the new branch. It will be a parentless branch.

By default the --orphan option doesn't remove the files in the working directory, so you can delete the working directory files by this:

git rm --cached -r

In details what the `--orphan` does:

--orphan <new_branch>
Create a new orphan branch, named <new_branch>, started from <start_point> and switch to it. The first commit made on this new branch will have no parents and it will be the root of a new history totally disconnected from all the other branches and commits.

The index and the working tree are adjusted as if you had previously run git checkout <start_point>. This allows you to start a new history that records a set of paths similar to <start_point> by easily running git commit -a to make the root commit.

This can be useful when you want to publish the tree from a commit without exposing its full history. You might want to do this to publish an open source branch of a project whose current tree is "clean", but whose full history contains proprietary or otherwise encumbered bits of code.

If you want to start a disconnected history that records a set of paths that is totally different from the one of <start_point>, then you should clear the index and the working tree right after creating the orphan branch by running git rm -rf . from the top level of the working tree. Afterwards you will be ready to prepare your new files, repopulating the working tree, by copying them from elsewhere, extracting a tarball, etc.

A link to a solution is welcome, but please ensure your answer is useful without it: [add context around the link](//meta.stackexchange.com/a/8259) so your fellow users will have some idea what it is and why it’s there, then quote the most relevant part of the page you're linking to in case the target page is unavailable. [Answers that are little more than a link may be deleted.](//stackoverflow.com/help/deleted-answers) — Yunnosch, Jan 25 '20 at 06:41

score 9 · Answer 6 · edited May 18 '20 at 14:33

9

If your git version does not have the --orphan option, this method should be used:

git symbolic-ref HEAD refs/heads/<newbranch> 
rm .git/index 
git clean -fdx

After doing some work:

git add -A
git commit -m <message>
git push origin <newbranch>

edited May 18 '20 at 14:33

TheTechRobo the Nerd

1,249
15
28

answered Sep 09 '14 at 12:46

cyb0k

2,478
23
19

3

Be careful, `git clean` can delete files you don't want to delete! Run `git clean -ndx` first to see what files it will delete before you run it for real with the `-f` option. – Lassi Oct 17 '18 at 20:08

score 8 · Answer 7 · edited Nov 08 '18 at 23:13

Let's say you have a master branch with files/directories:

> git branch  
master
> ls -la # (files and dirs which you may keep in master)
.git
directory1
directory2
file_1
..
file_n

Step by step how to make an empty branch:

git checkout —orphan new_branch_name
Make sure you are in the right directory before executing the following command:
ls -la |awk '{print $9}' |grep -v git |xargs -I _ rm -rf ./_
git rm -rf .
touch new_file
git add new_file
git commit -m 'added first file in the new branch'
git push origin new_branch_name

In step 2, we simply remove all the files locally to avoid confusion with the files on your new branch and those ones you keep in master branch. Then, we unlink all those files in step 3. Finally, step 4 and after are working with our new empty branch.

Once you're done, you can easily switch between your branches:

git checkout master 
git checkout new_branch

score 6 · Answer 8 · answered Feb 19 '20 at 12:42

On base this answer from Hiery Nomus.

You can create a branch as an orphan:

git checkout --orphan <branchname>

This will create a new branch with no parents. Then, you can clear the working directory with:

git rm --cached -r .

And then you just commit branch with empty commit and then push

git commit -m <commit message> --allow-empty
git push origin <newbranch>

score 5 · Answer 9 · answered Sep 06 '21 at 18:00

5

I found it here

If you use git 2.23 or above you may be used to git switch and git restore instead of git checkout

So if you need to have an empty branch try this:

git switch --orphan YourNewBranch

That's it :))

answered Sep 06 '21 at 18:00

Mehdi Soltani

163
3
13

score 4 · Answer 10 · answered Jun 10 '20 at 07:17

4

i found this help:

git checkout --orphan empty.branch.name
git rm --cached -r .
echo "init empty branch" > README.md
git add README.md
git commit -m "init empty branch"

answered Jun 10 '20 at 07:17

Qi Huaheng

41
2

I'm guessing we do this to create a "RELEASE branch" that can never be accidentally merged back into develop, right? – djangofan Feb 26 '21 at 17:36

Creating a new empty branch for a new project

10 Answers10

2022 Update

In details what the `--orphan` does:

Step by step how to make an empty branch:

Linked

Related

Creating a new empty branch for a new project

10 Answers10

2022 Update

In details what the --orphan does:

Step by step how to make an empty branch:

Linked

Related

In details what the `--orphan` does: