Downloads: Installation Instructions

Étoilé INSTALL

Required software

  • GCC 4.1 or higher is required to build Etoile
  • Clang is required to build LanguageKit. Clang 2.7 should work on FreeBSD but Linux requires Clang trunk. LanguageKit also requires LLVM trunk, so it is recommended that you install clang from svn as well.

You need to have the GNUstep core libraries installed in order to compile and use Etoile. The core packages are, at a minimum:

  • gnustep-make svn trunk (r29644 or more recent)
  • gnustep-base svn trunk (r28778 or more recent is required by EtoileSerialize)
  • gnustep-gui svn trunk
  • gnustep-back svn trunk
  • libobjc2 svn svn trunk (required by LanguageKit)

You can check out the latest GNUstep unstable (or trunk) as follows:

svn co http://svn.gna.org/svn/gnustep/modules/core

Note: EtoileUI works best with the most recent GNUstep svn revision, many EtoileUI-related bug fixes or improvements are regularly being committed to the GNUstep repository.

You need some extra libraries if you intend to build a complete Etoile environment or the whole repository:

For now, before building Etoile you should configure, compile and install LLVM by checking out the Subversion development trunk available at: http://llvm.org/svn/llvm-project/llvm/trunk.

WARNING: Please note that only the version of LanguageKit in stable will build with a release version of LLVM. The version in trunk requires a recent svn snapshot. Because the LLVM APIs are constantly evolving, LanguageKit may be broken with the latest svn at any given time. Please report any build failures to etoile-dev.

Notation

In the following text, square brackets "[ ]" are used to indicate an optional parameter.

Build LLVM and Clang

  • First check out the projects
svn co http://llvm.org/svn/llvm-project/llvm/trunk llvm
cd llvm/tools
svn co http://llvm.org/svn/llvm-project/cfe/trunk clang
  • Build both projects but don't install them

It's a good idea to build LLVM in parallel, so use '-j' if you can

cd .. # Back to llvm directory
./configure [--enable-optimized] && make [-j4]

Both LLVM and Clang have been built in debug mode.

Without --enable-optimized, Clang is quite slow, so it can be a good idea to pass this option. The downside is that it makes harder to debug LLVM/Clang issues, which might lead you to recompile LLVM/Clang without --enable-optimized later on. For more detailed instructions, see http://clang.llvm.org/get_started.html

  • Finally expose LLVM and Clang:
export PATH=$PATH:$PWD/Debug/bin: # llvm/Debug/bin contains the clang binary
export CC=clang # Make Clang the C/ObjC compiler rather than GCC

A good choice is put the two lines above in ~/.bashrc or similar and open a new shell. This way you won't have to export these variable every time you want to compile GNUstep or Etoile stuff.

  • Check Clang is ready:
clang -v

Build and Install GNUstep

To build GNUstep with GCC, follow the instructions here.

You can compile gnustep-back with the Cairo backend by configuring it as follows: ./configure --enable-graphics=cairo

To build GNUstep with Clang:

  • Check out GNUstep core modules and libobjc2:
svn co http://svn.gna.org/svn/gnustep/modules/core
svn co http://svn.gna.org/svn/gnustep/libs/libobjc2/trunk libobjc2
  • Install GNUstep Make a first time:
cd core/make
./configure --enable-debug-by-default [--prefix=/]
make && sudo -E make install
. /usr/GNUstep/System/Library/Makefiles/GNUstep.sh 
# Or . /System/Library/Makefiles/GNUstep.sh if --prefix=/ was passed

A good choice is to put this last line above in ~/.bashrc or similar. This way you won't have to source GNUstep.sh every time you want to compile GNUstep or Etoile stuff.

Note: If you use a C shell, you should source GNUstep.csh rather than GNUstep.sh.

  • Build libobjc2

strip=yes ensures you can debug ObjC code without stepping inside runtime functions each time a message is sent.

cd ../../libobjc2
make debug=no && sudo -E make strip=yes install

Warning: The new runtime is the GNU runtime version 2 but its library version is libobjc.so.4. libobjc.so.2 corresponds to the GNU runtime version 1 which comes with GCC and is also available at http://svn.gna.org/svn/gnustep/dev-libs/libobjc.

  • Install GNUstep Make a second time so it can detect the new ObjC runtime just installed:
cd ../../core/make
./configure --enable-debug-by-default [--prefix=/]
make && sudo -E make install
  • Build and Install GNUstep Base, Gui and Back:
cd core/base
# For Linux e.g. Ubuntu, --with-ffi-include is usually required
./configure [--with-ffi-include=/usr/include/`gcc -dumpmachine`]
make && sudo -E make install

cd core/gui
./configure && make && sudo -E make install

cd core/back
./configure && make && sudo -E make install

You can check you are really using Clang and not GCC with 'make messages=yes' instead of 'make' when building a GNUstep module. You can switch back to GCC for a given project with 'make CC=gcc' (or alternatively './configure CC=gcc').

To get an overview of the build options per module, you can use './configure --help' in each module directory.

See also GNUstep for further information.

Build and Install Etoile

WARNING: If you don't run setup.sh script, Etoile environment won't be fully installed and will simply fail to start. setup.sh is currently unsupported on platforms other than Linux. So the set up process has been to be done manually on systems such as FreeBSD.

Note: If you encounter path related error, you can source GNUstep.sh or GNUstep.csh in your shell, read the GNUstep documentation to know more about this topic.

Steps to build:

make
[sudo] [-E] make install
./setup.sh
Frameworks/CoreObject/setup-coreobject.sh

setup.sh script takes care of various operations mandatory to have a ready to use environment that includes:

  • the environment startup tool (named 'etoile_system')
  • Nesedah theme
  • Horizontal menu bar
  • X11 session support (to start Etoile with KDM, GDM etc.)

This involves to copy or link various elements and set several preferences (called 'defaults' in GNUstep terminology). The script will ask you whether you want to set up the environment for the current user only or for the whole machine.

Read CoreObject INSTALL documentation to learn about setup-coreobject.sh.

Uninstall Etoile

Steps to uninstall:

[sudo] [-E] make uninstall
./setdown.sh
Frameworks/CoreObject/uninstall-coreobject.sh

setdown.sh script allows to get rid of what has been installed or configured by setup.sh. In other words, it reverts the effect of setup.sh script.

Take note, you can use it alone without running 'make uninstall' first. This is useful when you want to disable temporarily Etoile theme, horizontal menu etc. and get back to the GNUstep look & feel. Then you can return to the usual Etoile look & feel by running setup.sh again.

However it's important to note that setdown.sh doesn't disable only Camaelon (theme engine) and WildMenus (horizontal menu engine). You won't be able to log in from KDM or GDM once setdown.sh has been run, and Etoile specific applications may fail because of missing elements or daemons not launched.

Read CoreObject INSTALL documentation to learn about uninstall-coreobject.sh.

Custom Build and Install

In order to build and install the whole project (with the exception of developers tools like UnitKit), you can just type in the root directory (named Etoile):

make
[sudo] [-E] make install

You can choose to build only custom set of modules. Add a 'modules.make' file in the root directory named 'Etoile' that contains Frameworks, Services and so on. In this file, to turn on the module CoreObject and off the module UnitKit, write:

export coreobject = yes export unitkit = no

Be careful to have no trailing spaces after 'yes' or 'no'. Take also note by declaring these variables, you only determine whether these specific modules are built or not, but the build system won't automatically resolve and turn on and off dependencies in relation to those modules. So you must keep track by yourself of the dependencies to be enabled or disabled. These dependencies are usually documented in Frameworks/GNUmakefile and similar directories. They can also always be found by looking at the linker flags for each module GNUmakefile.

You can use the 'make' command with all the available options from every projects directory.

You can also build test bundles for any specified modules by adding an option 'test=yes', in future you should be able to run every test bundles with 'make check' but this is not implemented currently.

Generate Documentation

To build both the code and the documentation at the same time in any directory, type:

make documentation=yes

In addition, you can also generate the documentation without building the code per module. Move to a module directory (e.g. cd Languages/LanguageKit) and do:

make doc

Every time you generate some documentation, a Documentation directory appears per module (e.g. Languages/LanguageKit/Documentation) and it gets consolidated in Developer/Documentation. You can browse the Developer/Documentation/index.html as a starting point. If you are in a module directory, you can browse its documentation with Documentation/index.html (e.g. Languages/LanguageKit/Documentation/index.html)

To clean the generated documentation in the current module directory (will also clean the content copied in Developer/Documentation):

make clean-doc

Finally to remove all the generated documentation, you can use in any directory:

make distclean

which also discards the code previously built.

Trouble

Give us feedback! Tell us what you like; tell us what you think could be better. Send bug reports and patches to etoile-track@gna.org.