Chakra Community Repository

From Chakra | Wiki
Jump to: navigation, search
Chakra Community Repository (CCR)
Community-driven (unsupported) repository for Chakra users. It contains package descriptions (PKGBUILDs, in source tarballs, often called source packages as opposed to binary packages or simply packages) that allow you to compile a package from source with makepkg and then install it via pacman. The Chakra Community Repository was created to organize and share source packages from the community for software not in the official repositories and to help expedite inclusion of popular software into the official repositories.

Users can search and download source packages from the CCR. These source packages contain different files (a PKGBUILD at least) that, once extracted from the tarball, automate the process of creating installable packages from source code, using Makepkg. Those packages can later be installed using pacman (command-line).

In the Chakra Community Repository website you can get information about new and updated source packages.


The Chakra Community Repository is a modified version of the Arch Linux's AUR frontend made by the Arch developers. It was adapted to fit Chakra needs.


Currently package search in CCR works as it does in the original Arch Linux's AUR: searches package names and descriptions via a MySQL LIKE comparison. This reads white spaces as so, so if you look for "video editor", you won't find all descriptions and package names with those two words, but instead you will get descriptions containing those exact words, "video editor". You can avoid this behavior replacing white spaces with '%', but you should have in mind that words will be searched also in that order. So, looking for "video%editor" or "editor%video" will give you different results.

There's also an interface suitable for accessing the CCR from scripts or similar. You can find it in


Installing packages from the CCR is a relatively simple process. Essentially:

  1. Acquire a source package (a tarball).
  2. Extract the content and move into the extracted folder (containing a PKGBUILD file and maybe others).
  3. Run makepkg in that folder (makepkg -s will auto-resolve dependencies).
  4. Install the resulting package.

You can also use chaser to retrieve packages from the Chakra Community Repository and auto-resolve their dependencies. It mostly works like pacman.

The steps to install a package from the Chakra Community Repository are explained below in detail:


First ensure that the necessary tools are installed. You must first make sure you have the base-devel group of packages installed, since CCR source packages assume it to be installed and because of that it will not be listed in any PKGBUILD. Also, packages in that group should be sufficient to compile most PKGBUILD files; it includes make and other tools needed to compile from source.

sudo pacman -S base-devel

Acquiring Source Files

Locate the source package in the CCR. This is done using the search feature (text field at the top of the CCR website). Clicking on the source package's name in the search list brings up an information page on the source package. Read through the description to confirm that this is the desired one, note when the source package was last updated, and read any comments.

Download the source package by clicking the "Tarball" link on the left-hand side near the end of the package details. Download it somewhere in your system, and go there. Left-click on the archive and press "Extract Archive Here". A new folder should appear, and you can now delete the archive.


Now get into the folder you've just extracted (which should be named after the source package), either through the terminal or through the file manager. If you used the file manager, open now Yakuake (F12 by default) or any other terminal.

Warning: Carefully check all files. Carefully check the PKGBUILD and any .install file for malicious commands. If in doubt, do not build the package and seek advice on the forum or mailing list.

Now make the package. After manually confirming the integrity of the files, run makepkg as a normal user in the build directory.

$ makepkg -s

The -s switch will use sudo to install any needed dependencies. If the use of sudo is undesirable, manually install required dependencies beforehand and exclude the -s in the above command.

Now you should see the compilation process begin, and once it is all done, a .pkg.tar.xz file should appear in the build directory. If it didn't because there was a problem during the compilation process, you should check the comments in the source package information page in the CCR, and maybe post your problem there.

Installing Packages

If the build was successful, install the package using pacman:

$ sudo pacman -U <package>


To remove a package that was installed from the CCR, you simply run:

sudo pacman -R <package>

If you want a list of the packages you installed from the CCR (actually the packages which are not in the official repositories), you can run this script:

#! /bin/bash
installed=`pacman -Q | sed -e "s|\(.*[^ ]*\) .*|\1|g" `
repos=`pacman -Sl | sed -e "s|[^ ]* \(.*[^ ]*\) .*|\1|g"`

for pkg in $installed
    found=`echo $repos | grep $pkg`
    if [ "$found" == "" ]; then
        echo $pkg
# end

Save it in a file, give it execution permission (chmod +x and run it:


It will print the packages you have installed which are not in the official repositories. You can also send the list to a text file:

./ > ccrlist.txt

Then, you can edit the list (to remove from it the software you still want in your system), and once the list has only software packages you want to remove, you can run this command to remove those:

sudo pacman -R $(cat ccrlist.txt)

Contributing Source Packages

The user plays an essential role in the CCR, which cannot fulfill its potential without the support, involvement, and contribution of the wider user community. The life-cycle of a CCR package starts and ends with the user and requires the user to contribute in several ways.

Users can share source packages using the CCR. The repository does not contain any binary packages but allows users to upload source packages with a PKGBUILD file and other text files that can be downloaded by other users. These source packages are completely unofficial and have not been vetted, so they should be used at your own risk.


After logging in to the CCR website, a user can submit a source package - that is, a .tar.gz archive of a directory containing description files for building a package. The directory inside the tarball should contain a PKGBUILD, and any .install files, patches, etc. (ABSOLUTELY no binaries).

From the folder containing the description files, the archive can be created with the following command:

$ makepkg --source


When submitting a source package, observe the following rules:

  • Check the official repositories for the package first. If it is inside any of those repositories in any form, do not submit the source package (if the current package is broken or is lacking any included feature then file a bug report).
  • Check the CCR for the source package. If it is currently maintained, changes can be submitted in a comment for the maintainer's attention. If it is unmaintained, the package can be adopted and updated as required.
  • Verify carefully that what you are uploading is correct. All contributors must read and adhere to the Chakra Packaging Standards when writing source packages. This is essential to the smooth running and general success of the CCR. Remember you are not going to earn any credit or respect from your peers by wasting their time with a bad source package.
  • Source packages that contain binaries or that are very poorly written may be deleted without warning.
  • If you are unsure about the package (or the build/submission process) in any way, ask in, and provide the source for public review, before adding it to the CCR.
  • Gain some experience before submitting source packages. Build a few packages to learn the process and then submit.
  • If you submit a package.tar.gz with a file named 'package' in it you'll get a an error: 'Could not change to directory /home/aur/unsupported/package/package'. To resolve this, rename the file named 'package' to something else, for example, 'package.rc'. When it is installed in the pkg directory you may rename it back to 'package'.


A comments facility allows users to provide suggestions and feedback on improvements to the source package maintainer. Avoid pasting patches, PKGBUILD or similar files into the comments section. They quickly become obsolete and just end up needlessly taking up lots of space. Instead, e-mail those files to the maintainer.

One of the easiest activities for all Chakra users is to browse the CCR and vote for their favorite source packages using the online interface. The vote count is one of the considerations the Chakra packagers take into account when choosing a package to get into the official repositories. It is in everyone's interest to vote.

Maintaining Source Packages

  • If you maintain a source package and want to update any of its files, simply resubmit it.
  • You might want to be aware of new upstream releases to upgrade the source package. Look for a feed you can follow: SourceForge downloads, development blog entries, etc. If there's none, you can always get a feed of the page where new releases are published generated with or any similar service.
  • Check for feedback and comments from other users and try to incorporate any improvements they suggest; consider it a learning process!
  • Please do not just submit and forget about source packages! While in the CCR, it is the user's job to maintain the source package by checking for updates and improving it.
  • If you do not want to continue to maintain the source package for some reason, "disown" it through the CCR website and/or send an e-mail to
  • A source package flagged as outdated and maintained by a user that has not responded to a comment from another user, requesting it to be orphaned that the second user may adopt and update it, for two weeks or more may be orphaned by a Trusted User in order to facilitate the process.

From CCR to the official repositories

Source packages uploaded to the CCR by the community may eventually be chosen by the Chakra packagers to be built and added to the official repositories. The community has the ability to vote for source packages in the CCR. If a source package becomes popular enough and meets the official repositories' requirements, it may be added to the official repositories.

Requirements to enter the Chakra repositories

To enter the official repositories, a package must meet these requirements:

  • Have a compatible license.
  • Packages with a good technique.
  • Don't depend, either directly or indirectly, on GTK libraries.


<references />

See Also

Repository.pngUnofficial User Repositories
Binary repositories not created by the Chakra Team.