1. PureLang
  2. Untitled project
  3. pure-lang

Wiki

Clone wiki

pure-lang / ArchPackaging

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 /etc/pacman.conf file:

[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

Of course, you can also use Manjaro's pamac, octopi or one of the other available GUI frontends to pacman and/or yaourt 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.)

Dependencies

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.

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

  • 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 makepkg -S.

  • Uploading packages into AUR is a pain to do using the web interface, so many people use the burp tool (this can be installed using pacman).

Updated