How do I build Unity from source?

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:

• http://unity.ubuntu.com/getinvolved/development/unity/

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

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.

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.

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!

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.