Take the 2-minute tour ×
Ask Ubuntu is a question and answer site for Ubuntu users and developers. It's 100% free, no registration required.

I'd like to know how I would build Unity from source code in the current development release. Please cover the following topics:

  • Which packages are needed to compile Unity?
  • Where would I get the current source code?
  • What are the steps to actually configure and compile Unity?
  • Is it possible to safely run the latest version alongside the version from the repositories?
share|improve this question
add comment

6 Answers

up vote 61 down vote accepted
+300

Building Unity from Source

In this guide you will build a separated version of Unity trunk (locally installed to your home directory), so you don't need to worry about corrupting the version from the Ubuntu repositories and you also won't need to get root permissions throughout the whole process (except for installing the build dependencies).

0. Installing build dependencies

You'll need to run this once to install all necessary build dependencies:

sudo apt-get install bzr cmake compiz-dev gnome-common libbamf3-dev libboost-dev \
libboost-serialization-dev libgconf2-dev libgdu-dev libglewmx1.6-dev \
libgnome-desktop-3-dev libibus-1.0-dev libindicator3-dev libjson-glib-dev \
libnotify-dev libnux-2.0-dev libpci-dev libsigc++-2.0-dev libunity-dev \
libunity-misc-dev libutouch-geis-dev libxxf86vm-dev libzeitgeist-dev xsltproc

If you have source code repositories (aka deb-src) enabled, you can instead use:

sudo apt-get build-dep unity

1. Preparing the environment

Replace SOURCE and PREFIX with the directories you'd like the source and build files to go. In this example I put both in my home directory:

export SOURCE=$HOME/source/unity
export PREFIX=$HOME/build/unity

export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig:$PKG_CONFIG_PATH"
export LD_LIBRARY_PATH="$PREFIX/lib:$LD_LIBRARY_PATH"
export LD_RUN_PATH="$PREFIX/lib:$LD_RUN_PATH"
export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"

mkdir -p "$PREFIX"
mkdir -p "$SOURCE"
cd "$SOURCE"

2. Building Nux

You will probably need to grab the latest version of Nux to get Unity trunk to compile:

bzr branch lp:nux
cd nux
./autogen.sh --disable-examples --disable-gputests --disable-tests --prefix="$PREFIX"
make -j4
make install
cd ..

Tip: Most modern desktops and laptops have several cores. You can greatly speed up the compilation by taking advantage of this. The make command has build-in support for this which you can activate using the -jN switch where N is the number of jobs to run in parallel. A good rule of thumb is to run 2 times the number of cores on your processor. Thus, on a normal dual core computer you should run make -j4 to minimize the compilation time.

3. Building Unity

Now grab the latest Unity code and build it:

bzr branch lp:unity
cd unity
mkdir build
cd build
cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON -DCMAKE_INSTALL_PREFIX="$PREFIX"
make -j4
make install

That's it, log out and back in again and you should be running the latest Unity. Alternatively, you can run

setsid $PREFIX/bin/unity

4. Updating

Make sure to prepare the environment like described in step 1, then simply enter both top-level directories nux and unity, run bzr pull, rebuild, and reinstall.

I suggest removing and recreating the build directory in the unity directory, to make sure no old files are messing with your build.

5. Removing Unity

Remove the three directories $SOURCE, $PREFIX and ~/.compiz-1.


Useful Link:

share|improve this answer
    
I think there's very important thing, to clone the version we currently use, for example on Ubuntu 12.04, I've tried to clone Nux latest version, and it went messy, because Nux used sharedptr but It seems that the gcc on 12.04 doesn't support, or need some flag to be added to the make files. So, Cloning the exact version suitable with my system, is very important. –  Muhammad Hewedy Sep 28 '13 at 8:24
add comment

I've made a script based on the Wayland build script and these instructions to automate installing prerequisites, cloning, updating, configuring and building Unity.

https://github.com/bitshifter/Unity-Build/raw/master/build-unity.sh

share|improve this answer
add comment

Building in your home directory

Sometimes for testing reasons it's useful to build Unity and nux in your home directory so you can try to see if something is fixed in trunk without mucking around with packages and/or PPAs. I asked Jason Smith (Unity Dev) how he builds Unity and he explained his method to me:

  1. Ensure you have all the build dependencies from this answer.

  2. First make a directory in your home called "staging", this is where we'll build Unity. Create a little script that will prepare the build environment, replace the home directory with your own:

    #!/bin/bash
    
    PREFIX=/home/jorge/staging
    
    export XDG_DATA_DIRS="$PREFIX/share:$XDG_DATA_DIRS"
    export LD_LIBRARY_PATH="$PREFIX/lib/"
    export PKG_CONFIG_PATH="$PREFIX/lib/pkgconfig/"
    

    I call this unity.sh and I run it every time I want to build Unity. So basically chmod +x unity.sh and then ./unity.sh when you want to build.

  3. Build nux:

    bzr branch lp:nux
    cd nux
    ./autogen.sh --prefix=/home/jorge/staging
    make -j4
    make install
    cd ..
    
  4. Build Unity:

    bzr branch lp:unity
    cd unity
    mkdir build
    cd build
    cmake .. -DCMAKE_INSTALL_PREFIX=/home/jorge/staging/ -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DGSETTINGS_LOCALINSTALL=ON
    make -j4
    make install
    

NOTE: This builds nux and unity in your home directory, there's no need for sudo here or anything like that.

  • Logging out and back in will run this version of Unity/nux automatically since it was built in ~/.compiz
  • To revert to the normal packages just log out, delete ~/.compiz and log back in.
share|improve this answer
add comment

The source code for the default environment (Unity) can be found in the package unity. Install the source with apt-get source unity, the dependencies to build it with sudo apt-get build-dep unity and hack away.

This will let you position the launcher on the right, bottom, top, etc.

share|improve this answer
add comment

There is excellent official documentation here - Developing Unity.

Here's an excerpt from it on building Unity - installing from source and compiling

Building Unity

These instructions will help you build unity from source. However, there are a few things to consider:

  • It is recommend that you never copy anything you’ve built locally outside your home directory. Doing so is asking for trouble, especially as we’re building the entire desktop shell. If you manage to ruin your system-wide desktop shell you’ll be a very sad programmer!
  • It is assumed that you’re running the precise Ubuntu release.
  • It is also assumed that you want to build unity from trunk (that is, lp:unity).

Getting the source code:

If you don’t already have Bazaar installed, install it now:

sudo apt-get install bzr

You will want to make yourself a folder for the unity code. Do something like this:

mkdir -p ~/code/unity
cd ~/code/unity

Let’s grab the code from launchpad:

bzr branch lp:unity trunk

This may take a while.
Installing Build Dependancies:

We need to get the build-dependancies for unity. Thankfully, apt-get makes this trivial:

sudo apt-get build-dep unity

Compiling Unity:

Use this set of bash functions to make this step significantly easier. To use them, copy the following bash code into a file in your home directory called .bash_functions:

function recreate-build-dir()
{
   rm -r build
   mkdir build
   cd build
}

function remake-autogen-project()
{
    ./autogen.sh --prefix=$HOME/staging --enable-debug
    make clean && make && make install
}

function remake-unity()
{
    recreate-build-dir
    cmake .. -DCMAKE_BUILD_TYPE=Debug -DCOMPIZ_PLUGIN_INSTALL_TYPE=local -DCMAKE_INSTALL_PREFIX=$HOME/staging/ -DGSETTINGS_LOCALINSTALL=ON
    make  && make install
}

function unity-env
{
 export PATH=~/staging/bin:$PATH
 export XDG_DATA_DIRS=~/.config/compiz-1/gsettings/schemas:~/staging/share:/usr/share:/usr/local/share
 export LD_LIBRARY_PATH=~/staging/lib:${LD_LIBRARY_PATH}
 export LD_RUN_PATH=~/staging/lib:${LD_RUN_PATH}
 export PKG_CONFIG_PATH=~/staging/lib/pkgconfig:${PKG_CONFIG_PATH}
 export PYTHONPATH=~/staging/lib/python2.7/site-packages:$PYTHONPATH
}

Now run this in a terminal:

echo ". ~/.bash_functions" >> ~/.bashrc

This ensures that the next time you open a bash shell the functions listed above will be available to you. To avoid having to close and re-open a terminal, we can read them manually just this once:

. ~/.bash_functions

You should now be able to run:

remake-unity

from the trunk/ directory we created earlier. That’s it – you’re building unity!

share|improve this answer
add comment

The installation got trickier recently : a new module has been added to compiz named GTK Load (or it will crash in XInternAtom). We need to activate this module to use 4.0.1, but activating it will crash unity 3.8.

It's getting hard to keep both of them. The way I did it was to :

  • go in the compiz-1 folder and rename all .so by .so1, except for libgtkloader.so
  • restart compiz with unity 4.0.1
  • activate the gtk Load module in compizconfig-settings-manager
  • rename the libraries back to .so
  • restart compiz.
share|improve this answer
add comment

protected by Community Sep 27 '12 at 16:37

Thank you for your interest in this question. Because it has attracted low-quality answers, posting an answer now requires 10 reputation on this site.

Would you like to answer one of these unanswered questions instead?

Not the answer you're looking for? Browse other questions tagged or ask your own question.