Pure on Arch Linux

NOTE: This page is outdated! As of August 2019, these packages have been moved to the Open Build Service. Please check the following wiki page for details: https://github.com/agraef/pure-lang/wiki/PureOnArch

The repositories described below will stick around for the time being, but won't be updated any longer.

Permanent link to this page for bookmarking: https://pureaur.bitbucket.io

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, using your preferred AUR helper program, e.g. (taking aurman as an example):

aurman -S pure

Please note that this will build the package(s) from source, which may take a while. (Of course, you can also download the build files manually and use the makepkg program to build and install the packages.)

Manjaro users: For users of the Arch derivative Manjaro we also offer a complete collection of binary packages (x86_64 and i686) at Bitbucket. To install from this repository, you need to add the following section to your /etc/pacman.conf file:

[pure-aur]
SigLevel = Never
Server = https://pureaur.bitbucket.io/$arch

Then run pacman -Sy to synchronize your repository information. Once you've done this you'll be able to install the packages as usual with pacman, e.g.:

sudo pacman -S pure

Of course, you can also use Manjaro's pamac or one of the other available GUI frontends to pacman instead.

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

EOL: 32 Bit Support

Please note that Arch and most of its derivatives don't support 32 bit systems any longer. As a result, while we still keep the 32 bit packages in this repository around for the time being, they won't be updated any longer. If you're still running a 32 bit Arch system, you should be able to install the latest version of these packages directly from the AUR instead, see below.

Dependencies

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.

LLVM 3.5: This legacy version of LLVM is currently required for Pure. It used to be available in the official Arch repositories, but recently got removed, so we now provide suitable packages both in the AUR and in the binary Pure repositories (look for the clang35, llvm35 and llvm35-libs packages). NOTE: If you install these from the AUR, please note that llvm35 is a split package, thus you need to use an AUR helper such as aurman which supports that kind of thing (yaourt doesn't), or download a snapshot and install manually using makepkg.

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

E.g., 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

Most of that also works with the AUR, using an AUR helper which supports package groups, e.g.:

aurman -S pure-complete

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 aurman:

aurman -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:

aurman -S pure-meta-complete

The end result is pretty much the same as with package groups, but meta-packages also work with AUR helpers and GUI frontends lacking support for package groups. Moreover, they can be updated if the collection of packages in a group changes, so that a subsequent upgrade will automatically install any new packages in each package group.

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-git and pure-docs-git packages which will install the latest snapshots of the interpreter and the online documentation from Pure's Git repository:

aurman -S pure-git pure-docs-git

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.

The Rolling Pure Release

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.

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-git]
SigLevel = Never
Server = https://pureaur.bitbucket.io/git/$arch

[pure-aur]
SigLevel = Never
Server = https://pureaur.bitbucket.io/$arch

The Pure packages in the pure-aur-git 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 -git suffix. So they can be installed as follows:

sudo pacman -S pure-complete-git

Or, if you prefer the meta-package:

sudo pacman -S pure-meta-complete-git

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.

Arch users: Again, the binary packages in the pure-aur-git repository will likely work on plain Arch systems as well. But of course you can also build the rolling release yourself from source. However, the process is a bit more involved because there are some bootstrapping issues (some parts of the Pure system are needed to build it). Therefore the PKGBUILD isn't readily available in the AUR right now, you'll have to download it from Bitbucket instead. We also recommend getting the accompanying Makefile which simplifies the process. You can download these as follows:

wget https://bitbucket.org/purelang/pkgbuild/raw/HEAD/pure-complete-git/{PKGBUILD,Makefile}

Then please follow the instructions in the Makefile which explains the compilation process in detail.

Package Maintenance

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 basic AUR wiki pages to read are the AUR User Guidelines and the Arch Packaging Standards.

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

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 or any other AUR helper, 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 namcap that inspects PKGBUILD files for various common issues. This is highly recommended.

• You can use yaourt to 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 PKGBUILD prototype from the Arch Packaging Standards.

• Instructions on how to submit a package to the AUR can be found in the Arch wiki.