Here I'm republishing an old blog post of mine originally from June 2018. The article has been slightly improved.
A lot has happened since I wrote this post. For example Raven has its own package manager called _ravensw_ now. It's a fork of FreeBSD's pkg(8) with some changes to make it more portable.
This post is about Ravenports, a universal package system und building framework for *nix systems (_DragonflyBSD_, _FreeBSD_, _Linux_ and _Solaris_ at the time of this writing). It's a relatively young project that began in late February 2017 after a longer period of careful planning. The idea is to provide a unified, convenient experience in a cross-platform way while putting focus on performance, scalability and modern tooling.
What exactly is it and why should you care? If you've read my previous post, you know that I consider the old package systems lacking in several ways. For me Raven already does a great job at solving some problems existing with other systems - and it's still far from tapping its full potential.
Modern-day package requirements
A lot of people will think now: "We already have quite capable package systems. What's the point in doing it again?”"Yes, in many regards it's "re-inventing the wheel"... And rightfully so! Most of the known package systems are pretty old now and while new features were of course added, this is sometimes problematic. There is a point where it's an advantage to start fresh and incorporate modern ideas right from the start. Being able to benefit from the experience and knowledge gained by using the other systems for two decades when designing a new system is invaluable.
Ravenadm running on FreeBSD, OmniOS, Ubuntu Linux and DragonflyBSD (PNG)
Ravenports was designed, implemented and is primarily maintained by a veteran in packaging software. John Marino at a time maintained literally thousands of ports for FreeBSD and DragonflyBSD. In addition to that, he wrote an alternative build tool called _Synth_. Aiming for higher portability, he modified Synth to work with Pkgsrc (which is available for many platforms) and also ported the modern Pkg package manager from FreeBSD to work with it.
In the end he had too many ideas about what could be improved in package building that would not fit into any existing project. Eventually Ravenports was born when he decided to give it a try and create a new framework with the powerful capabilities that he wanted to have and without the known weaknesses of the existing ones.
It probably makes sense to get to know Ravenports by comparison to others. Let's take a look at some of them first:
1) 1) FreeBSD's ports system is the oldest such framework. It's quite easy to use today, very flexible and since the introduction of pkg(8) (or "pkg-ng") it also has a really nice package manager.
2) NetBSD adopted the ports system and developed it according to their own needs. It's missing some of the newer features that FreeBSD added later but has gained support for an incredible amount of operating systems. Unfortunately it still uses the old _pkg_*_ tools that really show their age now.
3) OpenBSD also adopted the early FreeBSD ports system. They took a different path and added other features. OpenBSD put the focus on avoiding users having to compile their own packages. To do so, they added so-called _package flavors_. This allows for building packages multiple times with different compile-time options set. Their package tools were re-written in Perl and do what they are meant to. But IMO they don't compare well to a modern package manager.
4) Gentoo Linux with its portage system has taken flexibility to the extreme. It gives you fine-grained control over exactly how to build your software and really shines in that. The logical consequence is that, while it supports binary packages, this support is rudimentary in comparison.
EDE desktop, pekwm with Menda theme and brand-new LibreOffice (PNG)
FreeBSD gained support for flavors in December 2017 and NetBSD did some work to support subpackages in a GSoC project in the same year. It's hard to retrofit major new features into an existing framework, tough. When Ravenports started in the beginning of 2017, it already had those two features: _Variant packages_ (Raven's name for flavors) and _subpackages_. As a result they feel completely natural and fit well into the whole framework (which is why they are used excessively).
Ravenports knows ports options that can be set before building a package. Like with NetBSD or OpenBSD there's generally fewer options available compared to FreeBSD. This is because Raven is more geared towards building binary packages than being a ports framework to build on the target machine (which would defeat the goal of always providing a clean building environment). For that reason the options mostly exist to support the variants for the packages.
Compared to NetBSD's Pkgsrc, Ravenports supports much fewer operating systems right now but has a much easier bootstrap process (binary!) for all supported platforms. It also offers a much superior package manager. When comparing against FreeBSD, OpenBSD and Gentoo, Ravenports is much more portable and supports multiple operating systems and - with the exception of FreeBSD - comes with a more modern package manager for binary packages.
As Ravenports is not tied to a single operating system, it didn't have to take into account specific needs that are for one OS only. In general there are no second-class citizens among the supported platforms. Also it was made to be agnostic of the package manager used. Right now it's using pkg(8) only but other formats could be supported and thus binary packages be installed via pacman, rpm, dpkg, you-name-it.
Repology: Raven's package freshness in percent (06/25/2018) (PNG)
It allows for different versions of some software to be concurrently installed. If you e.g. want PHP 7.2 while some of your projects are stuck with 5.6 this is not a problem. It's also possible to define a default version for databases like MySQL and Postgres as well as languages like Perl, Python and Ruby. Speaking of MySQL: Raven knows about Oracle MySQL, MariaDB, Percona and Galera. Only the first one is currently available (the ports for the others are missing) but the selection of which product to install is already present and the others can be easily added as needed.
If you build packages yourself you'll notice that the whole tooling is fully integrated. Everything was planned right from the beginning to interact well and thus plays together just great. Also performance is something where Raven shines: Thanks to being programmed for high concurrency, operations like port scans are amazingly fast (if you know other frameworks).
Repology: Repology: Raven's outdated package count (06/25/2018) (PNG)
Raven follows a rolling-release model with extremely current package versions. In _Repology_, a fine tool for package maintainers and people interested in package statistics, Ravenports is the clear leader when it comes to freshness of the package repository: It rarely falls below 98% of freshness (while no other repo has managed to even reach 90% - and Repology lists almost 200 repositories!). If it does, it's usually for less than a day until updates get pushed.
This is only possible because much of ports maintenance is properly automated. This saves a lot of work and allows for keeping the software version current without the need for dozens of maintainers. Custom port collections are supported if you have special needs like sticking to specific program versions. This way Raven can e.g. support legacy versions that should not be part of the main tree. It might also be interesting for companies that want to package their product for multiple platforms but need to keep the source closed. Ravenports supports private GitHub repositories for cases like this. All components of the project itself are completely open-source, though, and are permissively licensed.
Also Raven is not the jealous kind of application. Packages are installed into _/raven_ by default (you can choose to build your packages with a different prefix if you wish) and thus probably separate from the default system location for software. This makes it possible to use raven in addition to your operating system's / distribution's package manager instead of being forced to replace it.
If you ask me about permanent problems with Raven: I don't really see any. However there's definitely a couple of things where it's currently way behind other package systems. Considering how young the project is this is probably no wonder.
It's a "needs more everything" situation. In fact it has the usual "chicken egg problem": More available ports would be nice and potentially attract more users. With more users probably more people would become porters. And with more porters there'd surely be more ports available... But every new project faces problems like this and with resolve, dedication and perseverance as well as a fair amount of work, it's possible to achieve the goal of making a project both useful and appealing enough for others to join in. Once that happens things get easier and easier.
Repology: KeePassXC, Geany and the EDE application menu (PNG)
The Ravenports catalog has over 3,000 entries right now. It's extremely hard to compare things like the package count, though. John provided an example: FreeBSD has 8 ports for each PostgreSQL version. With 5 supported versions that's 40 ports. Ravenports has 5 ports with 8 subpackages each. In this case the package count is comparable, but not the port count. Taking flavors and multiversions into account, all repositories look much bigger than they actually are in case of available software.
Also how to measure the quality of packages? What's with ports that are used by less than a handful of people? What with those that are extremely outdated? Do you think they should count? It's probably best to take a look and see if the software that you need is available. It is true though, that there's of course still many important packages missing. IMO the most important one being Rust - which is not only needed for current versions of Firefox but increasingly important to build other software, too.
Also Linux support is not perfect, yet, and Solaris support even less so. On Solaris systems Raven is currently mostly binary-only because the Solaris kernel is unable to work with system libraries other than the ones matching exactly in version. Packages built on older releases of the OS work fine on newer ones, but for each OS release, a specific build environment would need to be created before building packages is possible. This is an issue that needs to be resolved in the future (I guess some help from the illumos / Solaris community wouldn't hurt). Also there are packages that don't build on Solaris without patches which are not currently available. In case of important packages this leads to blockers since all other ports which depend on one such package also cannot be built: On FreeBSD there are 3,559 packages (including variants and metapackages) available from the repository at the present time. In the Solaris repo it's only 2,851 packages. That's certainly a nice start - but don't expect to run a full-fledged desktop (or even X11 at all) there, yet!
In Linux land, distributions that come with glibc version 2.23 or newer work best. On distributions with older glibc versions (e.g. CentOS 7), software will not run as the standard C library is missing some required symbols. Raven will need to be bootstrapped again to support those distros. This is likely to happen before too long, but we're not there, yet.
Repology: Current Firefox ESR version (+ sakura and pcmanfm in the panel) (PNG)
MacOS (which might be supported soon), OpenBSD and NetBSD are not currently supported, nor is Linux with musl-libc or μclibc. Also currently Raven is amd64 only. ARM64 support is planned and i386 might or might not happen but are not available now.
At this time Raven is probably most interesting for people who love tech and enjoy tinkering on *nix systems as well as those who like the features and are ok with being early adopters. Yes, in general it's ready for the latter. At least two people (including me) use Raven's packages exclusively on one of their machines. I'd say it is ready as a daily driver (if you can live with the limited set of software available - or consider adding more ports). In fact I built a laptop that I use e.g. for on-call duty with it. Since that one is critical, it probably needs to be considered as "in production use".
It's possible to install various text mode applications with Raven, but X11 is also available. You can choose from multiple window managers or from at least two desktop environments (Lumina and the ultra-light EDE). Xfce4 is partially available (i.e. the panel is already ported). If you're looking for web browsers, a current version of Firefox ESR (called "rustless-firefox") can be installed as well as Surf, a simple webkit-based browser. The LibreOffice suite is available in its latest version, too. The same is true for the just released Perl 5.28 and Python 3.7.
Repology: Running Chocolate DooM and Chocolate Heretic (PNG)
Oh, and if you're into gaming... It's not all just serious stuff. Yes, you can install and play DooM!
Ravenports is a fascinating project with lots and lots of possibilities. I wanted to get into porting with FreeBSD for quite a while but hesitated as I'm not a programmer. Then again I had been interested in package building for a long time and had played around with it on Arch Linux quite a bit. After my submissions to FreeBSD had been rotting in bug tracker for months (and still are after almost a year), I chose to give Raven a try in the meantime.
I was already familiar with Pkg and had used Synth before, too. Bootstrapping Raven's pkg and then installing stuff was as easy as expected. The same was true for building the ports myself. Then I did quite a bit of reading and wrote my first port. It didn't take more than 5 minutes after I opened my pull request on GitHub, before John responded - and the port was committed not much later. This was such a huge contrast that I decided to do more with Raven.
There was a learning curve, yes, but I received lots of help in getting started. I obviously liked the project enough to become a regular contributor and even got commit access to the ravensource repo later. Currently I'm maintaining just over 80 ports and I hope to write many more in the future. There have been some hard ports along the way (where I learned a lot about *nix), but lots of things are actually pretty easy once you get the hang of it.
Repology: Tongue-in-cheek: Make chaos or "make sense"! (PNG)
If this post got you interested, just give it a try. Feel free to contact me if you run into problems and I'll try to help. After this general overview of Raven the next post I plan to write will be on actually using it.
