Meld is a visual diff and merge tool targeted at developers

As a long time Sublime Text[1] user, I've been using Sublime Merge[2] since the day it's been launched and it brings me the same speed and minimalism I get with Sublime Text and has evolved quite a lot to be able to do most things I need in a merge tool.

Not affiliated with them in any way by the way.

[1] https://www.sublimetext.com/ [2] https://www.sublimemerge.com/

Another fan of Beyond Compare here, but I want to point out something everyone else has missed so far, which is that BC is great for comparing all sorts of files, not just code.

For example, I use its "Table Compare" feature to compare log files from different machines, sorted by timestamp. This lets me easily see the order of operations in a distributed system.

I've been using Meld since years ago, and it's my default go-to diff viewer. The visual style they implemented helps me a lot to reason about how lines have been added or deleted from documents in the side by side comparison. Very neat!

The directory contents tree diff is also really useful.

I wish they made it even easier the basic case of comparing aribtrary text. Maybe it should be the default mode after opening the program, instead of having to click on a couple buttons, because I use it a lot to manually paste pieces of text. For example, logs from a server during testing, to compare what went different between runs.

Another welcomed addition would be "ignore masks". Some kind of regex input that could be used to quickly tell Meld which parts of the text to skip comparing. That way, comparison of log files could be made where a timestamps column would be ignored.

IMHO, Meld is the second best open source tool for doing this.

On Windows, WinMerge[1] is a better alternative. Too bad is Windows only.

For a non-FOSS and cross platform solution I recommend BeyondCompare (U$30.00)[2]. It replicates most of WinMerge UI.

[1] https://winmerge.org/

[2] https://scootersoftware.com/

Meld might be useful for comparison, but in my opinion it is inconvenient as a git merge tool. For git merge I need four panels: original file, version A, version B, merged result. Meld has only three panels.

Currently I am using KDiff3. It is a little buggy and doesn't have a nice UI but it is the best open source merging tool that I am aware of. It allows choosing lines from original file, from A, B and manual editing.

I noticed that certain popular and highly praised commercial IDE also provides only 3-panel interface for merging. This makes resolving conflicts more difficult and prone to errors.

Since everyone else is mentioning other tools, here’s my mention for vimdiff. I think I have meld installed but rarely use it because vimdiff is usually enough. As a bonus I get to use my usual editing keys when working with it.

If you want to use it with git:

    git config --global diff.tool meld
    git config --global --add difftool.prompt false

For visualization I really like kdiff3.

Or on terminals https://github.com/mookid/diffr with specific settings that use 256 colors for highlighting word differences as well.

But for manual merging I haven't found anything better than ediff. That's the only reason I install emacs on my work machines. Seemless integration into a text editor is just unbeatable.

My .gitconfig for using meld at the git merge tool:

  [alias]
    mt = mergetool

  [merge]
    tool = mymeld
    conflictstyle = diff3
  
  [mergetool "mymeld"]
    # Gives you meld, with three comparison tabs. Assuming you're merging others changes into
    # your branch, this shows you:
    # - 1st tab: yours|merged result|theirs (do the merge here into the middle pane)
    # - 2nd tab: base vs your changes (look at just your changes)
    # - 3rd tab: base vs their changes (look at just their changes)
    cmd = meld $LOCAL $BASE $REMOTE --output $MERGED --diff $BASE $LOCAL --diff $BASE $REMOTE --auto-merge

BeyondCompare is much better and available on macOS too.

> On OS X, Meld is not yet officially supported. For pre-built binaries, these OS X builds are the best option.

> You can also get Meld from MacPorts, Fink or Brew; none of these methods are supported.

Can anyone recommend any of these unsupported options? The best diff GUI tool I've been able to find for OSX is DiffMerge (https://sourcegear.com/diffmerge/) on the App Store, and I'd like to have a tree view for folder comparisons.

Maybe strange question; but which diff and merge tools are not targeted at developers?

Edit: what->which

It's not open source, and comes with all the baggage of perforce, but p4merge and p4diff are just excellent tools that I install on every machine I work on.

https://discourse.gnome.org/tag/meld ## forum

https://gitlab.gnome.org/GNOME/meld ## code

Meld 3.21.1 — 07 Jan 2022 -- thanks Meld !!

Am I the only person who opens the whole conflicted project in VSCode and project-wide searches for ">>>>>>"

I try a few times, and always I get back to kdiff3. I feel less confuse with the 3 way view and separated merge output view.

I use meld by default. Honestly it's not great. I kind of miss beyondcompare. It is however readily available and works well enough.

I use vimdiff and occasionally kdiff3 for git merging. what I really like meld for is merging two directory trees (e.g. reconciling two forks of the same code), they have the best tree diff ux of any of the common tools I've tried.

I’ve been an Araxis Merge man my whole career. Most of my peers are either Araxis or Beyond Compare.

It’d be a great if an OSS tool was as good or better. But my experience thus far is that Araxis/BC3 are simply much better.

I was given a fresh copy of Windows at work the other week and had to install all tooling afresh. I decided to take the opportunity to try meld.

The first merge I did, even after reading the website, I couldn't fathom it. I understood the paradigm of merging into $BASE but couldn't figure out how to simply take these 5 lines from $REMOTE and these 3 from $LOCAL, so went back to the trusty Beyond Compare.

Might give it another shot.

I'm an xxdiff man myself: https://furius.ca/xxdiff/

I don't like the whole "balloons with tails" thing meld does. xxdiff strikes the best balance between "being a graphical tool" and "not having distracting clutter" in my opinion.

Is Meld aware of the programming language when it does diffs? The problem I have with many diff tools is that they'll detect block moves without regard for things like method boundaries. Instead of showing the change as moving a method's ordering, with some changes within those methods, most diff tools treat it as just text moves and changes.

So to me, "targeted at developers" should mean something more than what Meld seems to offer (i.e., more than just syntax highlighting and regex filtering).

It's disappointing that programming language-sensitivity isn't more common. [I developed a Visual Basic compare/merge app in the early 90s that did a good job of this because it did extra work to understand the structure of the code, splitting methods and sorting them before comparing.]

I have used Meld very happily for years on various Linuxes. But am not a developer—use it mainly for sync conflicts on things like to-do lists and article drafts. Thank you builders! It is an awesome tool.

It's my favorite and default diff viewer.

I remember at one point there was a new version (based on gtk3 perhaps) that didn't work as well (useless type of scrollbars and slow) and I did some shenanigans to have an older version again on archlinux. However now even fresh installs do look and work good, I'm not sure what happened to that new version, maybe they improved the gtk3 based one to be as good as the one before it and I don't notice the difference anymore...

Sorry, Meld is nice, but if you use version control you are handicapped if not using a 3 way diff program.

I never found one with features good enough to make me change from Kdiff3.

Love when ancient tools get reposted ;-)

This is older than most people here!

On the terminal I find `ydiff -s --wrap --width=0` very good for a comprehensible side-by-side diff: https://github.com/ymattw/ydiff

I definded this wrapper script ~/bin/git-ydiff-s:

    #!/bin/sh
    git diff "$@" | ydiff -s --wrap --width=0

I purchased Araxis Merge but I still find myself using Meld for the vast, vast majority of my 2- and 3- way Diffing.

It’s slightly tricky to integrate into Sourcetree but once you configure Sourcetree with the correct command line args it works quite painlessly.

Meld is extremely performant too.

Another text editor I love is “010 Editor”, it’s the only windows app I’ve found that works well on 2+ GB files without slowing my computer down.

On Windows, how does Meld compare with WinMerge[0]?

[0]: https://winmerge.org

Meld is great. The only nitpick I have is that winmerge was more efficient in resolving a file with the alt-down alt-left/right commands going one diff block at a time.

In meld, these commands operate depending on focus. When the focus is in the left file, alt-right merges to the right, but you cannot do alt-left to merge from the right file.

I use both Meld and Diffuse[1] depending on what I do. I find Diffuse represents diffs better visually, while Meld being better for actually merging contents since you can just click on those arrows.

[1]: https://github.com/MightyCreak/diffuse

The file contents two-way diff/merge visualization reminds me of NetBeans’ [0].

[0] e.g. https://stackoverflow.com/questions/10594653/is-there-any-wa...

I used it a lot many years ago, not so much now. I don't even know if it's on my laptop. I'm not using any other alternative. Maybe git merge and git diff are good enough for my needs. I'm also using both gitk and gitg, usually gitg. Maybe they qualify as alternatives.

these days, vscode does a fantastic job. you just use code --diff file1.js file2.js

Consider an alternative: diff2html - an npm CLI you install and summon with 1 command launches your default browser with a visual diff.

https://diff2html.xyz/

after all these years i still mostly use kdiff3

Haven't tried Meld and i'm always up for an enhanced workflow but merge/diff is all about context, the more context you can add about where something came from / is going to, its history etc the better. In this regard it is almost impossible (never say never) to beat your IDE for the possibility of a good merge/diff, it has all the context plus syntax highlighting, compiler errors / build scripts etc. I can merge two files, plus git blame where the changes came from, plus syntax highlight and see likely compile errors, remove unused imports and apply consistent formatting all in one step.

This is why I always use IntelliJ merge/diff for supported languages, it just has so much more information about the merge/diff already available.

I only recently used this for the first time and I must say: perfect for a quick file comparison. Don't know about other use cases. Nice to see it mentioned here.

With the switch to GTK3, it no longer fits on my screen (and headerbars stand out like a sore thumb too). Kdiff3 was confusing for a moment, but does a good job too.

I ran Meld on GHC Core before and after a subtle optimization to some slow Haskell. It called out exactly the improvement. Very cool to see.

What is the use case for a tool like this? I've never felt the need for anything beyond `git diff` (which uses `less`)

"Diffuse" has come to my rescue in the past when I've needed to do the odd 6-way diff (don't ask)

My memories of meld from the past: slow, confusing, crashed. Havent touched it in 10 years since.

I used to use meld before switching to vscode's built in visual diff

Yeah I know I'm an emacs zealot, but emerge works fine for me.

I wish it worked better in MacOS. Still my favourite tool.

Kaleidoscope on macOS isn’t cheap but has a great DX.

Meld rocks, thanks for making Meld Software Libre!

Love Meld, been using it for a while now.

Meld gets so many things right.

P4V is still the best cross platform diff/merge tool by far, and too bad it is relatively obscure.