How do I view 'git diff' output with my preferred diff tool/ viewer?

Question

When I type git diff, I want to view the output with my visual diff tool of choice (SourceGear "diffmerge" on Windows). How do I configure git to do this?

Nolan

You can use "git difftool" instead of "git diff" in all newer versions of git. That will open up a visual diff program. – Cincture

Regarding the new script difftool, I have added an answer below: stackoverflow.com/questions/255202/… – Utricle

gitx - gitx.frim.nl. Nuff said. – Berghoff

Brief tutorial you'd find here: nathanhoad.net/how-to-meld-for-git-diffs-in-ubuntu-hardy – Shrimp

git difftool -tool=opendiff just replace opendiff with whatever. – Maskanonge

Go to your repository in Git Bash. Type git config diff.tool winmerge. Verify it worked by typing git difftool. Get rid of the prompt typing git config --global difftool.prompt false. I recommend p4merge instead of winmerge. – Bersagliere

(1.) to list supported external diff tools do git difftool --tool-help (2.) to open using a specific diff tool like vimdiff just do git difftool --tool=vimdiff. This is a summary of the solution written by @JakubNarębski – Ulceration

see stackoverflow.com/questions/2069490/…, and just replace the path to beyond compare with the path to your tool. – Hacker

Answer 1

Since Git1.6.3, you can use the git difftool script: see my answer below.

---

May be this article will help you. Here are the best parts:

There are two different ways to specify an external diff tool.

The first is the method you used, by setting the GIT_EXTERNAL_DIFF variable. However, the variable is supposed to point to the full path of the executable. Moreover, the executable specified by GIT_EXTERNAL_DIFF will be called with a fixed set of 7 arguments:

path old-file old-hex old-mode new-file new-hex new-mode

As most diff tools will require a different order (and only some) of the arguments, you will most likely have to specify a wrapper script instead, which in turn calls the real diff tool.

The second method, which I prefer, is to configure the external diff tool via "git config". Here is what I did:

1) Create a wrapper script "git-diff-wrapper.sh" which contains something like

-->8-(snip)--
#!/bin/sh

# diff is called by git with 7 parameters:
# path old-file old-hex old-mode new-file new-hex new-mode

"<path_to_diff_executable>" "$2" "$5" | cat
--8<-(snap)--

As you can see, only the second ("old-file") and fifth ("new-file") arguments will be passed to the diff tool.

2) Type

$ git config --global diff.external <path_to_wrapper_script>

at the command prompt, replacing with the path to "git-diff-wrapper.sh", so your ~/.gitconfig contains

-->8-(snip)--
[diff]
    external = <path_to_wrapper_script>
--8<-(snap)--

Be sure to use the correct syntax to specify the paths to the wrapper script and diff tool, i.e. use forward slashed instead of backslashes. In my case, I have

[diff]
    external = \"c:/Documents and Settings/sschuber/git-diff-wrapper.sh\"

in .gitconfig and

"d:/Program Files/Beyond Compare 3/BCompare.exe" "$2" "$5" | cat

in the wrapper script. Mind the trailing "cat"!

(I suppose the '| cat' is needed only for some programs which may not return a proper or consistent return status. You might want to try without the trailing cat if your diff tool has explicit return status)

(Diomidis Spinellis adds in the comments:

The cat command is required, because diff(1), by default exits with an error code if the files differ.
Git expects the external diff program to exit with an error code only if an actual error occurred, e.g. if it run out of memory.
By piping the output of git to cat the non-zero error code is masked.
More efficiently, the program could just run exit with and argument of 0.)

---

That (the article quoted above) is the theory for external tool defined through config file (not through environment variable).
In practice (still for config file definition of external tool), you can refer to:

• How do I setup DiffMerge with msysgit / gitk? which illustrates the concrete settings of DiffMerge and WinMerge for MsysGit and gitk
• How can I set up an editor to work with Git on Windows? for the definition of Notepad++ as an external editor.

Utricle

ah, I'd set the external diff program but didn't know about the 7 arguments, thanks. – Nolan

Kudos ... this is very handy. I set this up with "opendiff" (which launches the slick XCode FileMerge utility under Mac OS X). – Stein

@Ryan: that is great :) Did you use the "diff.external" setting detailed in this answer or the "git difftool" of my second answer below? – Utricle

Fantastic! Thank you, tried both DiffMerge and opendiff; both work quite well. – Nieberg

old-file old-hex old-mode new-file new-hex new-mode that's only 6 arguments, not 7... – Sharpeyed

@Jez: yes that article omit the first argument, which is the path. You will find it though a few line below. – Utricle

So git sends 7 arguments to a diff program? The more I learn about Git, the more I feel it is was made for one person: The original programmer. This dvcs seems more like a shiny toy that doesn't do much. – Asmodeus

@Nolan is there an alternate link to the article you referenced, that one is no longer reachable on the web – Azevedo

@PeterNimmo I have found an alternative link: osdir.com/ml/version-control.msysgit/2008-06/msg00200.html – Utricle

@Utricle The alternative link in your comment is also no longer accessible – Missy

@Missy Thank you. I have edited the answer and restored the link to web.archive.org/web/20170508180316/http://git.net:80/ml/… – Utricle

@JesseRusak The cat command is required, because diff(1), by default exits with an error code if the files differ. Git expects the external diff program to exit with an error code only if an actual error occurred, e.g. if it run out of memory. By piping the output of git to cat the non-zero error code is masked. More efficiently, the program could just run exit with and argument of 0. – Tieshatieup

@DiomidisSpinellis Thank you. I have included your comment in the answer for more visibility. – Utricle

Note: step 2 (modifying diff.external) will cause "git diff" to launch your difftool. This can be undesirable, and can cause problems with user interfaces (like SourceTree), causing them to aggressively launch your tool at odd times. It's probably better to modify diff.tool instead (e.g.: git config --global diff.tool p4merge) – Quitt

@KevinMeboe I agree: that is what my second answer below (https://mcmap.net/q/12557/-how-do-i-view-39-git-diff-39-output-with-my-preferred-diff-tool-viewer) proposes. – Utricle

@Asmodeus I don't understand what is wrong with sending as much information as possible to a third-party program (i.e., not under the control of the first-party program, not known ahead of time, and any one of infinite possible choices). Assuming you're complaining about the number of arguments... although that's not quite clear either. – Blancablanch

Answer 2

To complete my previous "diff.external" config answer above:

As mentioned by Jakub, Git1.6.3 introduced git difftool, originally proposed in September 2008:

USAGE='[--tool=tool] [--commit=ref] [--start=ref --end=ref] [--no-prompt] [file to merge]'
(See --extcmd in the last part of this answer)

$LOCAL contains the contents of the file from the starting revision and $REMOTE contains the contents of the file in the ending revision.
$BASE contains the contents of the file in the wor

It's basically git-mergetool modified to operate on the git index/worktree.

The usual use case for this script is when you have either staged or unstaged changes and you'd like to see the changes in a side-by-side diff viewer (e.g. xxdiff, tkdiff, etc).

git difftool [<filename>*]

Another use case is when you'd like to see the same information but are comparing arbitrary commits (this is the part where the revarg parsing could be better)

git difftool --start=HEAD^ --end=HEAD [-- <filename>*]

The last use case is when you'd like to compare your current worktree to something other than HEAD (e.g. a tag)

git difftool --commit=v1.0.0 [-- <filename>*]

Note: since Git 2.5, git config diff.tool winmerge is enough!
See "git mergetool winmerge"

And since Git 1.7.11, you have the option --dir-diff, in order to to spawn external diff tools that can compare two directory hierarchies at a time after populating two temporary directories, instead of running an instance of the external tool once per a file pair.

---

Before Git 2.5:

Practical case for configuring difftool with your custom diff tool:

C:\myGitRepo>git config --global diff.tool winmerge
C:\myGitRepo>git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\""
C:\myGitRepo>git config --global difftool.prompt false

With winmerge.sh stored in a directory part of your PATH:

#!/bin/sh
echo Launching WinMergeU.exe: $1 $2
"C:/Program Files/WinMerge/WinMergeU.exe" -u -e "$1" "$2" -dl "Local" -dr "Remote"

If you have another tool (kdiff3, P4Diff, ...), create another shell script, and the appropriate difftool.myDiffTool.cmd config directive.
Then you can easily switch tools with the diff.tool config.

You have also this blog entry by Dave to add other details.
(Or this question for the winmergeu options)

The interest with this setting is the winmerge.shscript: you can customize it to take into account special cases.

See for instance David Marble's answer below for an example which deals with:

• new files in either origin or destination
• removed files in either origin or destination

---

As Kem Mason mentions in his answer, you can also avoid any wrapper by using the --extcmd option:

--extcmd=<command>

Specify a custom command for viewing diffs. git-difftool ignores the configured defaults and runs $command $LOCAL $REMOTE when this option is specified.

For instance, this is how gitk is able to run/use any diff tool.

Utricle

I had to escape the $, for $LOCAL and $REMOTE to prevent them from becoming "" and "". I would edit to say git config --globla difftool.winmerge.cmd "winmerge.sh \"\$LOCAL\" \"\$REMOTE\"" – Repudiation

Also, any idea of how to get the -s option (open several diffs in one winmerge window) to work in this scheme? – Repudiation

@Frank: I confirm, the $PATH or %PATH% is respected when it comes to git config directives (what is your setup? Git Version? OS?). And if you want to signal a post to Carlos, your comment needs to begin with '@': @Carlos (see meta.stackexchange.com/questions/1093/…) – Utricle

@Carlos: Frank (see comment above) wanted you to look at stackoverflow.com/questions/1220309/… (for opening several diffs in one winmerge window) – Utricle

the path issue I had was resolved, stackoverflow.com/questions/2664283/… – Zermatt

Note: git difftool now support directory diffs: stackoverflow.com/questions/2113889/… – Utricle

The --start= and --end= options are not recognised in v1.7.11 – Emu

@Utricle What does the option -ub do? I don't see it as one of the command line options of WinMerge. – Extraordinary

Also worth mentioning the highly useful --dir-diff option in order to compare all the files at once and avoid prompts. – Preceptory

@SteveChambers Yes, I mentioned it in https://mcmap.net/q/12823/-directory-comparison-of-git-branches. I will edit this answer. – Utricle

Answer 3

Try this solution:

$ meld my_project_using_git

Meld understands Git and provides navigating around the recent changes.

Vespertine

That's great, much easier to type meld . than git difftool and have to view changed files sequentially. And it's much closer to Mercurial's hg vdiff plugin. – Zadoc

Also, meld . works on Mercurial and Subversion projects too, in case anyone is curious. – Zadoc

Hmm, when I do this a list of modified files shows. When I click on one of them or do 'compare' it opens alone in a separate tab. How do I get a diff? – Martell

@misiu_mp, I just tried it, on clicking the modified files, it shows the diff (old file as well as modified file). – Lists

At what version was this added? It doesn't appear to work with meld version 1.1.5. – Emersonemery

Only one drawback: sometimes meld can scan diffs much longer than through using difftool. Looks like it still scans gitignored files (lots of build generated files in my case). It took several seconds on my machine to create a list of modified files, but with difftool it happened instantly – Lambrequin

Is there the same feature for kompare? I liked this solution very much (especially, that it allows you to select interested file from a list). – Loreanloredana

That's excellent if you want to see current changes. I found git difftool -y -t meld --dir-diff other_branch to be useful too, to see the difference with any branch. – Apologist

Answer 4

With new git difftool, its as simple as adding this to your .gitconfig file:

[diff]
    tool = any-name
[difftool "any-name"]
    cmd = "\"C:/path/to/my/ext/diff.exe\" \"$LOCAL\" \"$REMOTE\""

Optionally, also add:

[difftool]
    prompt = false

Also check out diffall, a simple script I wrote to extend the annoying (IMO) default diff behaviour of opening each in serial.

Global .gitconfig on Windows is in %USERPROFILE%\.gitconfig

Heartworm

what is $local and what is $remote? – Asmodeus

+1 for a method that doesn't require a wrapper script – Ideally

@CJohnson: Path to the original file and path to the edited file, respectively. – Ideally

in case the blog-link dies, here's the linked SO answer: https://mcmap.net/q/12824/-git-difftool-open-all-diff-files-immediately-not-in-serial – Daze

@CJohnson: $LOCAL is always the latest commit. However $REMOTE isn't consistent. When looking at changes in the local sandbox, it's the current/edited file, But when diffing historical commits, it's the parent commit. IOW for normal diffs $LOCAL = old and $REMOTE = new. For historical, $LOCAL = newer and $REMOTE = older. – Nonscheduled

Answer 5

Since Git version 1.6.3 there is "git difftool" which you can configure to use your favorite graphical diff tool.

Currently supported (at the time of writing this answer) out-of-the-box are KDiff3, Kompare, tkdiff, Meld, xxdiff, emerge, vimdiff, gvimdiff, ecmerge, Diffuse and opendiff; if the tool you want to use isn't on this list, you can always use 'difftool.<tool>.cmd' configuration option.

"git difftool" accepts the same options as "git diff".

Diastrophism

Araxis Merge is also configured. araxis.com/merge/scm_integration.html – Mickelson

example usage: git difftool -t kdiff3 HEAD – Urbai

Answer 6

I have one addition to this. I like to regularly use a diff app that isn't supported as one of the default tools (e.g. kaleidoscope), via

git difftool -t

I also like to have the default diff just be the regular command line, so setting the GIT_EXTERNAL_DIFF variable isn't an option.

You can use an arbitrary diff app as a one-off with this command:

git difftool --extcmd=/usr/bin/ksdiff

It just passes the 2 files to the command you specify, so you probably don't need a wrapper either.

Wernerwernerite

Good point: nobody has mentioned yet that --extcmd option. +1. I have included it in my answer. – Utricle

Can you add a reference to "kaleidoscope"? – Schaal

Answer 7

Building on VonC's answer to deal with file removals and additions, use the following commands and scripts:

git config --global diff.tool winmerge
git config --global difftool.winmerge.cmd "winmerge.sh \"$LOCAL\" \"$REMOTE\" \"$BASE\""
git config --global difftool.prompt false

Which is the same as putting this in your global file .gitconfig:

[diff]
    tool = winmerge
[difftool "winmerge"]
    cmd = winmerge.bat "$LOCAL" "$REMOTE" "$BASE"
[difftool]
    prompt = false

Then put the following in file winmerge.sh which must be on your path:

#!/bin/sh
NULL="/dev/null"
if [ "$2" = "$NULL" ] ; then
    echo "removed: $3"
elif [ "$1" = "$NULL" ] ; then
    echo "added: $3"
else
    echo "changed: $3"
    "C:/Program Files (x86)/WinMerge/WinMergeU.exe" -e -ub -dl "Base" -dr "Mine" "$1" "$2"
fi

Tallula

Excellent addition to the winmerge.sh script. +1. I have updated my answer to link to yours. – Utricle

winmerge.bat in the second snippet should be winmerge.sh – Gesso

Can you make this for many tools ? And associate them by file extension ? – Menticide

Answer 8

Solution for Windows/MSYS Git

After reading the answers, I discovered a simpler way that involves changing only one file.

1. Create a batch file to invoke your diff program, with argument 2 and 5. This file must be somewhere in your path. (If you don't know where that is, put it in C:\windows.) Call it, for example, "gitdiff.bat". Mine is:

   @echo off
   REM This is gitdiff.bat
   "C:\Program Files\WinMerge\WinMergeU.exe" %2 %5
   

2. Set the environment variable to point to your batch file. For example:GIT_EXTERNAL_DIFF=gitdiff.bat. Or through PowerShell by typing git config --global diff.external gitdiff.bat.

   It is important to not use quotes, or specify any path information, otherwise it won't work. That's why gitdiff.bat must be in your path.

Now when you type "git diff", it will invoke your external diff viewer.

Promiscuity

+1 (+10 if I could.) This is really the most simple solution. I struggled for hours with the accepted answer, and finally gave up (some of my problems were probably related to running Git through PowerShell...) However, I used git config --global diff.external winmerge.cmd, instead of setting the GIT_EXTERNAL_DIFF environment variable, and it works equally well. – Aiken

A couple of issues with this solution: 1. Doesn't work for new files. WinMerge asks me to enter a second file to compare against. 2. Window to compare next file only opens up after you close the current WinMerge window, no easy way to see all files at the same time. – Gel

Answer 9

If you're doing this through Cygwin, you may need to use cygpath:

$ git config difftool.bc3.cmd "git-diff-bcomp-wrapper.sh \$LOCAL \$REMOTE"
$ cat git-diff-bcomp-wrapper.sh
#!/bin/sh
"c:/Program Files (x86)/Beyond Compare 3/BComp.exe" `cygpath -w $1` `cygpath -w $2`

Crocein

For some reason, using "bc3" is no longer working for me, but if I use "beyond" instead, it's fine. – Crocein

Answer 10

After looking at some other external diff tools, I found that the diff view in IntelliJ IDEA (and Android Studio) is the best one for me.

Step 1 - setup IntelliJ IDEA to be run from the command line

If you want to use IntelliJ IDEA as your diff tool you should first setup IntelliJ IDEA to be run from the command line following the instructions here:

On macOS or UNIX:

1. Make sure IntelliJ IDEA is running.
2. On the main menu, choose Tools | Create Command-line Launcher. The dialog box Create Launcher Script opens, with the suggested path and name of the launcher script. You can accept default, or specify your own path. Make notice of it, as you'll need it later. Outside of IntelliJ IDEA, add the path and name of the launcher script to your path.

On Windows:

1. Specify the location of the IntelliJ IDEA executable in the Path system environment variable. In this case, you will be able to invoke the IntelliJ IDEA executable and other IntelliJ IDEA commands from any directory.

Step 2 - configure git to use IntelliJ IDEA as the difftool

Following the instructions on this blog post:

Bash

export INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
PATH=$IDEA_HOME $PATH

Fish

set INTELLIJ_HOME /Applications/IntelliJ\ IDEA\ CE.app/Contents/MacOS
set PATH $INTELLIJ_HOME $PATH

Now add the following to your git config:

[merge]
   tool = intellij
[mergetool "intellij"]
   cmd = idea merge $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE") $(cd $(dirname "$BASE") && pwd)/$(basename "$BASE") $(cd $(dirname "$MERGED") && pwd)/$(basename "$MERGED")
   trustExitCode = true
[diff]
   tool = intellij
[difftool "intellij"]
   cmd = idea diff $(cd $(dirname "$LOCAL") && pwd)/$(basename "$LOCAL") $(cd $(dirname "$REMOTE") && pwd)/$(basename "$REMOTE")

You can try it out with git difftool or git difftool HEAD~1

Hybridism

Answer 11

This works for me on Windows 7. There isn't any need for intermediary sh scripts

Contents of .gitconfig:

    [diff]
      tool = kdiff3

    [difftool]
       prompt = false

    [difftool "kdiff3"]
      path = C:/Program Files (x86)/KDiff3/kdiff3.exe
      cmd = "$LOCAL" "$REMOTE"

Castano

Do you also have kdiff3 defined as your mergetool? Mind sharing that part of your gitconfig if so? – Misfit

Thanks. This didn't quite work for me but it did work when I removed path and changed cmd to "\"C:/Program Files (x86)/KDiff3/kdiff3.exe\" \"$LOCAL\" \"$REMOTE\"" – Preceptory

Answer 12

A short summary of the previous great answers:

git difftool --tool-help
git config --global diff.tool <chosen tool>
git config --global --add difftool.prompt false

Then use it by typing (optionally specifying the file name as well):

git difftool

Percyperdido

Answer 13

Install Meld:

 # apt-get install meld

Then choose that as the difftool:

 $ git config --global diff.tool meld

If you want to run it in the console, type:

 $ git difftool

If you want to use graphic mode, type:

 $ git mergetool

And the output would be:

 'git mergetool' will now attempt to use one of the following tools:
 meld opendiff kdiff3 tkdiff xxdiff tortoisemerge gvimdiff diffuse
 diffmerge ecmerge p4merge araxis bc3 codecompare emerge vimdiff
 Merging:
 www/css/style.css
 www/js/controllers.js

 Normal merge conflict for 'www/css/style.css':
   {local}: modified file
   {remote}: modified file
 Hit return to start merge resolution tool (meld):

So just press Enter to use meld (default). This would open graphic mode. Make the magic save and press that that resolve the merge. That's all.

Mazuma

I love meld but it has been behaving very poorly on MacOs, so I've switched to sublime merge. – Fey

Answer 14

Introduction

For reference I'd like to include my variation on VonC's answer. Keep in mind that I am using the MSys version of Git (1.6.0.2 at this time) with modified PATH, and running Git itself from PowerShell (or cmd.exe), not the Bash shell.

I introduced a new command, gitdiff. Running this command temporarily redirects git diff to use a visual diff program of your choice (as opposed to VonC's solution that does it permanently). This allows me to have both the default Git diff functionality (git diff) as well as visual diff functionality (gitdiff). Both commands take the same parameters, so for example to visually diff changes in a particular file you can type

gitdiff path/file.txt

Setup

Note that $GitInstall is used as a placeholder for the directory where Git is installed.

1. Create a new file, $GitInstall\cmd\gitdiff.cmd

    @echo off
    setlocal
    for /F "delims=" %%I in ("%~dp0..") do @set path=%%~fI\bin;%%~fI\mingw\bin;%PATH%
    if "%HOME%"=="" @set HOME=%USERPROFILE%
    set GIT_EXTERNAL_DIFF=git-diff-visual.cmd
    set GIT_PAGER=cat
    git diff %*
    endlocal
   

2. Create a new file, $GitInstall\bin\git-diff-visual.cmd (replacing [visual_diff_exe] placeholder with full path to the diff program of your choice)

    @echo off
    rem diff is called by git with 7 parameters:
    rem path old-file old-hex old-mode new-file new-hex new-mode
    echo Diffing "%5"
    "[visual_diff_exe]" "%2" "%5"
    exit 0
   

3. You're now done. Running gitdiff from within a Git repository should now invoke your visual diff program for every file that was changed.

Beckibeckie

Answer 15

Here's a batch file that works for Windows - assumes DiffMerge installed in default location, handles x64, handles forward to backslash replacement as necessary and has ability to install itself. Should be easy to replace DiffMerge with your favourite diff program.

To install:

gitvdiff --install 

gitvdiff.bat:

@echo off

REM ---- Install? ----
REM To install, run gitvdiff --install

if %1==--install goto install



REM ---- Find DiffMerge ----

if DEFINED ProgramFiles^(x86^) (
    Set DIFF="%ProgramFiles(x86)%\SourceGear\DiffMerge\DiffMerge.exe"
) else (
    Set DIFF="%ProgramFiles%\SourceGear\DiffMerge\DiffMerge.exe"
)



REM ---- Switch forward slashes to back slashes ----

set oldW=%2
set oldW=%oldW:/=\%
set newW=%5
set newW=%newW:/=\%


REM ---- Launch DiffMerge ----

%DIFF% /title1="Old Version" %oldW% /title2="New Version" %newW%

goto :EOF



REM ---- Install ----
:install
set selfL=%~dpnx0
set selfL=%selfL:\=/%
@echo on
git config --global diff.external %selfL%
@echo off


:EOF

Phlogistic

Great script, it saved me the trouble of looking DiffMerge commands. You might want to modify the install line to use quotes - I had trouble on my machine: "%1"=="--install". – Prescription

Answer 16

If you're on a Mac and have Xcode, then you have FileMerge installed. The terminal command is opendiff, so you can just do:

git difftool -t opendiff

Grandiloquent

Use the -y option to avoid annoying prompts. Unfortunately, git will wait until FileMerge quits before offering the next changed file. Use the -d option to do a directory compare in one shot. – Particularism

The option -t seems to require the complete path. Maybe using git difftool --extcmd=opendiff is better. – Menticide

Answer 17

For a Linux version of how to configure a diff tool on Git versions prior to 1.6.3 (1.6.3 added difftool to Git), this is a great concise tutorial.

In brief:

Step 1: add this to your .gitconfig

[diff]
  external = git_diff_wrapper
[pager]
  diff =

Step 2: create a file named git_diff_wrapper, put it somewhere in your $PATH

#!/bin/sh

vimdiff "$2" "$5"

Emarie

Answer 18

On Mac OS X,

git difftool -t diffuse

does the job for me in the Git folder. For installing Diffuse, one can use port -

sudo port install diffuse

Kevakevan

"port"? On BSD? – Schaal

Can you add references to 'port' and 'diffuse'? And presumed platforms/operating system(s)? – Schaal

Answer 19

You can use git difftool.

For example, if you have Meld, you can edit the branches master and devel by:

git config --global diff.external meld
git difftool master..devel

Boatyard

Answer 20

The following can be gleaned from the other answers here, but for me it's difficult, (too much information), so here's the 'just type it in' answer for tkdiff:

git difftool --tool=tkdiff <path to the file to be diffed>

You can substitute the executable name of your favorite diffing tool for tkdiff. As long as (e.g. tkdiff), (or your favorite diffing tool) is in your PATH, it will be launched.

Knepper

this is the simplest and fastest way. – Nessi

Answer 21

I tried the fancy stuff here (with tkdiff) and nothing worked for me. So I wrote the following script, tkgitdiff. It does what I need it to do.

$ cat tkgitdiff
#!/bin/sh

#
# tkdiff for git.
# Gives you the diff between HEAD and the current state of your file.
#

newfile=$1
git diff HEAD -- $newfile > /tmp/patch.dat
cp $newfile /tmp
savedPWD=$PWD
cd /tmp
patch -R $newfile < patch.dat
cd $savedPWD
tkdiff /tmp/$newfile $newfile

Wheelwright

Answer 22

I use Kompare on Ubuntu:

sudo apt-get install kompare

To compare two branches:

git difftool -t kompare <my_branch> master

Eddi

Answer 23

I've been using this bit in file ~/.gitconfig for a long time:

[diff]
    external = ~/Dropbox/source/bash/git-meld

With git-meld:

#!/bin/bash
if [ "$DISPLAY" = "" ];
then
    diff $2 $5
else
    meld $2 $5
fi

But now I got tired of always using Meld in a graphical environment, and it's not trivial to invoke the normal diff with this setup, so I switched to this:

[alias]
    v =  "!sh -c 'if [ $# -eq 0 ] ; then git difftool -y -t meld ; else git difftool -y $@ ; fi' -"

With this setup, things like this work:

git v
git v --staged
git v -t kompare
git v --staged -t tkdiff

And I still get to keep the good old git diff.

Sava

Answer 24

You may want to try out xd, which is a GUI wrapper for Git/SVN diff. It is not a diff tool itself.

You run xd when you want to run git diff or svn diff and it will show you a list of files, a preview window and you can launch any diff tool you like, including tkdiff, xxdiff, gvimdiff, Emacs (ediff), XEmacs (ediff), Meld, Diffuse, Kompare and KDiff3. You can also run any custom tool.

Unfortunately the tool doesn't support Windows.

Disclosure: I am the author of this tool.

Ramonramona

Answer 25

If you happen to already have a diff tool associated with filetypes (say, because you installed TortoiseSVN which comes with a diff viewer) you could just pipe the regular git diff output to a "temp" file, then just open that file directly without needing to know anything about the viewer:

git diff > "~/temp.diff" && start "~/temp.diff"

Setting it as a global alias works even better: git what

[alias]
    what = "!f() { git diff > "~/temp.diff" && start "~/temp.diff"; }; f"

Kymberlykymograph

Answer 26

If you're not one for the command line then if you install TortoiseGit, you can right click on a file to get a TortoiseGit submenu with the "Diff later" option.

When you select this on the first file, you can then right click on the second file, go to the TortoiseGit submenu and select "Diff with ==yourfilehere==". This will give the TortoiseGit merge GUI for the result.

Annalisaannalise