How do I build Unity from source?

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?

Answers 6

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



  • 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!


Related Questions