Does a git branch name get persisted in a projects history?

I was working on some code in the master branch and needed to switch focus. I (without thinking properly about it) opened a new branch with a vulgar branch name, and committed my code there. Now i need to use this code.

For professional reasons I don't want this vulgar branch name to appear anywhere where my colleagues and bosses might be able to see.

If I branch off of my vulgar branch to a new branch, will their be anything in the history of my new branch, or the master branch after committing, referencing the vulgar branch name?

My assumption is that branch names aren't used, and only the commit history gets recorded?

Git stores branch names not directly into the history. But you should look for merge commits, since there the branch name is part of the commit message. If you did not had any merges of this branch, it won't appear anywhere in the project history. In such a situation you just git checkout -b nice && git branch -D bad-name && git push --delete origin bad-name && git push origin nice.

You can check for bad commits with git log --all --grep bad-name

From a security perspective, your fundamental issue isn't really just that particular branch name, but your overall use of .... let's say things not intended for the public ... in a repository that might eventually be shared with the public.

If the mere name of that branch is already such a big issue, chances are that you might have also used ... wording that you might not want to share with the public ... in other places, such as commit messages, code comments, or even function or variable names.

I would suggest you first squash all of your changes into a single commit, then create a new branch off of whatever you want to merge it into, cherry-pick that single commit and then very carefully go over all of the changes, line-by-line before making any PR or publishing it anywhere.

If you want to be extra cautious:

• Squash all of your changes:
  git rebase -i <last-known-good-commit>
  use fixup everywhere
• Once you only have one commit, export it:
  git log -p -1 > ~/that-commit.diff
• Clone upstream repository someplace else.
• Create integration branch:
  cd <someplace-else>
git checkout -b today-is-wednesday
• Apply that patch
  git apply ~/that-commit.diff
  or
  patch -p1 < ~/that-commit.diff
• Get cup of coffee
• Verify very carefully
  git add -i

Then you should have a clean repo and can safely push.

While Git itself won't directly store branch names in the history, there is a possibility that other tools such as your editor might store it in places you might not expect.

I would therefore consider the entire repository to be compromised and rather spend that extra time copying patches over to a "clean" version - while carefully reviewing them - instead of just hoping for the best.

In case you have multiple commits in your local branch and would like to preserve their history, you could use something like git format-patch and git am.

In any case, double check that it is not just the Git history, but that you also didn't add anything to the actual code that you don't want to share.

The branch name is an "attribute" of a (starting) commit hash.

If you remove the branch remotely, the hystory holds the commits, but loses, as expected, the name of the deleted branch.

To be sure that it cannot be remotely recovered by refs you should run a remote git gc --aggressive. Keep in mind that GitHub and GitLab do it automatically on a timely basis.

A branch name is just a reference (ref). [1] If you just created
it and used it a bit then it is very unlikely that it has been shared
anywhere.

So the short answer is that you don’t have to worry unless you have
pushed anything anywhere.

Branch name locally

When you create a branch name you will create that ref as well as a
reflog [2] for it, if the reflog is enabled.

For example (after three commits):

4a77267 (HEAD -> vulgar) vulgar@{0}: commit: Init
835ca5e vulgar@{1}: commit: Init
4d4cd99 vulgar@{2}: commit: Init
3c45b79 (main) vulgar@{3}: branch: Created from HEAD

If you --move this name then the reflog will mention the previous
name:

4a77267 (HEAD -> nice-name) nice-name@{0}: Branch: renamed refs/heads/vulgar to refs/heads/nice-name
4a77267 (HEAD -> nice-name) nice-name@{1}: commit: Init
835ca5e nice-name@{2}: commit: Init
4d4cd99 nice-name@{3}: commit: Init
3c45b79 (main) nice-name@{4}: branch: Created from HEAD

If you delete the branch then the reflog is deleted as well:

$ git branch -D vulgar
$ git reflog vulgar
fatal: ambiguous argument 'vulgar': unknown revision or path not in the working tree.

But the reflog for HEAD might still mention the branch name:

[…] checkout: moving from vulgar to main

You might be able to delete the reflog for HEAD with:

git reflog expire --expire=now

But check with git reflog afterwards

Branch name locally: merge commit messages

Be mindful of default merge commit messages:

Merge branch 'vulgar'

Branch name on the remote

You should only be concerned if you have pushed the branch:

git push origin vulgar

If so you should delete the branch:

git push --delete origin vulgar
git remote prune origin

The remote might have reflog enabled. If so (according to my testing in
a non-bare remote) then the reflog for the vulgar branch name will still
be there, even after git push --delete origin vulgar.

Notes

1. A ref is a pointer to a commit. So there isn’t much more to it than a
   name
2. The reflog is local-only, or rather specific to that repository (not
   shared anywhere like on push or fetch)