Meld is a visual diff and merge tool targeted at developers | Hacker News Reader

Meld is a visual diff and merge tool targeted at developers

meldmerge.org

334 pointsdanielsokil144 comments

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/

Same here. So far it's my favorite UX for solving non-trivial merge conflicts.

Same. I don't know why but there's something so intuitive and easy to use and yet so powerful about Sublime Merge's merge tool that it quickly became my favorite after having used a lot of different other tools in the past (TortoiseGit, Meld, etc.)

Sublime Merge is a fanastic tool (I use it) but it's less of a merge tool and more of a git client, which I think is an important distinction.

Yeah. I would be interested in using Sublime Merge as a Merge tool for projects based in Perforce and Mercurial. But last I checked it wasn't really capable of that.

It should have been called Sublime Git. Alas.

a nice feature of sublime merge that i haven't seen in other programs is actually showing you the git commands that will run when you press whatever button

i believe the IntelliJ Git tool window does this as well FWIW

Also the ability to create custom menu items (e.g for any context menu) for whatever command you desire. It's a game changer for me that I haven't seen in any other git client.

Also it's lightning fast and relatively bug free compared to the mess that is Sourcetree, which used to be my favorite client but then went utterly downhill.

I don't know if it's on par with SM, but Git Fork has a system for custom commands which result in custom context menu entries in most cases.

It uses categories like per-commit or per-branch commands.

Magit does this

Sourcetree also shows the git commands it runs, but not before it runs them.

I don't understand the comparison. Isn't meld free?

Not sure what you're trying to say. Free vs not free is not the most important axis to consider when evaluating software.

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.

Meld already supports text filters!

absolutely,meld is my favorite,along with the filters

Yes! There are text filters but those are kind of a static setting, found somewhere in the Preferences menu. When I wrote my comment I had in mind some user input that could be more interactive for one off, line based filtering. Although you are right, the already existing filter settings can be used for what I said, if one already has a regex that works fine for the current text being compared.

Yeah, I use it a lot, but 80% of that is comparing arbitrary text that I just want to copy-paste in. To be fair, that's just two clicks now (first click "File" comparison, then "blank comparison"), but that still feels a bit cumbersome.

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/

I setup Git to use Perforce’s P4Merge as the Git mergetool. P4Merge is cross-platform and free and quite good.

There are 2 things to consider when comparing them: 2 panel diffs and 3 panel merging.

P4Merge is very good at the second but not so much at the first.

Also, to this date it doesn't have an OS-X version for M1 CPUs.

Do you think the pro version of BeyondCompare is worth it compared to the standard one?

You need the Pro version to do a 3-way merge.

Yes, I bought it years ago and it's been one of my goto tools. Worth every penny, plenty of features beyond just being a git mergetool.

Depends...

Pro version gives you 3 panel merging. If you use that a lot then it might be worth it. Or, instead, use P4Merge for it.

Yes. They often have sales, and I picked up Pro for about the price of Standard a few years back. If you see a sale, get Pro. If you are not worried about the pro feature set, get standard.

The other thing is that the trial used to be very fair. I don’t know if they changed it, but it used to give you “days of usage” not contiguous days. I once used it for about 5 months because the 30 day trial only counted the days I actually used it and I saved using it for when I really needed it, and used WinMerge when I could instead.

Beyond Compare is a gem.

I actually don't understand what people love about BC. The only thing I find it extremely useful for is the occasional files where inline diffs are practically mandatory, like CSVs. Other than that, I generally find it frustrating compared to TortoiseGitMerge, except perhaps for some very specific/unusual scenarios. In particular the line highlighting is annoying - instead of coloring the lines that were added vs. removed differently, it colors lines according to whether they're an "important difference" or "unimportant difference" (?!), which is borderline useless to me. What do people love about it so much?

+1 for TortoiseGitMerge, which is my go-to tool these days. It's Windows only but not a problem for me since I mostly work in Windows.

My SO adores Meld, but she works with Linux. I tried using it but couldn't get used to it. She also makes fun of me (half in jest) because I use Tortoise Git instead of the command line...

I use TortoiseGit too, ever since I used TortoiseSVN back in the day. Highly underrated, and ridiculously powerful, I’ve practically never had to look up “how to do x” :)

The things that makes it borderline useless to you is actually one reason I like it so much. Makes it really easy to do code reviews and focus on what actually matters. Also, it was until somewhat recently the undisputed best 3-way merge tool. Meld gets close, but to me Meld's UI is sluggish and fuzzy (on Windows) while BC is snappy and sharp.

Maybe I need to try Meld at some point. Have you tried TortoiseGitDiff by any chance?

I’ve been using BC since the early 2000’s, so probably more than 15 years. I know it backwards and forwards. If you set it up right, it is pretty powerful. It allows a lot of the stuff that other tools fail on to be overcome. Manual alignment is a dream. The rules based comparison is very nice. Ignoring unimportant differences removes pretty much all the white space differences. The ease of selecting arbitrary blocks and moving them left or right is powerful. I’ve tried both Windiff and kdiff3 and both have missing features.

Back before git, it was common to take a massive set of changes and merge them manually when merging branches, and BC was the only tool that made it painless for me.

I stumped up my own cash for a pro license and I use it almost daily even now.

Interesting. Have you tried TortoiseGitDiff? I'd be curious what you think of that in comparison if so.

Update: I just downloaded Meld. It literally takes ~half a second to change the cursor location when I click in a highlighted region, which is already making me dislike it. Is this normal?

I'll add the ability to specify and tag regexes ("comment", "timestamp", etc) on a file-type by file-type basis, and then specify various tags as "unimportant" for the current diff is super powerful.

It means you can do things like compare two system logs from different times and have it highlight you exactly the differences you care about.

And the theme is unusable on KDE dark theme to a red blue color blinded user.

winmerge is definitely the best windows-only open source app I've used. surprised it's never been ported to linux.

WinMerge for comparing two individual files. BeyondCompare for comparing deep nested directory structures.

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.

I really wish kdiff3 would get a modern update.

kdiff3 does have a modern version: https://invent.kde.org/sdk/kdiff3/.

Unfortunately versions starting at 1.9.0 are drastically buggier than 1.8.5: Ctrl+C being incorrectly enabled and disabled (https://bugs.kde.org/show_bug.cgi?id=444636), merge errors (https://bugs.kde.org/show_bug.cgi?id=437570, fixed), drastic slowdown when loading CRLF files (https://bugs.kde.org/show_bug.cgi?id=450411, fixed), recurring assertion errors (didn't personally encounter, but https://bugs.kde.org/show_bug.cgi?id=426301, https://bugs.kde.org/show_bug.cgi?id=442618), large chunks of Git history producing unusable binaries that corrupt memory or print assertion errors when loading files, etc. I stopped following KDiff3 development and decided to pin 1.8.5 on my system, which actually works.

Another fork of KDiff3 is https://github.com/michaelxzhang/kdiff3. I haven't tested it, but I hope the alternative diff coloration makes it easier to see single-word/space insertions and deletions within a line (which is something I often fail to notice in mainline KDiff3).

> original file, version A, version B, merged result

Isn't one of version A or B the original file? What am I missing?

In a merge conflict versions A & B would tend to be different changes made to the original, usually made by different people.

the "original" file is the common ancestor of version A and version B

http://psung.blogspot.com/2011/02/reducing-merge-headaches-g...

This is a good discussion on the topic including the diff3 option git has.

My .gitconfig for using meld at the git merge tool - which gives you that:

  [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

I agree 100% on the utility of a 4 panel diff, but I'd be careful using kdiff3... I also used it for quite a while but found that it would "auto resolve" some merge conflicts which git would flag, and I found it would sometimes auto resolve them wrong (maybe about 10-20% of the time?), and I couldn't figure out how to turn this feature off... I'm using tortoise git merge now (which also does do some auto resolve but only simpler resolutions)

According to `kdiff3 --help`, there's a flag --qall "Do not solve conflicts automatically.".

I've not noticed the problem you describe, so can't confirm whether it is solved by that flag - a while ago I mostly switched to Sublime Merge from kdiff3.

i've used kdiff3 for some hairy merges with good results.

back in the days when i was responsible for regular merges for a pretty big project (weekly or so, 10-30 devs on both sides, n*1e7 LoC), i took the time to learn ediff and did my merges in lucid/xemacs.

i had colleagues at the time who had nice things to say about beyondcompare.

more recently i have seen this meld thing and it has piqued my curiosity.

favorite tool for quick no-frills out-of-practice-with-real-tools visual diff is fldiff built on fltk.

Another vote from here. I've tried a good number of merge tools but always go back to KDiff3. It has the best automatic merge conflict resolver I've seen, and really just enables me to fix things and continue.

I often have colleagues who are inexplicably afraid of merge conflicts and try to negotiate who's working on which parts of the app. I think a proper merge tool could help them to overcome this.

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.

same here!

it may not be the best merge tool in existence but it's adequate (which is actually, suprisingly good, given it is not at all its intended function) and at that point having all my standard vim configuration, editing capabilities etc. beats anything another tool would bring to the table.

Not to mention, 100% terminal UI and built-into-vim means I can use it everywhere and anywhere without thinking about it.

If you want to use it with git:

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

And use git difftool instead of git diff

On my Ubuntu based (Xubuntu, Mint) workstations this works without any configuration

  $ meld .

That command is only for diffing against Git HEAD. `git difftool` supports all the ways to diff with Git.

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.

I like kdiff3 better for 3 way merges, and meld for comparing two files.

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

So this works by 'git merge feature/branch' and then call 'git mt'?

Yes. If you have a conflict, you can either run `git mergetool` and it will use that meld config. `git mt` is an alias for `git mergetool`.

BeyondCompare is much better and available on macOS too.

I use Beyond Compare mainly for sync of folders by comparing files (sizes, dates) and not for file contents diff as such. Part of my backup strategy while copying/syncing file between windows/mac/NAS ;-)

I've been a passionate Beyond Compare user for about 2 decades now. I swear by it. Great for diffing images as well.

Me too. It is an amazing tool.

Another vote for Beyond Compare here, 10 years service with Git.

Adding another vote for BeyondCompare. It's not free, but it's fantastic.

I'll have to check it out, but I'm pretty happy with Kaleidoscope. https://kaleidoscope.app

Does BC has 3 way diff/merge?

Absolutely.

> 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.

I'm using the build from Brew, works fine.

I second that. DiffMerge every day for almost 10y

Sometimes when I want a visual representation I use Apple's FileMerge, but for everything else I just use diff and patch.

Since you mention folders:

https://kaleidoscope.app/

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

Edit: what->which

Wikipedia, Google Docs, Microsoft Word... they're far simpler systems, but still useful for everyday edits

These have some diff functionality but are not "diff / merge tools". There are diff tools, though, targeted at lawyers for legal work: "show me the differences between these two contracts" and the such (which most developer-oriented tools actually suck at as they care too much about "lines" and whitespace).

I don't think it's that black and white? Google Docs, for example, lets you individually review and accept/deny/revise each individual suggested change. It's not a 3-way merge like programmers are used to seeing, but it's the same idea... you start with an original, see someone else's changes, and decide which to keep, or you can take their changes and further edit. And comment in-line too.

I've never used a lawyer's diff tool, but my IDE (IntelliJ) ignores whitespace and lines.

> There are diff tools, though, targeted at lawyers for legal work: "show me the differences between these two contracts" ...

Do you have some examples from the top of your head?

Comparing the content of PDF files would be awesome, and I don't mean comparing graphically but textually.

Not in any way affiliated with them but “Snowtrack is the intuitive versioning tool for creatives.”: https://snowtrack.io/about.html

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.

How is it not open source? The very first download link is to download the source. And it’s GPLv2 licensed.

They’re talking about the p4 tool they use

What baggage? They can be downloaded separately

https://www.perforce.com/products/helix-core-apps/merge-diff...

As another former p4 user, know of any git tool that provides anything like p4's blame viewer (was it called "time-lapse view"?)?

Afraid not, it's one of the things I miss most about p4.

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 do the same. >> usually does the trick

You're not alone.

I stand with you.

There are dozens of us! DOZENS!

This is often the only reason for me to open vscode on a project. I hate everything about their git flows, except the merge UI

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.]

There's the commercial SemanticMerge [0] which might work if it has a parser for the language that you use. According to their docs they currently only support C#, Java, C, C++ and PHP [1].

[0] https://www.semanticmerge.com/

[1] https://www.semanticmerge.com/features

That sounds like the sales pitch for Semantic Merge: https://www.semanticmerge.com/features/

I haven't tried it, but it does seem like a good direction to be trying to take merge tools.

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.

Meld is a 3 way merge tool.

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

with which you can do `git ydiff-s` in your repos easily.

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.

> Meld is extremely performant too

I've ben using Meld daily for more than 10 years now. I am not so sure it can be defined "performant". Maybe your box is really powerful, but on small and mid-sized systems its performance is more on the clunky side.

I remember its performance worsened when it migrated to GTK3. It has stayed semi-slow for me since then.

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

[0]: https://winmerge.org

WinMerge is better. It has better UI: bottom line comparison, keyboard shortcuts, copy left to right and vice-versa, lots of preferences settings, etc. Too bad it is Windows-only.

If you can accept a paid version of WinMerge for Linux and Mac I'd highly recommend BeyondCompare (U$ 30.00).

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

meld will compare trees of folders. Does vsc?

Yup. Tons of options.

https://marketplace.visualstudio.com/items?itemName=L13RARY....

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

It remains the best option for 3-way merge. For diff, I find myself just reading the raw diff output.

Works fine for 2-way diffs too

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`)

It depends on the user I suppose. I use the `git diff` and bare `diff` and `patch` commands which works fine for me, but there are a lot of people who either just don't like it or don't want to dive that deep into those tools.

"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.

And so you should be. Smerge is a useful addition, including as a find-file hook for resolving conflicts.

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

https://kaleidoscope.app/ is by far the best Mac solution.

For diffing yes but for merging... I have never gotten myself to use anything but DiffMerge. And now with their rewrite and price tag... Never ever.

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

I too wish Kaleidoscope wasn't quite so expensive. I've had my eye on since the v3 rewrite but can't bring myself to spend $150 on a tool I'll only use occasionally. I wish there was a "lite" version for $50.

Right. I would've hesitated to upgrade if it wasn't for the upgrade discount.

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.

Reply on news.ycombinator.com