diff --git a/SConstruct b/SConstruct
index 80cb2ba..2377727 100644
--- a/SConstruct
+++ b/SConstruct
@@ -1,195 +1,198 @@
 from __future__ import print_function
 import os
 from os.path import join, abspath
 from version import write_info_file
 
 
 def gen_print(action_string, color_string, env):
     """Generic function for creating pretty compile output"""
     if env['verbose']:
         return None
 
     def print_fun(command, target, source, env):
         colors = env['COLOR_DICT']
         print("{}[{}] {}{}{}".format(colors[color_string],
                                      action_string,
                                      colors['blue'],
                                      target[0],
                                      colors['end']))
     return print_fun
 
 
 # Compilation colors
 colors = {
   'cyan': '\033[96m',
   'purple': '\033[95m',
   'blue': '\033[94m',
   'green': '\033[92m',
   'yellow': '\033[93m',
   'red': '\033[91m',
   'end': '\033[0m'
 }
 
 # Inherit all environment variables (for CXX detection, etc.)
 main_env = Environment(ENV=os.environ)
 main_env['COLOR_DICT'] = colors
 
 # Compiler detection
 compiler_default = 'g++'
 if 'CXX' in os.environ:
     compiler_default = os.environ['CXX']
 
 # Build variables
 vars = Variables('build-setup.conf')
 vars.Add(EnumVariable('build_type', 'Build type', 'release',
                       allowed_values=('release', 'profiling', 'debug'),
                       ignorecase=2))
 vars.Add('prefix', 'Prefix where to install', '/usr/local')
 vars.Add('CXX', 'Compiler', compiler_default)
 vars.Add('py_exec', 'Python executable', 'python')
 vars.Add(BoolVariable('timer', 'Activate the timer possibilities', False))
 vars.Add(BoolVariable('verbose', 'Activate verbosity', False))
 vars.Add(BoolVariable('build_doc', 'Build documentation', False))
 vars.Add(BoolVariable('color', 'Color the non-verbose compilation output', False))
 vars.Update(main_env)
 
 Help(vars.GenerateHelpText(main_env))
 
 # Save all options, not just those that differ from default
 with open('build-setup.conf', 'w') as setup:
     for key in vars.keys():
         setup.write("{} = '{}'\n".format(key, main_env[key]))
 
 build_type = main_env['build_type']
 build_dir = 'build-' + main_env['build_type']
 print("Building in " + build_dir)
 
 verbose = main_env['verbose']
 
 # Remove colors if not set
 if not main_env['color']:
     for key in colors:
         colors[key] = ''
 
 if not verbose:
     main_env['SHCXXCOMSTR'] = u'{0}[Compiling] {1}$SOURCE{2}'.format(colors['green'],
                                                                      colors['blue'],
                                                                      colors['end'])
     main_env['SHLINKCOMSTR'] = u'{0}[Linking] {1}$TARGET{2}'.format(colors['purple'],
                                                                     colors['blue'],
                                                                     colors['end'])
     main_env['SWIGCOMSTR'] = u'{0}[Swig] {1}$SOURCE{2}'.format(colors['yellow'],
                                                                colors['blue'],
                                                                colors['end'])
 
 # Include paths
 main_env.AppendUnique(CPPPATH=['#/src',
                                '#/src/core',
-			       '#/src/bem',
+                               '#/src/bem',
                                '#/src/surface',
                                '#/src/python',
-			       '#/src/percolation',
-			       '#/src/model',
-			       '#/src/solvers',
+                               '#/src/percolation',
+                               '#/src/model',
+                               '#/src/solvers',
                                '#/python'])
 
+# Changing the shared object extension
+main_env['SHOBJSUFFIX'] = '.o'
+
 # Treating Intel compiler for OpenMP
 if main_env['CXX'] != 'icpc':
     omp_libs = ['gomp']
     omp_flag = '-fopenmp'
 else:
     omp_libs = ['']
     omp_flag = '-qopenmp'
 
 main_env.AppendUnique(LIBS=omp_libs)
 main_env.AppendUnique(LINKFLAGS=[omp_flag])
 
 # Flags and options
 main_env.AppendUnique(CXXFLAGS=['-std=c++14',
                                 '-Wall',
                                 omp_flag])
 
 # Adding compile flags defined in evironment
 if 'CXXFLAGS' in os.environ:
     main_env.AppendUnique(CXXFLAGS=Split(os.environ['CXXFLAGS']))
 
 if main_env['timer']:
     main_env.AppendUnique(CPPDEFINES=['USING_TIMER'])
 if build_type == 'debug':
     main_env.AppendUnique(CPPDEFINES=['TAMAAS_DEBUG'])
 
 cxxflags_dict = {
     "debug": Split("-g -O0"),
     "profiling": Split("-g -pg -O2"),
     "release": Split("-O3")
 }
 
 shlinkflags_dict = {
     "debug": [],
     "profiling": ['-pg'],
     "release": []
 }
 
 main_env.AppendUnique(CXXFLAGS=cxxflags_dict[build_type])
 main_env.AppendUnique(SHLINKFLAGS=shlinkflags_dict[build_type])
 
 main_env['LIBPATH'] = [abspath(join(build_dir, 'src'))]
 main_env['RPATH'] = "$LIBPATH"
 
 
 fftw_include = ""
 fftw_library = ""
 
 # If FFTW is provided by module system (on clusters)
 if 'FFTW_ROOT' in main_env['ENV']:
     fftw_include = join(main_env['ENV']['FFTW_ROOT'], 'include')
     fftw_library = join(main_env['ENV']['FFTW_ROOT'], 'lib')
 
 main_env = main_env.Clone(
     tools=[fftw],
     FFTW_LIBRARY_WISH=['main', 'omp'],
     FFTW_INCLUDE_DIR=fftw_include,
     FFTW_LIBRARY_DIR=fftw_library,
 )
 
 # Find boost on clusters
 if 'BOOST_ROOT' in main_env['ENV']:
     main_env.AppendUnique(CPPPATH=[join(main_env['ENV']['BOOST_ROOT'], 'include')])
 
 # Writing information file
 write_info_file("src/tamaas_info.cpp")
 
 # Saving the env file
 env_content = """export PYTHONPATH=$PYTHONPATH:{0}/python
 export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:{0}/src
 """
 
 
 def write_env_file(target, source, env):
     """Builder to write content to file"""
     with open(str(target[0]), 'w') as env_file:
         env_file.write(env_content.format(abspath(build_dir)))
 
 
 main_env['gen_print'] = gen_print
 env_file_env = main_env.Clone(PRINT_CMD_LINE_FUNC=gen_print("Writing", "cyan", main_env))
 # Need to have a command and manage tamaas_environement.sh as target because
 # the build directory does not always exist
 env_file_env.Command(join(build_dir, 'tamaas_environement.sh'), None, write_env_file)
 
 
 Export('main_env')
 
 
 # Building subdirs
 def subdir(dir): SConscript(join(dir, 'SConscript'),
                             variant_dir=join(build_dir, dir),
-                            duplicate=False)
+                            duplicate=True)
 
 
 for dir in ['src', 'python', 'tests']:
     subdir(dir)
 
 # Building documentation
 if main_env['build_doc']:
     subdir('doc')