MacPorts vs. Fink vs. Homebrew [duplicate]

I always used MacPorts to install and maintain my GCC compilers and other programs. Now I've heard about Fink and Homebrew. It seems these two utilities are gaining ground in the Mac community, but I don't understand the difference between them.

What is the main difference between MacPorts, Fink, and Homebrew? Is there any difference in quality or performance?

Fink has been around since at least 2001. Fink and MacPorts are package managers that want to be "orthogonal" to the system, that is, they install their own version of python, perl, libraries, compilers, etc. in own trees (/sw for Fink, /opt/local for MacPorts). The reason for this is that they have no control what Apple does with its software, and it occasionally broke things when Apple updated their own stuff.

From what I understand, Homebrew wants to be more "integrated" with the system, uses the libraries that Apple provides, and installs its stuff in /usr/local/bin and other standard folders. I guess that means that the software choice is more limited with Homebrew, I can't imagine that one could install KDE with it, but I've not tried that.

One point for Fink vs. MacPorts: a few years back, the Fink project provided binary packages; that is you could download and install the packages without compiling them yourself. Its package manager still has that ability, only there have been no binaries available for a long time. I do not know if that has changed in the meantime.

So in short: without the binary stuff, Fink and MacPorts are very similar. They should have more packages available than Homebrew, while Homebrew should take less disk space for the reasons I stated above. Concerning the quality: I've never installed Homebrew, and between Fink and MacPorts I usually prefer the one that I'm not currently using.

So if you are satisfied with MacPorts, just stay with it.

P.S. The reason I never tried Homebrew is that I use some precompiled packages. These usually also install themselves into /usr/local/bin and the like, which just cries for trouble.

I'd say the main differences are:
Providence, outcome, and the method of distribution.

The most important detail will be for you to check if the system you choose contains package(s) for the software you want. Package counts are approximately: 19k Macports, 22k Fink, 3k Homebrew, 10k pkgsrc.

• Macports, formerly Darwin ports seems to be a BSD style ports system like pkgsrc which gets source, patches it, builds it, and installs it. If it is very like pkgsrc it'll do this using shell scripts. It used to rely on the tools provided by Xcode, but that started causing problems, so now it can also bootstrap gcc. Additionally there's some binary packages out there, but you may not find the latest version for your system every time. It came from Darwin, the Apple open-sourced BSD based on the OS X kernel which ceased distribution. It installs packages to /opt/local which probably won't get touched by other installer packages or system upgrades.
• Fink, re: finches being the subject of Charles Darwin's study, is a package system based on Debian Package Manager, that means it features use of dpkg and apt-get the main benefit being that that you can reliably find binary packages.. assuming you have an upstream package repository that contains binaries for your current OS version. It also came out of the Darwin user-base but probably more popular with those who came from Debian Linux [for mac, or PPC] looking for a little more stable hardware support... while it lasted. It installs packages into /sw for reasons of not overwriting or getting overwritten what other installers might install. Also something about compiler search paths and the default PATH containing /usr/local/bin already.
• Homebrew is a kind of ports system in concept, but written in ruby. It doesn't come from a stand-alone OS world and was intended for Mac OS X users (the others are thoroughly used and tested by the same). As of mid-2014 it tries to build basically every package (they call them formula) though a few are available in binary form called bottles, and you can make a repository of bottles to share in your social group if you're inclined on semi-standardizing you and your friend's toolchains (ditto for other systems). On the plus side, it builds using as many of the libraries as you probably already have that came from Apple. I think you don't need Xcode for it to work in most cases, but it "supports and recommends" it. You can install each item in its own prefix, but the default is the relatively integrated /usr/local I think it was kickstarted and is more recent than the others. I've personally found I used this one most because I rarely need interdependent packages, and I'm unclear on how well mac homebrew supports it. Homebrew aims to force you to use more appropriate package managers for software that originates from a tightly coupled manager, like cpan, gems and the like.
• pkgsrc would be available for Mac OS X, has binary packages, and comes from NetBSD which maintains it and in turn based it on FreeBSD's port system. NetBSD was so focused on portability across architectures that it was probably the best candidate port system to start supporting other platforms too, which it has. It's similar in my description to Macport, but I've not used it (except on NetBSD), and I think it installs into / but builds and maintains packages in /pkg. There's probably a lot of packages (like 12k) and some 20% may not build, or, the latest version of the source may not patch with the last maintained patch. That's why the binary packages are my preference with these kinds of systems.

I've also used perlbrew which is a kind of homebrew for perl, applications built in perl and some dependencies. It's mostly a good way to maintain multiple versions of perl, and it conveniently negates the need for other more general package systems (for its purpose). But of course that also has cpan and cpanminus.

You might find similar managers for your own mini-environment (like vundle for vim, or gem for ruby, npm for node.js, pypm or pip for python, go's built-in go install ... etc?)

Fink and MacPorts are direct competitors in that they install an orthogonal system. Fink lost considerable ground to MacPorts several years ago. I'm not completely sure why now, but MacPorts handled almost everything better.

We've less reason for an orthogonal installation now that Mac OS X has grown less crazy pants. Brew was otoh created to integrate better with Mac OS X, making it lighter weight and less orthogonal, and also because Rubyist rewrite everything.

In practice, MacPorts is a bit more complicated, but MacPorts almost always works, while Brew is simpler but more likely to run into a brick wall.

Ask yourself these question :

• Do you use many Linux ecosystem tools?
• Do you need multiple versions?
• Do you experiment with new tools much?
• Do you use math/science tools/libraries or other unusual tools?

Any yes answers suggest you should choose MacPorts. Brew is less overhead if you install relatively few and common packages, but Brew won't handle complexities as well. Brew pollutes /usr/local which you might want for manual installations too. Actually, there are more detailed arguments for MacPorts but again they probably do not apply if you answered no.

Conversely, if you answered yes but your primary machine runs Linux, and your Mac is only a toy running minimal Linux software, then actually you might do better with Brew.

But as a side note, nothing Apple OS X related would install itself into /usr/local/bin. They use /usr/lib , /usr/bin behind the scenes and frameworks gets packaged up into /Library/Frameworks while stuff you install yourself via the regular Unix ./configure, make, make install will use /usr/local/bin etc, and utilities like MacPorts will use /opt/ and possibly package frameworks to your personal ~/Library/Frameworks/.

My recommendation is to stay with MacPorts if that's what you're used to. Basically the main difference is that MacPorts uses a system that closer resembles the true Unix/BSD ports tree implementation with ports from FreeBSD, while Fink uses applications ported from the Linux Debian archives, and uses the same package manager system as Linux Debian.