Image of git describe Command | git describe examples and usage


Table of Contents

What is git describe?

As projects grow, it becomes more and more difficult to track changes across a large repository with many commits. The git describe command generates a text description of a particular commit in a Git repository. By using the git describe command, developers can quickly and easily locate specific commits or determine the version of a project without having to search through the commit history manually.

Git Describe is a Git command that allows you to describe the most recent tag that is reachable from a commit. Essentially, it takes the latest tag in the commit history and applies it to the commit. If the commit is not a tagged commit, git describe will try to come up with a human-readable version string by using the number of commits and the abbreviated commit hash since the last tag.

How does git describe work?

The git describe command is useful for identifying the current version of a project, especially when working with tags and releases. It can be used to generate version strings, changelogs, and other documentation related to the project's release history.

The git describe command works by finding the most recent tag that is reachable from a commit. It then appends the number of additional commits on top of that tag, along with the abbreviated commit hash, to create a version string. For example, if the commit is two commits ahead of the nearest tag, git describe might output something like v1.2-2-g123456, where v1.2 is the nearest tag, 2 is the number of commits since the tag, and g123456 is the abbreviated commit hash. By default, git describe points to the latest commit of the active branch, also known as the head.

What is a tag?

In Git, a tag is a reference to a specific point in Git history. Tagging is generally used to capture a point in history for a marked version release. There are two types of tags in Git: lightweight and annotated.

If you want to fully understand the git describe command, it is essential to comprehend git tags. A git tag is a label applied to a specific commit in a Git repository. They are most commonly used to signify version releases like v1.0 or v2.0.

Lightweight tags – references to specific commits. Do not contain the full commit object, but rather just a pointer to the commit. Lightweight tags are often used to mark specific code versions or identify important commits. Unlike annotated tags, these tags do not have a message or author attached to them.

Annotated tags – are stored as full objects in the Git database, similar to commits, and they can be signed with GPG (GNU Privacy Guard) to provide additional security. Annotated tags are a way to mark a specific commit in a Git repository with a tag that includes the following information:

  1. Tagger’s name
  2. Tagger’s email
  3. Date the tag was added
  4. Time the tag was added
  5. Message left by the tagger
  6. Verification from GNU Privacy Guard

Git tags are an important part of version control and release management, and they can be very useful for identifying specific points in the project's history.

git describe commit

To use git describe to extract the most recent reachable tag from a specific commit, you can simply run git describe with no arguments:

$ git describe

This is the equivalent to running git describe HEAD.

If you don’t provide the commit hash, you will be pointing to the Git HEAD by default. In the above example, git describe has output the tag v1.0, followed by the number of commits since that tag (2), and the abbreviated commit has (g123456). The g prefix indicates that this is a commit that has not been tagged.

How do you describe a commit?

You can also use git describe to describe a specific commit by providing the commit hash as an argument. Here’s an example of the git describe <hash> command and its expected output:

$ git describe <a1b2c3d4>

In this example, git describe has output the a1b2c3d4 commit.

git describe examples

Let’s take a look at some of the subcommands that are commonly used with git describe:

Describing All Commits | git describe --all

If you want to access any ref found in the refs/ namespace, instead of just annotated tags, use the --all subcommand. This includes all known branches, remote-tracking branches, and lightweight tags. Here’s an example of how git describe --all output differs from git describe:

$ git describe --all HEAD
v1.2.3 master

If the HEAD commit is a tagged version ‘v1.2.3’ and it is also the tip of the master brand, the output might be something like ‘v1.2.3 master’.

How do I list all tags?

The --tags command lets you view all tags found in the refs/tags namespace, both annotated and lightweight. This command will output the most recent tag that is reachable from the current commit, along with the number of commits that have been made since the tag was created. For example, if the current commit is five commits ahead of the most recent tag, the output might look something like this:

$ git describe --tags

This indicates that the current commit is five commits ahead of the v.1.2.3 tag, and its commit hash is 1234567.

Describing the Closest Tagged Ancestor

You can use the --contains option to view the tag that predates the commit. Or in other words, to describe the commit that is the closest ancestor to a specified commit and is also tagged. This git describe subcommand automatically implies --tags. Here is an example that demonstrates the use of the -contains option:

$ git describe --contains 123456

Modifying the Description Output

You can use the -- abbrev flag to specify the number of digits in the abbreviated commit hash that is included in the description output:

$ git describe --abbrev=8 123456

Alternatively, if you want to suppress the longer format and show the closest annotated tag, you can use --abbrev=0.

git describe no names found

If git describe throws the message fatal: No names found, cannot describe anything you don’t have any tags in your current repository. You must have at least one tag in your repository to use the git describe command.

To create a git tag for your repository, follow these steps:

  1. Make sure you are in the correct repository and branch.
  2. Use the command git tag -a <tag_name> -m <message> to create a new tag.
  3. Replace <tag_name> with the desired name for your tag and <message> with a short description of the changes made in the tag. Press enter to create the tag.
  4. To push the tag to the remote repository, use the git push command with the follow subcommands: origin <tag_name>. Replace <tag_name> with the name of your tag.

Note: You can also create an annotated tag using the -a flag or a lightweight tag without a message using the -m flag.

Alternatively, if your repository does have tags, this error means you are in a shallow clone. A shallow clone pulls only the latest commits, not the entire repository. If you really think you should have tags in your repository that you need to recover, you can try the following solutions:

  1. Ensure you’ve pushed the changes upstream after tagging a commit.
  2. Use the git pull command to try to pull the tags.
  3. If you are working on a cloned repository, check that you have tags on the remote repository.
  4. Try the git fetch --prune --unshallow command to fetch the tags.

How to Fetch Remote Git Tags

Fetching remote tags is useful when you want to get the latest tags from a remote repository. This is especially important when working in a team, as other team members may have created new tags that you don't have locally. By fetching the latest tags, you can stay up to date with the project's release history and versioning.

To fetch remote tags in Git, you can use the git fetch command with the --tags flag. This will download all tags from the remote repository and store them locally.

Here's an example of how to fetch remote tags:

git fetch --tags

This will fetch all tags from the default remote repository (usually origin). If you want to fetch tags from a different remote repository, you can specify the repository name as an argument:

git fetch <remote> --tags

For example, to fetch tags from the upstream remote repository, you can use the following command:

git fetch upstream --tags

Once the tags have been fetched, you can view the list of tags by running the command git tag.

It's a good idea to fetch remote tags periodically, even if you're not actively working on the project. This will ensure that you have the latest tags and that your local repository is in sync with the remote repository.


Git describe helps you to identify the current version of a project based on tags and commits. This command can be useful for generating version strings, changelogs, and other documentation related to the project's release history. Additionally, git describe can help you understand the context of a commit within the project's history. By showing the number of commits and the abbreviated commit hash since the last tag, git describe can give you a sense of how far the commit is from the last tagged release.

The git describe command is a convenient way to quickly reference a specific commit, especially when working with tags and releases. Understanding the git describe command will expand your skillset as a developer. Now that you have a basic understanding of this command's function, get out there and put it to use in your projects and repositories.

Next steps

If you're interested in learning more about how Git works under the hood, check out our Decoding Git Guidebook for Developers, which dives into Git's code in an accessible way. We wrote it for curious developers to learn how Git works at the code level. To do this, we documented the first version of Git's code and discuss it in detail.

We hope you enjoyed this post! Feel free to shoot me an email at with any questions or comments.


  1. Git SCM Docs -

Final Notes

Recommended product: Git Guidebook for Developers