Pure on Arch Linux
The Pure packages for Arch Linux are maintained in the Arch User Repositories (AUR). This is a complete collection of all Pure-related packages, as well as a few dependencies which aren't packaged elsewhere. You can install directly from the AUR, with the yaourt program, e.g.:
yaourt -S pure
Please note that this will build the package(s) from source, which may take a while.
Manjaro users: For users of the Arch derivative Manjaro we also offer a complete collection of binary packages (x86_64 and i686) at Bitbucket. All you have to do to install from this repository is to add the following section to your
[pure-aur] SigLevel = Never Server = http://pureaur.bitbucket.org/$arch
Once you've done this you'll also be able to install packages as usual with pacman, e.g.:
sudo pacman -S pure
Arch users: The binary packages for Manjaro often work on plain Arch systems as well. But since Manjaro is usually some 1-2 weeks behind the official Arch repositories, it's generally advisable to install the Pure packages directly from the AUR instead, so that they are compiled against the latest base libraries. (Real Arch users will prefer that method anyway.)
Except for some (optional) Haskell dependencies as noted below, all required dependencies should be readily available either in the official Arch repositories, in the binary Pure repositories (if you use those), or in the AUR. If you run into any missing dependencies then please let us know so that we can fix the issue.
There is one optional package (pure-pandoc), however, which requires a recent version of the pandoc program which isn't available in the standard repositories right now. This package isn't required for a working Pure installation and doesn't get installed by default. If you want to use that package, we recommend installing the haskell-pandoc package and its dependencies from the ArchHaskell repository. (You may want to add this repository to your pacman.conf anyway if you're using Haskell, since the official Arch repositories only provide a rather limited collection of Haskell-related packages.)
Package Groups and Meta-Packages
At the time of this writing, the AUR Pure collection consists of some 60 packages, which includes the Pure interpreter, online documentation, addon modules and utilities, as well as various useful dependencies which aren't available elsewhere, such as Faust and Gnocl. To make it easier to handle the amount of packages available, we offer various package groups and meta-packages which both enable you to manage entire collections of Pure-related packages. At present the following package groups are provided:
- pure-base: interpreter, standard library, documentation and emacs mode
- pure-graphics: interfaces for graphics and GUI programming
- pure-math: interfaces to various 3rd party mathematical software
- pure-multimedia: interfaces to audio, MIDI, OSC, Faust, Pd
- pure-util: basic support utilities and libraries
- pure-web: interfaces for database and web programming
- pure-complete: the whole shebang
When installing from the binary package repository, you can use pacman to install an entire package group at once, using a command like the following:
sudo pacman -S pure-base
There's also a pure-complete package group which lets you install the full Pure system in one go:
sudo pacman -S pure-complete
In a similar fashion, you can remove an entire package group with a single command, e.g.:
sudo pacman -R pure-multimedia
It is also possible to list all the packages contained in a specific group as follows:
pacman -Sg pure-math
Please note that these facilities only work with the binary package repository, because the AUR doesn't support package groups right now.
Therefore, and as an alternative, we also provide a collection of Debian-style meta-packages which represent the same package collections. Each meta-package is simply an empty package which pulls in the packages from the corresponding group as its dependencies. For instance, when installing from the AUR using yaourt:
yaourt -S pure-meta-base
There's also a pure-meta-complete package which pulls in all the other meta-packages and thus installs the entire package collection:
yaourt -S pure-meta-complete
The end result is pretty much the same as with package groups, but meta-packages work with both the AUR and the binary package repository, so if you install from AUR sources then this is the only way to go. Moreover, meta-packages can be updated if the collection of packages in a group changes, so that a subsequent upgrade using
pacman -Syu or
yaourt -Syua will automatically install any new packages in each package group. Last but not least, the meta packages also provide you with a quick way to install entire package groups with pamac, octopi or one of the other graphical pacman/yaourt frontends.
The downside is that meta-packages have hard dependencies on all the packages in the group, so that individual packages from a group can't be uninstalled unless the corresponding meta-package is removed as well. The Pure meta-packages are in their own pure-meta package group, so that they can all be removed at once using the following command:
sudo pacman -R pure-meta
Packages Built from Repository Sources
For users who like to live on the bleeding edge there are the pure-hg and pure-docs-hg packages which will install the latest snapshots of the interpreter and the online documentation from Pure's Mercurial repository:
yaourt -S pure-hg yaourt -S pure-docs-hg
Please note that these packages aren't included in any of the package groups discussed above, so if you want to use them you'll have to install them separately, either beforehand, or by swapping out the pure and pure-docs packages if you already installed these or the pure-complete or pure-base package groups.
If you really want all the greatest and latest stuff, there's also a complete alternative set of packages built straight from the latest repository sources. This also includes all the addon modules and utilities. The packages are all created from a single PKGBUILD which can be found here.
Arch users: The AUR doesn't support split packages very well, so you'll have to download the PKGBUILD and run makepkg if you want to build the packages yourself:
wget https://bitbucket.org/purelang/pkgbuild/raw/HEAD/pure-complete-hg/PKGBUILD makepkg
Note that the makepkg build requires a prior installation of the Pure base system as well as a few other dependencies; makepkg will tell you which packages need to be installed beforehand. Once makepkg finished downloading and compiling the sources, it will create a bunch of binary packages (.tar.xz files) which can be installed with pacman as follows:
sudo pacman -U *.xz
Of course, you can also build your own Pure package repository from the resulting packages with repo-add and use this with pacman as usual. This will be more convenient if you just want to install some of the packages or package groups. Or you might try using the pure-aur-hg binary package repo described below.
Manjaro users: We provide ready-made binary packages at Bitbucket. In order to use these, configure your pacman.conf as follows (note that the pure-aur repo is still needed as well for the various dependencies):
[pure-aur-hg] SigLevel = Never Server = http://pureaur.bitbucket.org/hg/$arch [pure-aur] SigLevel = Never Server = http://pureaur.bitbucket.org/$arch
The Pure packages in the
pure-aur-hg repository are organized in the same way as those in the
pure-aur repository, but the package groups and meta-packages all have an additional
-hg suffix. So they can be installed as follows:
sudo pacman -S pure-complete-hg
Or, if you prefer the meta-package:
sudo pacman -S pure-meta-complete-hg
This will give you a kind of "rolling release" of the Pure system, since the packages are updated regularly if there are any worthwhile changes in the source code repository.
Alastair Pharo <asppsa at gmail.com> is our current AUR packaging overlord. Please mail him or post to the Pure mailing list if you have any questions concerning Pure's AUR packaging. We also have a special pure-aur mailing list for the Pure AUR package maintainers at freelists.org, so if you have a question or would like to get involved, you can also subscribe to this list and post a message there. We're always looking for people who would like to provide a helping hand by adopting one or more AUR packages to maintain. There is a whole bunch of packages to look after, so this provides an easy way that any Arch user can contribute to the project.
The current list of packages can be found by using the search function of the AUR website. We also have a git repository with all the Pure-related package builds; you can find that here. The repository also offers some infrastructure for automated builds and uploads of source and binary packages.
To make it easier for potential contributors, Alastair has written up some basic instructions for those who are new to Arch packaging. You can find these below.
A Quick Introduction to AUR Packaging
The gist is that there are source packages, which are
.tar.gz files that generally only contain a folder with the same name as the package, and a single file in that folder called
PKGBUILD, which is a special bash script that contains a bunch of variable assignments and function definitions. The packaging standards document gives the details on what is and isn't allowed in a
The source package is built into a binary package by extracting it somewhere, changing into the directory containing the
PKGBUILD file, and running
makepkg (comes with Arch).
makepkg will by default create a binary package for the platform you are on at the time. You can then install that into your system using
pacman -U <package file>. When you install a package from AUR using
yaourt, it is just a wrapper for the above steps.
Hence, you can download and extract a source package (or create a fresh
PKGBUILD), alter the
PKGBUILD file, run
makepkg, and then install the resulting package in order to test your
PKGBUILD files without uploading them to the AUR first.
There are a couple of other things:
You can install a helper tool call
PKGBUILDfiles for various common issues. This is highly recommended.
You can use
yaourtto download and extract source packages for you. E.g.:
yaourt -G pure.
If you're making a package from scratch, you would probably want to copy the
PKGBUILDprototype from the Arch Packaging Standards.
Once you're happy with the package, you need to make the source package in order to submit it to AUR. You do this with
Uploading packages into AUR is a pain to do using the web interface, so many people use the
burptool (this can be installed using