Replicating the "git show" Command in Mercurial

Posted on in software

cover image for article

As a seasoned software engineer who has transitioned from the early days of development to the modern era, I understand the importance of having robust tools to manage codebases. Two of the most popular version control systems (VCS) today are Git and Mercurial. While both serve the same fundamental purpose, their commands and workflows can differ significantly. For developers transitioning between these systems, understanding how to replicate familiar commands is crucial. One such command in Git is git show, which provides detailed information about a specific commit. In this article, we will explore how to replicate the functionality of git show in Mercurial (hg).

Understanding git show

The git show command in Git is used to display various types of objects. By default, it shows the commit details, including the commit message, the author, the date, and the diff associated with the commit.


git show <commit-hash>

This command is incredibly useful for reviewing changes and understanding the context of a commit. It combines the functionalities of git log and git diff into a single, comprehensive command.

Equivalent Commands in Mercurial

Mercurial doesn't have a direct equivalent of git show, but we can achieve the same functionality using a combination of commands: hg log, hg diff, and hg export.

1. Viewing Commit Details with hg log

The hg log command provides detailed information about commits, similar to git show. To view details of a specific commit, use the -r option followed by the commit hash.


hg log -r <commit-hash>

This command displays information such as the changeset, author, date, and commit message.

2. Viewing Diff with hg diff

To view the differences introduced by a specific commit, use the hg diff command with the -c option followed by the commit hash.


hg diff -c <commit-hash>

This command shows the diff associated with the specified commit, similar to what git show displays.

3. Combining Log and Diff with hg export

The hg export command combines the functionality of hg log and hg diff by exporting a changeset in a patch format, including commit details and diffs.


hg export <commit-hash>

This command outputs the commit message, author, date, and the diff in a unified format.

Creating a Custom Command for Convenience

To replicate the git show command more conveniently in Mercurial, we can create a custom command using an alias in the .hgrc configuration file.

  1. Open or create the .hgrc file in your home directory or repository directory:

    vim ~/.hgrc
  2. Add the following alias:

    show = log -r $1 && diff -c $1

    With this alias, you can now use hg show <commit-hash> to display the commit details and diff, mimicking git show.

Step-by-Step Guide

Step 1: Initialize a Mercurial Repository

First, ensure you have a Mercurial repository to work with. If you don't have one, you can create a new repository:

hg init my-repo
cd my-repo

Step 2: Make Some Commits

Create some files and make a few commits to have a history to work with:

echo "First file content" > file1.txt
hg add file1.txt
hg commit -m "Initial commit"

echo "Second file content" > file2.txt
hg add file2.txt
hg commit -m "Add second file"

echo "Update to first file" >> file1.txt
hg commit -m "Update first file"

Step 3: Use hg log to View Commit Details

To view the details of a specific commit:

hg log -r 1

Step 4: Use hg diff to View the Diff of a Commit

To view the diff of a specific commit:

hg diff -c 1

Step 5: Use hg export to View Both Details and Diff

To view both the commit details and the diff:

hg export 1

Step 6: Set Up the Custom hg show Command

  1. Open the .hgrc file:

    vim ~/.hgrc
  2. Add the alias:

    show = log -r $1 && diff -c $1
  3. Use the new hg show command:

    hg show 1

Deep Dive: Comparing Git and Mercurial Workflows

Commit Hashes and Revision Numbers

In Git, commits are identified by SHA-1 hashes, which are unique and consistent across repositories. Mercurial, however, uses both SHA-1 hashes and sequential revision numbers. The revision number is unique within a repository but can differ across cloned repositories. This difference can impact how you reference commits in scripts and commands.

Branching and Merging

Git and Mercurial handle branching and merging differently. Git uses lightweight branches that are essentially pointers to commits. Branch operations in Git are fast and branches can be easily deleted without losing history.

Mercurial uses named branches and bookmarks. Named branches are permanent and are recorded in the commit history. Bookmarks in Mercurial are similar to Git branches but are mutable pointers that can be moved between commits.


Rebasing is a common practice in Git to rewrite commit history and create a linear sequence of commits. Mercurial supports rebasing but with more caution due to its emphasis on preserving history. The hg rebase extension needs to be enabled explicitly in Mercurial's configuration.

Staging Area

Git has a staging area (index) where changes are prepared before committing. This provides granular control over what gets included in a commit. Mercurial commits changes directly from the working directory, but the hg shelve extension can provide similar functionality by temporarily storing changes not ready for commit.

Practical Use Cases

Reviewing Changes

Using the custom hg show command is incredibly useful for reviewing changes before integrating them into the main codebase. It provides a comprehensive view of the commit, helping you understand the context and impact of the changes.

Code Audits

During code audits, it's essential to trace the history and details of specific changes. The hg show command replicates the comprehensive view provided by git show, making it easier to audit code changes in Mercurial repositories.


When collaborating with other developers, sharing the exact changes and their context becomes crucial. The hg show command can be used to generate detailed commit reports, facilitating better communication and understanding among team members.


While Mercurial and Git have different commands and workflows, it's possible to replicate the functionality of git show in Mercurial using a combination of hg log, hg diff, and hg export. By setting up a custom alias, you can streamline this process and make the transition between these version control systems smoother. This guide provides the necessary steps to achieve this, enabling you to leverage the powerful features of Mercurial while maintaining familiar workflows. As always, happy coding and may your version control be ever in your favor!

Slaptijack's Koding Kraken