diff --git a/lib/exabgp/__main__.py b/lib/exabgp/__main__.py
index 3efa66d78..f42bb17a3 100644
--- a/lib/exabgp/__main__.py
+++ b/lib/exabgp/__main__.py
@@ -1,3 +1,4 @@
 if __name__ == '__main__':
     from exabgp.application.main import main
+
     main()
diff --git a/lib/exabgp/application/bgp.py b/lib/exabgp/application/bgp.py
deleted file mode 100755
index 0780b47d9..000000000
--- a/lib/exabgp/application/bgp.py
+++ /dev/null
@@ -1,446 +0,0 @@
-# encoding: utf-8
-"""
-bgp.py
-
-Created by Thomas Mangin on 2009-08-30.
-Copyright (c) 2009-2017 Exa Networks. All rights reserved.
-License: 3-clause BSD. (See the COPYRIGHT file)
-"""
-
-import os
-import sys
-import stat
-import platform
-import syslog
-import string
-
-from exabgp.util.dns import warn
-from exabgp.logger import Logger
-
-from exabgp.version import version
-
-# import before the fork to improve copy on write memory savings
-from exabgp.reactor.loop import Reactor
-
-from exabgp.vendoring import docopt
-
-from exabgp.configuration.usage import usage
-
-from exabgp.debug import setup_report
-
-setup_report()
-
-
-def is_bgp(s):
-    return all(c in string.hexdigits or c == ':' for c in s)
-
-
-def __exit(memory, code):
-    if memory:
-        from exabgp.vendoring import objgraph
-
-        sys.stdout.write('memory utilisation\n\n')
-        sys.stdout.write(objgraph.show_most_common_types(limit=20))
-        sys.stdout.write('\n\n\n')
-        sys.stdout.write('generating memory utilisation graph\n\n')
-        sys.stdout.write()
-        obj = objgraph.by_type('Reactor')
-        objgraph.show_backrefs([obj], max_depth=10)
-    sys.exit(code)
-
-
-def named_pipe(root, pipename='exabgp'):
-    locations = [
-        '/run/exabgp/',
-        '/run/%d/' % os.getuid(),
-        '/run/',
-        '/var/run/exabgp/',
-        '/var/run/%d/' % os.getuid(),
-        '/var/run/',
-        root + '/run/exabgp/',
-        root + '/run/%d/' % os.getuid(),
-        root + '/run/',
-        root + '/var/run/exabgp/',
-        root + '/var/run/%d/' % os.getuid(),
-        root + '/var/run/',
-    ]
-    for location in locations:
-        cli_in = location + pipename + '.in'
-        cli_out = location + pipename + '.out'
-
-        try:
-            if not stat.S_ISFIFO(os.stat(cli_in).st_mode):
-                continue
-            if not stat.S_ISFIFO(os.stat(cli_out).st_mode):
-                continue
-        except KeyboardInterrupt:
-            raise
-        except Exception:
-            continue
-        os.environ['exabgp_cli_pipe'] = location
-        return [location]
-    return locations
-
-
-def root_folder(options, locations):
-    if options['--root']:
-        return os.path.realpath(os.path.normpath(options['--root'])).rstrip('/')
-
-    argv = os.path.realpath(os.path.normpath(os.path.join(os.getcwd(), sys.argv[0])))
-
-    for location in locations:
-        if argv.endswith(location):
-            return argv[: -len(location)]
-    return ''
-
-
-def get_envfile(options, etc):
-    envfile = 'exabgp.env' if not options["--env"] else options["--env"]
-    if not envfile.startswith('/'):
-        envfile = '%s/%s' % (etc, envfile)
-    return envfile
-
-
-def get_env(envfile):
-    from exabgp.configuration.setup import environment
-
-    try:
-        return environment.setup(envfile)
-    except environment.Error as exc:
-        sys.stdout.write(usage)
-        sys.stdout.flush()
-        print('\nconfiguration issue,', str(exc))
-        sys.exit(1)
-
-
-def main():
-    major = int(sys.version[0])
-    minor = int(sys.version[2])
-
-    if major <= 2 and minor < 5:
-        sys.stdout.write('This program can not work (is not tested) with your python version (< 2.5)\n')
-        sys.stdout.flush()
-        sys.exit(1)
-
-    cli_named_pipe = os.environ.get('exabgp_cli_pipe', '')
-    if cli_named_pipe:
-        from exabgp.application.control import main as control
-
-        control(cli_named_pipe)
-        sys.exit(0)
-
-    options = docopt.docopt(usage, help=False)
-
-    if options["--run"]:
-        sys.argv = sys.argv[sys.argv.index('--run') + 1 :]
-        if sys.argv[0] == 'healthcheck':
-            from exabgp.application import run_healthcheck
-
-            run_healthcheck()
-        elif sys.argv[0] == 'cli':
-            from exabgp.application import run_cli
-
-            run_cli()
-        else:
-            sys.stdout.write(usage)
-            sys.stdout.flush()
-            sys.exit(0)
-        return
-
-    root = root_folder(
-        options, ['/bin/exabgp', '/sbin/exabgp', '/lib/exabgp/application/bgp.py', '/lib/exabgp/application/control.py']
-    )
-    prefix = '' if root == '/usr' else root
-    etc = prefix + '/etc/exabgp'
-
-    os.environ['EXABGP_ETC'] = etc  # This is not most pretty
-
-    if options["--version"]:
-        sys.stdout.write('ExaBGP : %s\n' % version)
-        sys.stdout.write('Python : %s\n' % sys.version.replace('\n', ' '))
-        sys.stdout.write('Uname  : %s\n' % ' '.join(platform.uname()[:5]))
-        sys.stdout.write('Root   : %s\n' % root)
-        sys.stdout.flush()
-        sys.exit(0)
-
-    envfile = get_envfile(options, etc)
-    env = get_env(envfile)
-
-    # Must be done before setting the logger as it modify its behaviour
-    if options["--debug"]:
-        env.log.all = True
-        env.log.level = syslog.LOG_DEBUG
-
-    logger = Logger()
-
-    from exabgp.configuration.setup import environment
-
-    if options["--decode"]:
-        decode = ''.join(options["--decode"]).replace(':', '').replace(' ', '')
-        if not is_bgp(decode):
-            sys.stdout.write(usage)
-            sys.stdout.write('Environment values are:\n%s\n\n' % '\n'.join(' - %s' % _ for _ in environment.default()))
-            sys.stdout.write('The BGP message must be an hexadecimal string.\n\n')
-            sys.stdout.write('All colons or spaces are ignored, for example:\n\n')
-            sys.stdout.write('  --decode 001E0200000007900F0003000101\n')
-            sys.stdout.write('  --decode 001E:02:0000:0007:900F:0003:0001:01\n')
-            sys.stdout.write('  --decode FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF001E0200000007900F0003000101\n')
-            sys.stdout.write('  --decode FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:001E:02:0000:0007:900F:0003:0001:01\n')
-            sys.stdout.write('  --decode \'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 001E02 00000007900F0003000101\n\'')
-            sys.stdout.flush()
-            sys.exit(1)
-    else:
-        decode = ''
-
-    duration = options["--signal"]
-    if duration and duration.isdigit():
-        pid = os.fork()
-        if pid:
-            import time
-            import signal
-
-            try:
-                time.sleep(int(duration))
-                os.kill(pid, signal.SIGUSR1)
-            except KeyboardInterrupt:
-                pass
-            try:
-                pid, code = os.wait()
-                sys.exit(code)
-            except KeyboardInterrupt:
-                try:
-                    pid, code = os.wait()
-                    sys.exit(code)
-                except Exception:
-                    sys.exit(0)
-
-    if options["--help"]:
-        sys.stdout.write(usage)
-        sys.stdout.write('Environment values are:\n' + '\n'.join(' - %s' % _ for _ in environment.default()))
-        sys.stdout.flush()
-        sys.exit(0)
-
-    if options["--decode"]:
-        env.log.parser = True
-        env.debug.route = decode
-        env.tcp.bind = ''
-
-    if options["--profile"]:
-        env.profile.enable = True
-        if options["--profile"].lower() in ['1', 'true']:
-            env.profile.file = True
-        elif options["--profile"].lower() in ['0', 'false']:
-            env.profile.file = False
-        else:
-            env.profile.file = options["--profile"]
-
-    if envfile and not os.path.isfile(envfile):
-        comment = 'environment file missing\ngenerate it using "exabgp --fi > %s"' % envfile
-    else:
-        comment = ''
-
-    if options["--full-ini"] or options["--fi"]:
-        for line in environment.iter_ini():
-            sys.stdout.write('%s\n' % line)
-            sys.stdout.flush()
-        sys.exit(0)
-
-    if options["--full-env"] or options["--fe"]:
-        print()
-        for line in environment.iter_env():
-            sys.stdout.write('%s\n' % line)
-            sys.stdout.flush()
-        sys.exit(0)
-
-    if options["--diff-ini"] or options["--di"]:
-        for line in environment.iter_ini(True):
-            sys.stdout.write('%s\n' % line)
-            sys.stdout.flush()
-        sys.exit(0)
-
-    if options["--diff-env"] or options["--de"]:
-        for line in environment.iter_env(True):
-            sys.stdout.write('%s\n' % line)
-            sys.stdout.flush()
-        sys.exit(0)
-
-    if options["--once"]:
-        env.tcp.once = True
-
-    if options["--pdb"]:
-        # The following may fail on old version of python (but is required for debug.py)
-        os.environ['PDB'] = 'true'
-        env.debug.pdb = True
-
-    if options["--test"]:
-        env.debug.selfcheck = True
-        env.log.parser = True
-
-    if options["--memory"]:
-        env.debug.memory = True
-
-    configurations = []
-    # check the file only once that we have parsed all the command line options and allowed them to run
-    if options["<configuration>"]:
-        for f in options["<configuration>"]:
-            # some users are using symlinks for atomic change of the configuration file
-            # using mv may however be better practice :p
-            normalised = os.path.realpath(os.path.normpath(f))
-            target = os.path.realpath(normalised)
-            if os.path.isfile(target):
-                configurations.append(normalised)
-                continue
-            if f.startswith('etc/exabgp'):
-                normalised = os.path.join(etc, f[11:])
-                if os.path.isfile(normalised):
-                    configurations.append(normalised)
-                    continue
-
-            logger.debug('one of the arguments passed as configuration is not a file (%s)' % f, 'configuration')
-            sys.exit(1)
-
-    else:
-        sys.stdout.write(usage)
-        sys.stdout.write('Environment values are:\n%s\n\n' % '\n'.join(' - %s' % _ for _ in environment.default()))
-        sys.stdout.write('no configuration file provided')
-        sys.stdout.flush()
-        sys.exit(1)
-
-    from exabgp.bgp.message.update.attribute import Attribute
-
-    Attribute.caching = env.cache.attributes
-
-    if env.debug.rotate or len(configurations) == 1:
-        run(env, comment, configurations, root, options["--validate"])
-
-    if not (env.log.destination in ('syslog', 'stdout', 'stderr') or env.log.destination.startswith('host:')):
-        logger.error('can not log to files when running multiple configuration (as we fork)', 'configuration')
-        sys.exit(1)
-
-    try:
-        # run each configuration in its own process
-        pids = []
-        for configuration in configurations:
-            pid = os.fork()
-            if pid == 0:
-                run(env, comment, [configuration], root, options["--validate"], os.getpid())
-            else:
-                pids.append(pid)
-
-        # If we get a ^C / SIGTERM, ignore just continue waiting for our child process
-        import signal
-
-        signal.signal(signal.SIGINT, signal.SIG_IGN)
-
-        # wait for the forked processes
-        for pid in pids:
-            os.waitpid(pid, 0)
-    except OSError as exc:
-        logger.critical('can not fork, errno %d : %s' % (exc.errno, exc.strerror), 'reactor')
-        sys.exit(1)
-
-
-def run(env, comment, configurations, root, validate, pid=0):
-    logger = Logger()
-
-    logger.notice('Thank you for using ExaBGP', 'welcome')
-    logger.notice('%s' % version, 'version')
-    logger.notice('%s' % sys.version.replace('\n', ' '), 'interpreter')
-    logger.notice('%s' % ' '.join(platform.uname()[:5]), 'os')
-    logger.notice('%s' % root, 'installation')
-
-    if comment:
-        logger.notice(comment, 'advice')
-
-    warning = warn()
-    if warning:
-        logger.warning(warning, 'advice')
-
-    if env.api.cli:
-        pipename = 'exabgp' if env.api.pipename is None else env.api.pipename
-        pipes = named_pipe(root, pipename)
-        if len(pipes) != 1:
-            env.api.cli = False
-            logger.error(
-                'could not find the named pipes (%s.in and %s.out) required for the cli' % (pipename, pipename), 'cli'
-            )
-            logger.error('we scanned the following folders (the number is your PID):', 'cli')
-            for location in pipes:
-                logger.error(' - %s' % location, 'cli control')
-            logger.error('please make them in one of the folder with the following commands:', 'cli control')
-            logger.error('> mkfifo %s/run/%s.{in,out}' % (os.getcwd(), pipename), 'cli control')
-            logger.error('> chmod 600 %s/run/%s.{in,out}' % (os.getcwd(), pipename), 'cli control')
-            if os.getuid() != 0:
-                logger.error(
-                    '> chown %d:%d %s/run/%s.{in,out}' % (os.getuid(), os.getgid(), os.getcwd(), pipename),
-                    'cli control',
-                )
-        else:
-            pipe = pipes[0]
-            os.environ['exabgp_cli_pipe'] = pipe
-            os.environ['exabgp_api_pipename'] = pipename
-
-            logger.info('named pipes for the cli are:', 'cli control')
-            logger.info('to send commands  %s%s.in' % (pipe, pipename), 'cli control')
-            logger.info('to read responses %s%s.out' % (pipe, pipename), 'cli control')
-
-    if not env.profile.enable:
-        exit_code = Reactor(configurations).run(validate, root)
-        __exit(env.debug.memory, exit_code)
-
-    try:
-        import cProfile as profile
-    except ImportError:
-        import profile
-
-    if env.profile.file == 'stdout':
-        profiled = 'Reactor(%s).run(%s,"%s")' % (str(configurations), str(validate), str(root))
-        exit_code = profile.run(profiled)
-        __exit(env.debug.memory, exit_code)
-
-    if pid:
-        profile_name = "%s-pid-%d" % (env.profile.file, pid)
-    else:
-        profile_name = env.profile.file
-
-    notice = ''
-    if os.path.isdir(profile_name):
-        notice = 'profile can not use this filename as output, it is not a directory (%s)' % profile_name
-    if os.path.exists(profile_name):
-        notice = 'profile can not use this filename as output, it already exists (%s)' % profile_name
-
-    if not notice:
-        cwd = os.getcwd()
-        logger.debug('profiling ....', 'reactor')
-        profiler = profile.Profile()
-        profiler.enable()
-        try:
-            exit_code = Reactor(configurations).run(validate, root)
-        except Exception:
-            exit_code = Reactor.Exit.unknown
-            raise
-        finally:
-            from exabgp.vendoring import lsprofcalltree
-
-            profiler.disable()
-            kprofile = lsprofcalltree.KCacheGrind(profiler)
-            try:
-                destination = profile_name if profile_name.startswith('/') else os.path.join(cwd, profile_name)
-                with open(destination, 'w+') as write:
-                    kprofile.output(write)
-            except IOError:
-                notice = 'could not save profiling in formation at: ' + destination
-                logger.debug("-" * len(notice), 'reactor')
-                logger.debug(notice, 'reactor')
-                logger.debug("-" * len(notice), 'reactor')
-            __exit(env.debug.memory, exit_code)
-    else:
-        logger.debug("-" * len(notice), 'reactor')
-        logger.debug(notice, 'reactor')
-        logger.debug("-" * len(notice), 'reactor')
-        Reactor(configurations).run(validate, root)
-        __exit(env.debug.memory, 1)
-
-
-if __name__ == '__main__':
-    main()
diff --git a/lib/exabgp/application/cli.py b/lib/exabgp/application/cli.py
index ab5a10d1c..05225cc3f 100644
--- a/lib/exabgp/application/cli.py
+++ b/lib/exabgp/application/cli.py
@@ -1,30 +1,23 @@
 #!/usr/bin/env python
 # encoding: utf-8
-"""
-cli.py
 
-Created by Thomas Mangin on 2014-12-22.
-Copyright (c) 2009-2017 Exa Networks. All rights reserved.
-License: 3-clause BSD. (See the COPYRIGHT file)
-"""
+"""exabgp command line interface"""
+
 
 import os
 import sys
 import time
+import errno
 import select
 import signal
-import errno
+import argparse
 
-from exabgp.application.bgp import root_folder
-from exabgp.application.bgp import named_pipe
-from exabgp.application.bgp import get_envfile
-from exabgp.application.bgp import get_env
+from exabgp.application.control import named_pipe
 from exabgp.application.control import check_fifo
 
 from exabgp.reactor.network.error import error
 from exabgp.reactor.api.response.answer import Answer
 
-from exabgp.vendoring import docopt
 
 errno_block = set(
     (
@@ -40,27 +33,6 @@
     )
 )
 
-usage = """\
-The BGP swiss army knife of networking
-
-usage: exabgpcli [--root ROOT]
-\t\t\t\t\t\t\t\t [--help|<command>...]
-\t\t\t\t\t\t\t\t [--env ENV]
-
-positional arguments:
-\tcommand               valid exabgpcli command (see below)
-
-optional arguments:
-\t--env ENV,   -e ENV   environment configuration file
-\t--help,      -h       exabgp manual page
-\t--root ROOT, -f ROOT  root folder where etc,bin,sbin are located
-
-commands:
-\thelp                  show the commands known by ExaBGP
-""".replace(
-    '\t', '  '
-)
-
 
 class AnswerStream:
     done = '\n%s\n' % Answer.done
@@ -123,29 +95,22 @@ def write_timeout(signum, frame):
     return writer
 
 
+def args(sub):
+    # fmt:off
+    sub.add_argument('command', nargs='*', help='command to run on the router')
+    # fmt:on
+
+
 def main():
-    options = docopt.docopt(usage, help=False)
-    if options['--env'] is None:
-        options['--env'] = ''
-
-    root = root_folder(options, ['/bin/exabgpcli', '/sbin/exabgpcli', '/lib/exabgp/application/cli.py'])
-    prefix = '' if root == '/usr' else root
-    etc = prefix + '/etc/exabgp'
-    envfile = get_envfile(options, etc)
-    env = get_env(envfile)
-    pipename = env['api']['pipename']
+    parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__)
+    args(parser)
+    cmdline(parser.parse_args())
 
-    if options['--help']:
-        sys.stdout.write(usage)
-        sys.stdout.flush()
-        sys.exit(0)
 
-    if not options['<command>']:
-        sys.stdout.write(usage)
-        sys.stdout.flush()
-        sys.exit(0)
+def cmdline(cmdarg):
+    pipename = env['api']['pipename']
 
-    command = ' '.join(options['<command>'])
+    command = cmdarg.command
 
     pipes = named_pipe(root, pipename)
     if len(pipes) != 1:
diff --git a/lib/exabgp/application/control.py b/lib/exabgp/application/control.py
index 10a045c55..5838ddfe5 100644
--- a/lib/exabgp/application/control.py
+++ b/lib/exabgp/application/control.py
@@ -1,11 +1,3 @@
-"""
-control.py
-
-Created by Thomas Mangin on 2015-01-13.
-Copyright (c) 2015-2017 Exa Networks. All rights reserved.
-License: 3-clause BSD. (See the COPYRIGHT file)
-"""
-
 import os
 import sys
 import fcntl
@@ -23,6 +15,39 @@
 mb = kb * 1024
 
 
+def named_pipe(root, pipename='exabgp'):
+    locations = [
+        '/run/exabgp/',
+        '/run/%d/' % os.getuid(),
+        '/run/',
+        '/var/run/exabgp/',
+        '/var/run/%d/' % os.getuid(),
+        '/var/run/',
+        root + '/run/exabgp/',
+        root + '/run/%d/' % os.getuid(),
+        root + '/run/',
+        root + '/var/run/exabgp/',
+        root + '/var/run/%d/' % os.getuid(),
+        root + '/var/run/',
+    ]
+    for location in locations:
+        cli_in = location + pipename + '.in'
+        cli_out = location + pipename + '.out'
+
+        try:
+            if not stat.S_ISFIFO(os.stat(cli_in).st_mode):
+                continue
+            if not stat.S_ISFIFO(os.stat(cli_out).st_mode):
+                continue
+        except KeyboardInterrupt:
+            raise
+        except Exception:
+            continue
+        os.environ['exabgp_cli_pipe'] = location
+        return [location]
+    return locations
+
+
 def env(app, section, name, default):
     r = os.environ.get('%s.%s.%s' % (app, section, name), None)
     if r is None:
diff --git a/lib/exabgp/application/decode.py b/lib/exabgp/application/decode.py
new file mode 100644
index 000000000..ada74fea7
--- /dev/null
+++ b/lib/exabgp/application/decode.py
@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+import sys
+import string
+import argparse
+
+from exabgp.environment import getenv
+
+
+def is_bgp(message):
+    return all(c in string.hexdigits or c == ':' for c in message)
+
+
+def args(sub):
+    # fmt:off
+    sub.add_argument('payload', help='the BGP payload in hexadecimal', type=str)
+    # fmt:on
+
+
+def main():
+    parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__)
+    args(parser)
+    cmdline(parser.parse_args())
+
+
+def cmdline(cmdarg):
+    if not is_bgp(cmdarg.payload):
+        # parser.print_usage()
+        sys.stdout.write('Environment values are:\n%s\n\n' % '\n'.join(' - %s' % _ for _ in Env.default()))
+        sys.stdout.write('The BGP message must be an hexadecimal string.\n\n')
+        sys.stdout.write('All colons or spaces are ignored, for example:\n\n')
+        sys.stdout.write('  --decode 001E0200000007900F0003000101\n')
+        sys.stdout.write('  --decode 001E:02:0000:0007:900F:0003:0001:01\n')
+        sys.stdout.write('  --decode FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF001E0200000007900F0003000101\n')
+        sys.stdout.write('  --decode FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF:001E:02:0000:0007:900F:0003:0001:01\n')
+        sys.stdout.write('  --decode \'FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF 001E02 00000007900F0003000101\n\'')
+        sys.stdout.flush()
+        sys.exit(1)
+
+    env = getenv()
+    env.log.parser = True
+    env.debug.route = cmdarg.payload
+    env.tcp.bind = ''
+
+
+if __name__ == '__main__':
+    main()
diff --git a/lib/exabgp/application/environ.py b/lib/exabgp/application/environ.py
new file mode 100644
index 000000000..babbbc557
--- /dev/null
+++ b/lib/exabgp/application/environ.py
@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+"""exabgp environement values"""
+
+import sys
+import argparse
+
+from exabgp.environment import Env
+
+
+def args(sub):
+    # fmt: off
+    sub.add_argument('-d', '--diff', help='show only the different from the defaults', action='store_true')
+    sub.add_argument('-e', '--env', help='display using environment (not ini)', action='store_true')
+    # fmt: on
+
+
+def default():
+    sys.stdout.write('\nEnvironment values are:\n')
+    sys.stdout.write('\n'.join('    %s' % _ for _ in Env.default()))
+    sys.stdout.flush()
+
+
+def cmdline(cmdarg):
+    dispatch = {
+        True: Env.iter_env,
+        False: Env.iter_ini,
+    }
+
+    for line in dispatch[cmdarg.env](cmdarg.diff):
+        sys.stdout.write('%s\n' % line)
+        sys.stdout.flush()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__)
+    args(parser)
+    cmdline(parser.parse_args())
+
+
+if __name__ == '__main__':
+    main()
diff --git a/lib/exabgp/application/healthcheck.py b/lib/exabgp/application/healthcheck.py
index 5e2007013..52846eab4 100644
--- a/lib/exabgp/application/healthcheck.py
+++ b/lib/exabgp/application/healthcheck.py
@@ -68,7 +68,7 @@ def parse():
     formatter = argparse.RawDescriptionHelpFormatter
     parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__, formatter_class=formatter)
 
-    #fmt: off
+    # fmt: off
     g = parser.add_mutually_exclusive_group()
     g.add_argument("--debug", "-d", action="store_true", default=False, help="enable debugging")
     g.add_argument("--no-ack", "-a", action="store_true", default=False, help="set for exabgp 3.4 or 4.x when exabgp.api.ack=false")
@@ -116,7 +116,7 @@ def parse():
     g.add_argument("--up-execute", metavar='CMD', type=str, action="append", help="execute CMD when the service becomes available")
     g.add_argument("--down-execute", metavar='CMD', type=str, action="append", help="execute CMD when the service becomes unavailable")
     g.add_argument("--disabled-execute", metavar='CMD', type=str, action="append", help="execute CMD when the service is disabled")
-    #fmt: on
+    # fmt: on
 
     options = parser.parse_args()
     if options.config is not None:
@@ -509,6 +509,11 @@ def sigterm_handler(signum, frame):  # pylint: disable=W0612,W0613
             break
 
 
+def cmdline(cmdarg):
+    sys.argv = [f'{sys.argv[0]} {sys.argv[1]}'] + sys.argv[2:]
+    main()
+
+
 def main():
     """Entry point."""
     options = parse()
diff --git a/lib/exabgp/application/main.py b/lib/exabgp/application/main.py
index 988b32a24..0a85c8acb 100644
--- a/lib/exabgp/application/main.py
+++ b/lib/exabgp/application/main.py
@@ -7,40 +7,73 @@
 License: 3-clause BSD. (See the COPYRIGHT file)
 """
 
+import os
 import sys
+import argparse
 
-from exabgp.application import run_exabgp
-from exabgp.application import run_exabmp
-from exabgp.application import run_cli
-from exabgp.application import run_healthcheck
+from exabgp.application import cli
+from exabgp.application import server
+from exabgp.application import decode
+from exabgp.application import environ
+from exabgp.application import version
+from exabgp.application import healthcheck
 
 
 def main():
-    if len(sys.argv) == 1:
-        run_exabgp()
-        return
-
-    if sys.argv[1] == 'bgp':
-        sys.argv = sys.argv[1:]
-        run_exabgp()
-        return
-
-    if sys.argv[1] == 'bmp':
-        sys.argv = sys.argv[1:]
-        run_exabgp()
-        return
-
-    if sys.argv[1] == 'healthcheck':
-        sys.argv = sys.argv[1:]
-        run_healthcheck()
-        return
-
-    if sys.argv[1] == 'cli':
-        sys.argv = sys.argv[1:]
-        run_cli()
-        return
-
-    run_exabgp()
+    cli_named_pipe = os.environ.get('exabgp_cli_pipe', '')
+    if cli_named_pipe:
+        from exabgp.application.control import main as control
+
+        control(cli_named_pipe)
+        sys.exit(0)
+
+    # compatibility with exabgp 4.x
+    if len(sys.argv) > 1 and not ('-h' in sys.argv or '--help' in sys.argv):
+        if sys.argv[1] not in ('version', 'cli', 'healthcheck', 'decode', 'server', 'env'):
+            sys.argv = sys.argv[0:1] + ['server'] + sys.argv[1:]
+
+    formatter = argparse.RawDescriptionHelpFormatter
+    parser = argparse.ArgumentParser(description='The BGP swiss army knife of networking')
+
+    subparsers = parser.add_subparsers()
+
+    sub = subparsers.add_parser('version', help='report exabgp version', description=version.__doc__)
+    sub.set_defaults(func=version.cmdline)
+    version.args(sub)
+
+    sub = subparsers.add_parser('cli', help='control a running exabgp server instance', description=cli.__doc__)
+    sub.set_defaults(func=cli.cmdline)
+    cli.args(sub)
+
+    sub = subparsers.add_parser(
+        'healthcheck',
+        help='monitor services and announce/withdraw routes',
+        description=healthcheck.__doc__,
+        formatter_class=formatter,
+    )
+    sub.set_defaults(func=healthcheck.cmdline)
+    # healthcheck.args(sub)
+
+    sub = subparsers.add_parser('env', help='show exabgp configuration information', description=environ.__doc__)
+    sub.set_defaults(func=environ.cmdline)
+    environ.args(sub)
+
+    sub = subparsers.add_parser('decode', help='decode hex-encoded bgp packets', description=decode.__doc__)
+    sub.set_defaults(func=decode.cmdline)
+    decode.args(sub)
+
+    sub = subparsers.add_parser('server', help='start exabgp', description=server.__doc__)
+    sub.set_defaults(func=server.cmdline)
+    server.args(sub)
+
+    cmdarg = parser.parse_args()
+    options = vars(cmdarg)
+
+    if 'func' in options:
+        cmdarg.func(cmdarg)
+    else:
+        parser.print_help()
+        environ.default()
 
 
 if __name__ == '__main__':
diff --git a/lib/exabgp/application/server.py b/lib/exabgp/application/server.py
new file mode 100755
index 000000000..3e07fd900
--- /dev/null
+++ b/lib/exabgp/application/server.py
@@ -0,0 +1,277 @@
+# encoding: utf-8
+
+"""exabgp server"""
+
+
+import os
+import sys
+import syslog
+import argparse
+import platform
+
+from exabgp.debug import setup_report
+
+# import before the fork to improve copy on write memory savings
+from exabgp.reactor.loop import Reactor
+
+from exabgp.util.dns import warn
+from exabgp.logger import Logger
+
+# this is imported from configuration.setup to make sure it was initialised
+from exabgp.environment import getenv
+from exabgp.environment import ENVFILE
+from exabgp.environment import ROOT
+
+from exabgp.application.control import named_pipe
+from exabgp.version import version
+
+
+def __exit(memory, code):
+    if memory:
+        from exabgp.vendoring import objgraph
+
+        sys.stdout.write('memory utilisation\n\n')
+        sys.stdout.write(objgraph.show_most_common_types(limit=20))
+        sys.stdout.write('\n\n\n')
+        sys.stdout.write('generating memory utilisation graph\n\n')
+        sys.stdout.write()
+        obj = objgraph.by_type('Reactor')
+        objgraph.show_backrefs([obj], max_depth=10)
+    sys.exit(code)
+
+
+def args(sub):
+    # fmt:off
+    sub.add_argument('-t', '--test', help='perform a configuration validity check only', action='store_true')
+    sub.add_argument('-d', '--debug', help='start the python debugger on serious logging and on SIGTERM (shortcut for exabgp.log.all=true exabgp.log.level=DEBUG)', action='store_true')
+    sub.add_argument('-s', '--signal', help='issue a SIGUSR1 to reload the configuration after <time> seconds, only useful for code debugging', type=int)
+    sub.add_argument('-v', '--validate', help='validate the configuration file format only', action='store_true')
+    sub.add_argument('-1', '--once', help='only perform one attempt to connect to peers', action='store_true')
+    sub.add_argument('-p', '--pdb', help='fire the debugger on critical logging, SIGTERM, and exceptions (shortcut for exabgp.pdb.enable=true)', action='store_true')
+    sub.add_argument('-m', '--memory', help='display memory usage information on exit', action='store_true')
+    sub.add_argument('--profile', help='enable profiling (shortcut for exabgp.profile.enable=true exabgp.profile.file=PROFILE)', type=int)
+    sub.add_argument('configuration', help='configuration file(s)', nargs='+', type=str)
+    # fmt:on
+
+
+def cmdline(cmdarg):
+    if not os.path.isfile(ENVFILE):
+        comment = 'environment file missing\ngenerate it using "exabgp env --fi > %s"' % ENVFILE
+    else:
+        comment = ''
+
+    logger = Logger()
+
+    # Must be done before setting the logger as it modify its behaviour
+    if cmdarg.debug:
+        env = getenv()
+        env.log.all = True
+        env.log.level = syslog.LOG_DEBUG
+
+    duration = cmdarg.signal
+    if duration and duration.isdigit():
+        pid = os.fork()
+        if pid:
+            import time
+            import signal
+
+            try:
+                time.sleep(int(duration))
+                os.kill(pid, signal.SIGUSR1)
+            except KeyboardInterrupt:
+                pass
+            try:
+                pid, code = os.wait()
+                sys.exit(code)
+            except KeyboardInterrupt:
+                try:
+                    pid, code = os.wait()
+                    sys.exit(code)
+                except Exception:
+                    sys.exit(0)
+
+    if cmdarg.profile:
+        env.profile.enable = True
+        if cmdarg.profile.lower() in ['1', 'true']:
+            env.profile.file = True
+        elif cmdarg.profile.lower() in ['0', 'false']:
+            env.profile.file = False
+        else:
+            env.profile.file = cmdarg.profile
+
+    if cmdarg.once:
+        env.tcp.once = True
+
+    if cmdarg.pdb:
+        env.debug.pdb = True
+
+    if cmdarg.test:
+        env.debug.selfcheck = True
+        env.log.parser = True
+
+    if cmdarg.memory:
+        env.debug.memory = True
+
+    configurations = []
+    # check the file only once that we have parsed all the command line options and allowed them to run
+    for f in cmdarg.configuration:
+        # some users are using symlinks for atomic change of the configuration file
+        # using mv may however be better practice :p
+        normalised = os.path.realpath(os.path.normpath(f))
+        target = os.path.realpath(normalised)
+        if os.path.isfile(target):
+            configurations.append(normalised)
+            continue
+        if f.startswith('etc/exabgp'):
+            normalised = os.path.join(etc, f[11:])
+            if os.path.isfile(normalised):
+                configurations.append(normalised)
+                continue
+
+        logger.debug('one of the arguments passed as configuration is not a file (%s)' % f, 'configuration')
+        sys.exit(1)
+
+    from exabgp.bgp.message.update.attribute import Attribute
+
+    Attribute.caching = env.cache.attributes
+
+    if env.debug.rotate or len(configurations) == 1:
+        run(env, comment, configurations, cmdarg.validate)
+
+        logger.error('can not log to files when running multiple configuration (as we fork)', 'configuration')
+        sys.exit(1)
+
+    try:
+        # run each configuration in its own process
+        pids = []
+        for configuration in configurations:
+            pid = os.fork()
+            if pid == 0:
+                run(env, comment, [configuration], cmdarg.validate, os.getpid())
+            else:
+                pids.append(pid)
+
+        # If we get a ^C / SIGTERM, ignore just continue waiting for our child process
+        import signal
+
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
+
+        # wait for the forked processes
+        for pid in pids:
+            os.waitpid(pid, 0)
+    except OSError as exc:
+        logger.critical('can not fork, errno %d : %s' % (exc.errno, exc.strerror), 'reactor')
+        sys.exit(1)
+
+
+def run(env, comment, configurations, validate, pid=0):
+    logger = Logger()
+
+    logger.notice('Thank you for using ExaBGP', 'welcome')
+    logger.notice('%s' % version, 'version')
+    logger.notice('%s' % sys.version.replace('\n', ' '), 'interpreter')
+    logger.notice('%s' % ' '.join(platform.uname()[:5]), 'os')
+    logger.notice('%s' % ROOT, 'installation')
+
+    if comment:
+        logger.notice(comment, 'advice')
+
+    warning = warn()
+    if warning:
+        logger.warning(warning, 'advice')
+
+    if env.api.cli:
+        pipename = 'exabgp' if env.api.pipename is None else env.api.pipename
+        pipes = named_pipe(ROOT, pipename)
+        if len(pipes) != 1:
+            env.api.cli = False
+            logger.error(
+                'could not find the named pipes (%s.in and %s.out) required for the cli' % (pipename, pipename), 'cli'
+            )
+            logger.error('we scanned the following folders (the number is your PID):', 'cli')
+            for location in pipes:
+                logger.error(' - %s' % location, 'cli control')
+            logger.error('please make them in one of the folder with the following commands:', 'cli control')
+            logger.error('> mkfifo %s/run/%s.{in,out}' % (os.getcwd(), pipename), 'cli control')
+            logger.error('> chmod 600 %s/run/%s.{in,out}' % (os.getcwd(), pipename), 'cli control')
+            if os.getuid() != 0:
+                logger.error(
+                    '> chown %d:%d %s/run/%s.{in,out}' % (os.getuid(), os.getgid(), os.getcwd(), pipename),
+                    'cli control',
+                )
+        else:
+            pipe = pipes[0]
+            os.environ['exabgp_cli_pipe'] = pipe
+            os.environ['exabgp_api_pipename'] = pipename
+
+            logger.info('named pipes for the cli are:', 'cli control')
+            logger.info('to send commands  %s%s.in' % (pipe, pipename), 'cli control')
+            logger.info('to read responses %s%s.out' % (pipe, pipename), 'cli control')
+
+    if not env.profile.enable:
+        exit_code = Reactor(configurations).run(validate, ROOT)
+        __exit(env.debug.memory, exit_code)
+
+    try:
+        import cProfile as profile
+    except ImportError:
+        import profile
+
+    if env.profile.file == 'stdout':
+        profiled = 'Reactor(%s).run(%s,"%s")' % (str(configurations), str(validate), str(ROOT))
+        exit_code = profile.run(profiled)
+        __exit(env.debug.memory, exit_code)
+
+    if pid:
+        profile_name = "%s-pid-%d" % (env.profile.file, pid)
+    else:
+        profile_name = env.profile.file
+
+    notice = ''
+    if os.path.isdir(profile_name):
+        notice = 'profile can not use this filename as output, it is not a directory (%s)' % profile_name
+    if os.path.exists(profile_name):
+        notice = 'profile can not use this filename as output, it already exists (%s)' % profile_name
+
+    if not notice:
+        cwd = os.getcwd()
+        logger.debug('profiling ....', 'reactor')
+        profiler = profile.Profile()
+        profiler.enable()
+        try:
+            exit_code = Reactor(configurations).run(validate, ROOT)
+        except Exception:
+            exit_code = Reactor.Exit.unknown
+            raise
+        finally:
+            from exabgp.vendoring import lsprofcalltree
+
+            profiler.disable()
+            kprofile = lsprofcalltree.KCacheGrind(profiler)
+            try:
+                destination = profile_name if profile_name.startswith('/') else os.path.join(cwd, profile_name)
+                with open(destination, 'w+') as write:
+                    kprofile.output(write)
+            except IOError:
+                notice = 'could not save profiling in formation at: ' + destination
+                logger.debug("-" * len(notice), 'reactor')
+                logger.debug(notice, 'reactor')
+                logger.debug("-" * len(notice), 'reactor')
+            __exit(env.debug.memory, exit_code)
+    else:
+        logger.debug("-" * len(notice), 'reactor')
+        logger.debug(notice, 'reactor')
+        logger.debug("-" * len(notice), 'reactor')
+        Reactor(configurations).run(validate, ROOT)
+        __exit(env.debug.memory, 1)
+
+
+def main():
+    parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__)
+    args(parser)
+    setup_report()
+    cmdline(parser, parser.parse_args())
+
+
+if __name__ == '__main__':
+    main()
diff --git a/lib/exabgp/application/tojson.py b/lib/exabgp/application/tojson.py
index b502704b4..49fed0732 100644
--- a/lib/exabgp/application/tojson.py
+++ b/lib/exabgp/application/tojson.py
@@ -21,9 +21,6 @@
 from exabgp.reactor.api.transcoder import Transcoder
 from exabgp.reactor.api.processes import preexec_helper
 
-from exabgp.configuration.setup import environment
-
-environment.setup('')
 
 # test = """\
 # { "exabgp": "3.5.0", "time": 1430238962.74, "host" : "mangin.local", "pid" : 37912, "ppid" : 37903, "type": "state", "neighbor": { "address": { "local": "82.219.212.34", "peer": "127.0.0.1" }, "asn": { "local": "65534", "peer": "65533" }, "state": "down", "reason": "out loop, peer reset, message [closing connection] error[the TCP connection was closed by the remote end]"} }
diff --git a/lib/exabgp/application/version.py b/lib/exabgp/application/version.py
new file mode 100644
index 000000000..ab58ac30a
--- /dev/null
+++ b/lib/exabgp/application/version.py
@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+"""exabgp current version"""
+
+import sys
+import argparse
+import platform
+
+from exabgp.version import version
+
+
+def args(sub):
+    # fmt:off
+    pass
+    # fmt:on
+
+
+def main():
+    parser = argparse.ArgumentParser(description=sys.modules[__name__].__doc__)
+    args(parser)
+    cmdline(parser.parse_args())
+
+
+def cmdline(cmdarg):
+    sys.stdout.write('ExaBGP : %s\n' % version)
+    sys.stdout.write('Python : %s\n' % sys.version.replace('\n', ' '))
+    sys.stdout.write('Uname  : %s\n' % ' '.join(platform.uname()[:5]))
+    sys.stdout.flush()
+
+
+if __name__ == '__main__':
+    main()
diff --git a/lib/exabgp/bgp/message/update/attribute/attributes.py b/lib/exabgp/bgp/message/update/attribute/attributes.py
index 7fb00ec8e..fc9a293a8 100644
--- a/lib/exabgp/bgp/message/update/attribute/attributes.py
+++ b/lib/exabgp/bgp/message/update/attribute/attributes.py
@@ -9,7 +9,7 @@
 
 from struct import unpack
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 from exabgp.bgp.message.update.attribute.attribute import Attribute
 from exabgp.bgp.message.update.attribute.attribute import TreatAsWithdraw
@@ -188,7 +188,7 @@ def __init__(self):
         self.cacheable = True
 
         # XXX: FIXME: surely not the best place for this
-        Attribute.caching = environment.settings().cache.attributes
+        Attribute.caching = getenv().cache.attributes
 
     def has(self, k):
         return k in self
diff --git a/lib/exabgp/configuration/configuration.py b/lib/exabgp/configuration/configuration.py
index 86f4047ef..6e34c7926 100644
--- a/lib/exabgp/configuration/configuration.py
+++ b/lib/exabgp/configuration/configuration.py
@@ -43,7 +43,7 @@
 from exabgp.configuration.l2vpn import ParseVPLS
 from exabgp.configuration.operational import ParseOperational
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 # for registration
 from exabgp.configuration.announce.ip import AnnounceIP
@@ -108,7 +108,7 @@ def inject_refresh(self, peers, refreshes):
 class Configuration(_Configuration):
     def __init__(self, configurations, text=False):
         _Configuration.__init__(self)
-        self.api_encoder = environment.settings().api.encoder
+        self.api_encoder = getenv().api.encoder
 
         self._configurations = configurations
         self._text = text
@@ -337,13 +337,13 @@ def reload(self):
         except KeyboardInterrupt:
             return self.error.set('configuration reload aborted by ^C or SIGINT')
         except Error as exc:
-            if environment.settings().debug.configuration:
+            if getenv().debug.configuration:
                 raise
             return self.error.set(
                 'problem parsing configuration file line %d\n' 'error message: %s' % (self.tokeniser.index_line, exc)
             )
         except Exception as exc:
-            if environment.settings().debug.configuration:
+            if getenv().debug.configuration:
                 raise
             return self.error.set(
                 'problem parsing configuration file line %d\n' 'error message: %s' % (self.tokeniser.index_line, exc)
@@ -519,16 +519,16 @@ def run(self, name, command):
 
     def debug_check_route(self):
         # we are not really running the program, just want to ....
-        if environment.settings().debug.route:
+        if getenv().debug.route:
             from exabgp.configuration.check import check_message
 
-            if check_message(self.neighbors, environment.settings().debug.route):
+            if check_message(self.neighbors, getenv().debug.route):
                 sys.exit(0)
             sys.exit(1)
 
     def debug_self_check(self):
         # we are not really running the program, just want check the configuration validity
-        if environment.settings().debug.selfcheck:
+        if getenv().debug.selfcheck:
             from exabgp.configuration.check import check_neighbor
 
             if check_neighbor(self.neighbors):
diff --git a/lib/exabgp/configuration/core/error.py b/lib/exabgp/configuration/core/error.py
index 3961dedc0..e686de4e8 100644
--- a/lib/exabgp/configuration/core/error.py
+++ b/lib/exabgp/configuration/core/error.py
@@ -1,13 +1,13 @@
 import sys
 import pdb
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 
 class Error(Exception):
     def __init__(self):
         self.message = ''
-        self.debug = environment.settings().debug.configuration
+        self.debug = getenv().debug.configuration
 
     def set(self, message):
         self.message = message
diff --git a/lib/exabgp/configuration/environment.py b/lib/exabgp/configuration/environment.py
deleted file mode 100644
index cedb1dfaf..000000000
--- a/lib/exabgp/configuration/environment.py
+++ /dev/null
@@ -1,388 +0,0 @@
-# encoding: utf-8
-"""
-environment.py
-
-Created by Thomas Mangin on 2011-11-29.
-Copyright (c) 2011-2017 Exa Networks. All rights reserved.
-License: 3-clause BSD. (See the COPYRIGHT file)
-"""
-
-# XXX: raised exception not caught
-# XXX: reloading mid-program not possible
-# XXX: validation for path, file, etc not correctly test (ie surely buggy)
-
-
-import os
-import sys
-import pwd
-import syslog
-
-from exabgp.protocol.ip import IP
-from exabgp.util.ip import isip
-
-
-# ===================================================================== NoneDict
-#
-
-
-class NoneDict(dict):
-    def __getitem__(self, name):
-        return None
-
-
-nonedict = NoneDict()
-
-
-# ================================================================== environment
-# XXX: FIXME: Upper case for class !
-
-
-class environment(object):
-    # class returned on issues
-    class Error(Exception):
-        pass
-
-    application = 'unset'
-
-    # the configuration to be set by the program
-    configuration = {}
-
-    # the final parsed settings
-    _settings = None
-
-    location = (
-        os.path.normpath(sys.argv[0])
-        if sys.argv[0].startswith('/')
-        else os.path.normpath(os.path.join(os.getcwd(), sys.argv[0]))
-    )
-    log_levels = ['EMERG', 'ALERT', 'CRIT', 'CRITICAL', 'ERR', 'ERROR', 'WARNING', 'NOTICE', 'INFO', 'DEBUG']
-
-    @staticmethod
-    def setup(conf):
-        if environment._settings:
-            # nosetest is performing the setup multiple times, so we can not raise anymore
-            # raise RuntimeError('You already initialised the environment')
-            return environment._settings
-        environment._settings = _env(conf)
-        return environment._settings
-
-    @staticmethod
-    def settings():
-        if not environment._settings:
-            raise RuntimeError('You can not have an import using settings() before main() initialised environment')
-        return environment._settings
-
-    @staticmethod
-    def root(path):
-        roots = environment.location.split(os.sep)
-        location = []
-        for index in range(len(roots) - 1, -1, -1):
-            if roots[index] == 'lib':
-                if index:
-                    location = roots[:index]
-                break
-        root = os.path.join(*location)
-        paths = [
-            os.path.normpath(os.path.join(os.path.join(os.sep, root, path))),
-            os.path.normpath(os.path.expanduser(environment.unquote(path))),
-            os.path.normpath(os.path.join('/', path)),
-        ]
-        return paths
-
-    @staticmethod
-    def integer(_):
-        return int(_)
-
-    @staticmethod
-    def real(_):
-        return float(_)
-
-    @staticmethod
-    def lowunquote(_):
-        return _.strip().strip('\'"').lower()
-
-    @staticmethod
-    def unquote(_):
-        return _.strip().strip('\'"')
-
-    @staticmethod
-    def quote(_):
-        return "'%s'" % str(_)
-
-    @staticmethod
-    def quote_list(_):
-        return "'%s'" % ' '.join([str(x) for x in _])
-
-    @staticmethod
-    def nop(_):
-        return _
-
-    @staticmethod
-    def boolean(_):
-        return _.lower() in ('1', 'yes', 'on', 'enable', 'true')
-
-    @staticmethod
-    def api(_):
-        encoder = _.lower()
-        if encoder not in ('text', 'json'):
-            raise TypeError('invalid encoder')
-        return encoder
-
-    @staticmethod
-    def methods(_):
-        return _.upper().split()
-
-    @staticmethod
-    def list(_):
-        return "'%s'" % ' '.join(_)
-
-    @staticmethod
-    def lower(_):
-        return str(_).lower()
-
-    @staticmethod
-    def ip(_):
-        if isip(_):
-            return _
-        raise TypeError('ip %s is invalid' % _)
-
-    @staticmethod
-    def ip_list(_):
-        ips = []
-        for ip in _.split(' '):
-            if not ip:
-                continue
-            elif isip(ip):
-                ips.append(IP.create(ip))
-            else:
-                raise TypeError('ip %s is invalid' % ip)
-        return ips
-
-    @staticmethod
-    def user(_):
-        # XXX: incomplete
-        try:
-            pwd.getpwnam(_)
-            # uid = answer[2]
-        except KeyError:
-            raise TypeError('user %s is not found on this system' % _)
-        return _
-
-    @staticmethod
-    def folder(path):
-        paths = environment.root(path)
-        options = [p for p in paths if os.path.exists(path)]
-        if not options:
-            raise TypeError('%s does not exists' % path)
-        first = options[0]
-        if not first:
-            raise TypeError('%s does not exists' % first)
-        return first
-
-    @staticmethod
-    def path(path):
-        split = sys.argv[0].split('lib/exabgp')
-        if len(split) > 1:
-            prefix = os.sep.join(split[:1])
-            if prefix and path.startswith(prefix):
-                path = path[len(prefix) :]
-        home = os.path.expanduser('~')
-        if path.startswith(home):
-            return "'~%s'" % path[len(home) :]
-        return "'%s'" % path
-
-    @staticmethod
-    def conf(path):
-        first = environment.folder(path)
-        if not os.path.isfile(first):
-            raise TypeError('%s is not a file' % path)
-        return first
-
-    @staticmethod
-    def exe(path):
-        first = environment.conf(path)
-        if not os.access(first, os.X_OK):
-            raise TypeError('%s is not an executable' % first)
-        return first
-
-    @staticmethod
-    def syslog(path):
-        path = environment.unquote(path)
-        if path in ('stdout', 'stderr'):
-            return path
-        if path.startswith('host:'):
-            return path
-        return path
-
-    @staticmethod
-    def redirector(name):
-        if name == 'url' or name.startswith('icap://'):
-            return name
-        raise TypeError('invalid redirector protocol %s, options are url or header' % name)
-
-    @staticmethod
-    def syslog_value(log):
-        if log not in environment.log_levels:
-            if log == 'CRITICAL':
-                log = 'CRIT'
-            if log == 'ERROR':
-                log = 'ERR'
-            raise TypeError('invalid log level %s' % log)
-        return getattr(syslog, 'LOG_%s' % log)
-
-    @staticmethod
-    def syslog_name(log):
-        for name in environment.log_levels:
-            if name == 'CRITICAL':
-                name = 'CRIT'
-            if name == 'ERROR':
-                name = 'ERR'
-            if getattr(syslog, 'LOG_%s' % name) == log:
-                return name
-        raise TypeError('invalid log level %s' % log)
-
-    @staticmethod
-    def umask_read(_):
-        return int(_, 8)
-
-    @staticmethod
-    def umask_write(_):
-        return "'%s'" % (oct(_))
-
-    @staticmethod
-    def default():
-        for section in sorted(environment.configuration):
-            if section in ('internal', 'debug'):
-                continue
-            for option in sorted(environment.configuration[section]):
-                values = environment.configuration[section][option]
-                default = (
-                    "'%s'" % values['value']
-                    if values['write'] in (environment.list, environment.path, environment.quote, environment.syslog)
-                    else values['value']
-                )
-                yield '%s.%s.%s %s: %s. default (%s)' % (
-                    environment.application,
-                    section,
-                    option,
-                    ' ' * (20 - len(section) - len(option)),
-                    values['help'],
-                    default,
-                )
-
-    @staticmethod
-    def iter_ini(diff=False):
-        for section in sorted(environment._settings):
-            if section in ('internal', 'debug'):
-                continue
-            header = '\n[%s.%s]' % (environment.application, section)
-            for k in sorted(environment._settings[section]):
-                v = environment._settings[section][k]
-                if (
-                    diff
-                    and environment.configuration[section][k]['read'](environment.configuration[section][k]['value'])
-                    == v
-                ):
-                    continue
-                if header:
-                    yield header
-                    header = ''
-                yield '%s = %s' % (k, environment.configuration[section][k]['write'](v))
-
-    @staticmethod
-    def iter_env(diff=False):
-        for section, values in environment._settings.items():
-            if section in ('internal', 'debug'):
-                continue
-            for k, v in values.items():
-                if (
-                    diff
-                    and environment.configuration[section][k]['read'](environment.configuration[section][k]['value'])
-                    == v
-                ):
-                    continue
-                if environment.configuration[section][k]['write'] == environment.quote:
-                    yield "%s.%s.%s='%s'" % (environment.application, section, k, v)
-                    continue
-                yield "%s.%s.%s=%s" % (
-                    environment.application,
-                    section,
-                    k,
-                    environment.configuration[section][k]['write'](v),
-                )
-
-
-# ========================================================================= _env
-#
-
-import configparser as ConfigParser
-from exabgp.util.hashtable import HashTable
-
-
-def _env(conf):
-    here = os.path.join(os.sep, os.path.join(*environment.location.split(os.sep)))
-
-    location, directory = os.path.split(here)
-    while directory:
-        if directory == 'lib':
-            location = os.path.join(location, 'lib')
-            break
-        location, directory = os.path.split(location)
-    # we did not break - ie, we did not find the location in the normal path.
-    else:
-        # let's try to see if we are running from the QA folder (for unittesting)
-        location, directory = os.path.split(here)
-        while directory:
-            if directory == 'dev':
-                location = os.path.join(location, 'lib')
-                break
-            location, directory = os.path.split(location)
-        else:
-            # oh ! bad, let set the path to something ...
-            location = '/lib'
-
-    _conf_paths = []
-    if conf:
-        _conf_paths.append(os.path.abspath(os.path.normpath(conf)))
-    if location:
-        _conf_paths.append(
-            os.path.normpath(os.path.join(location, 'etc', environment.application, '%s.env' % environment.application))
-        )
-    _conf_paths.append(
-        os.path.normpath(os.path.join('/', 'etc', environment.application, '%s.env' % environment.application))
-    )
-
-    env = HashTable()
-    ini = ConfigParser.ConfigParser()
-
-    ini_files = [path for path in _conf_paths if os.path.exists(path)]
-    if ini_files:
-        ini.read(ini_files[0])
-
-    for section in environment.configuration:
-        default = environment.configuration[section]
-
-        for option in default:
-            convert = default[option]['read']
-            try:
-                proxy_section = '%s.%s' % (environment.application, section)
-                env_name = '%s.%s' % (proxy_section, option)
-                rep_name = env_name.replace('.', '_')
-
-                if env_name in os.environ:
-                    conf = os.environ.get(env_name)
-                elif rep_name in os.environ:
-                    conf = os.environ.get(rep_name)
-                else:
-                    conf = environment.unquote(ini.get(proxy_section, option, vars=nonedict))
-                    # name without an = or : in the configuration and no value
-                    if conf is None:
-                        conf = default[option]['value']
-            except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
-                conf = default[option]['value']
-            try:
-                env.setdefault(section, HashTable())[option] = convert(conf)
-            except TypeError:
-                raise environment.Error('invalid value for %s.%s : %s' % (section, option, conf))
-
-    return env
diff --git a/lib/exabgp/environment/__init__.py b/lib/exabgp/environment/__init__.py
new file mode 100644
index 000000000..dc054f499
--- /dev/null
+++ b/lib/exabgp/environment/__init__.py
@@ -0,0 +1,19 @@
+# this is where the environment should be taken from
+# it makes sure the environment is setup before it is imported
+import exabgp.environment.setup
+
+from exabgp.environment.environment import Env
+
+from exabgp.environment.base import APPLICATION
+from exabgp.environment.base import ENVFILE
+from exabgp.environment.base import ROOT
+
+# As soon as we import anything, a COPY is made in the local
+# namespace, it mean that we can not import the GlobalHashTable
+# directly but must ask for a copy to be made each time
+# at the time of import, so using a function get around it
+from exabgp.environment.hashtable import GlobalHashTable as __
+
+
+def getenv():
+    return __()
diff --git a/lib/exabgp/environment/base.py b/lib/exabgp/environment/base.py
new file mode 100644
index 000000000..72345bffd
--- /dev/null
+++ b/lib/exabgp/environment/base.py
@@ -0,0 +1,8 @@
+import os
+import sys
+
+APPLICATION = 'exabgp'
+
+ROOT = os.path.normpath(os.environ.get('EXABGP_ROOT', os.path.dirname(sys.argv[0])))
+ETC = os.path.join(ROOT, 'etc', APPLICATION)
+ENVFILE = os.path.join(ETC, f'{APPLICATION}.env')
diff --git a/lib/exabgp/environment/environment.py b/lib/exabgp/environment/environment.py
new file mode 100644
index 000000000..94780adc8
--- /dev/null
+++ b/lib/exabgp/environment/environment.py
@@ -0,0 +1,141 @@
+# encoding: utf-8
+"""
+environment.py
+
+Created by Thomas Mangin on 2011-11-29.
+Copyright (c) 2011-2017 Exa Networks. All rights reserved.
+License: 3-clause BSD. (See the COPYRIGHT file)
+"""
+
+import os
+
+import configparser as ConfigParser
+
+from exabgp.environment import base
+from exabgp.environment import parsing
+from exabgp.environment.base import ENVFILE
+from exabgp.environment.hashtable import HashTable
+from exabgp.environment.hashtable import GlobalHashTable
+
+
+class NoneDict(dict):
+    def __getitem__(self, name):
+        return None
+
+
+nonedict = NoneDict()
+
+
+class Env(object):
+    _setup = False
+
+    # the configuration to be set by the program
+    definition = {}
+
+    # one copy of the global configuration
+    _env = GlobalHashTable()
+
+    @classmethod
+    def default(cls):
+        for section in sorted(cls.definition):
+            if section in ('internal', 'debug'):
+                continue
+            for option in sorted(cls.definition[section]):
+                values = cls.definition[section][option]
+                default = (
+                    "'%s'" % values['value']
+                    if values['write'] in (parsing.list, parsing.path, parsing.quote, parsing.syslog_name)
+                    else values['value']
+                )
+                yield '%s.%s.%s %s %s. default (%s)' % (
+                    base.APPLICATION,
+                    section,
+                    option,
+                    ' ' * (18 - len(section) - len(option)),
+                    values['help'],
+                    default,
+                )
+
+    @classmethod
+    def iter_ini(cls, diff=False):
+        for section in sorted(cls._env):
+            if section in ('internal', 'debug'):
+                continue
+            header = '\n[%s.%s]' % (base.APPLICATION, section)
+            for k in sorted(cls._env[section]):
+                v = cls._env[section][k]
+                func = cls.definition[section][k]['read']
+                value = cls.definition[section][k]['value']
+                if diff and func(value) == v:
+                    continue
+                if header:
+                    yield header
+                    header = ''
+                yield '%s = %s' % (k, cls.definition[section][k]['write'](v))
+
+    @classmethod
+    def iter_env(cls, diff=False):
+        for section, values in cls._env.items():
+            if section in ('internal', 'debug'):
+                continue
+            for k, v in values.items():
+                func = cls.definition[section][k]['read']
+                value = cls.definition[section][k]['value']
+                if diff and func(value) == v:
+                    continue
+                if cls.definition[section][k]['write'] == parsing.quote:
+                    yield "%s.%s.%s='%s'" % (base.APPLICATION, section, k, v)
+                    continue
+                yield "%s.%s.%s=%s" % (
+                    base.APPLICATION,
+                    section,
+                    k,
+                    cls.definition[section][k]['write'](v),
+                )
+
+    @classmethod
+    def setup(cls, configuration):
+        if cls._setup:
+            return {}
+        cls._setup = True
+        cls.definition = configuration
+
+        ini = ConfigParser.ConfigParser()
+
+        _conf_paths = [
+            ENVFILE,
+        ]
+
+        ini_files = [path for path in _conf_paths if os.path.exists(path)]
+        if ini_files:
+            ini.read(ini_files[0])
+
+        for section in cls.definition:
+            default = cls.definition[section]
+
+            for option in default:
+                convert = default[option]['read']
+                try:
+                    proxy_section = '%s.%s' % (base.APPLICATION, section)
+                    env_name = '%s.%s' % (proxy_section, option)
+                    rep_name = env_name.replace('.', '_')
+
+                    if env_name in os.environ:
+                        conf = os.environ.get(env_name)
+                    elif rep_name in os.environ:
+                        conf = os.environ.get(rep_name)
+                    else:
+                        conf = parsing.unquote(ini.get(proxy_section, option, vars=nonedict))
+                        # name without an = or : in the configuration and no value
+                        if conf is None:
+                            conf = default[option]['value']
+                except (ConfigParser.NoSectionError, ConfigParser.NoOptionError):
+                    conf = default[option]['value']
+                try:
+                    cls._env.setdefault(section, HashTable())[option] = convert(conf)
+                except TypeError:
+                    raise ValueError('invalid value for %s.%s : %s' % (section, option, conf))
+
+    @classmethod
+    def settings(cls):
+        return cls._env
diff --git a/lib/exabgp/environment/hashtable.py b/lib/exabgp/environment/hashtable.py
new file mode 100644
index 000000000..80aa8e779
--- /dev/null
+++ b/lib/exabgp/environment/hashtable.py
@@ -0,0 +1,35 @@
+# encoding: utf-8
+"""
+hashtable.py
+
+Created by Thomas Mangin on 2009-09-06.
+Copyright (c) 2009-2017 Exa Networks. All rights reserved.
+License: 3-clause BSD. (See the COPYRIGHT file)
+"""
+
+
+def _(key):
+    return key.replace('_', '-')
+
+
+class HashTable(dict):
+    def __getitem__(self, key):
+        return dict.__getitem__(self, _(key))
+
+    def __setitem__(self, key, value):
+        return dict.__setitem__(self, _(key), value)
+
+    def __getattr__(self, key):
+        return dict.__getitem__(self, _(key))
+
+    def __setattr__(self, key, value):
+        return dict.__setitem__(self, _(key), value)
+
+
+class GlobalHashTable(HashTable):
+    _instance = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super(GlobalHashTable, cls).__new__(cls)
+        return cls._instance
diff --git a/lib/exabgp/environment/parsing.py b/lib/exabgp/environment/parsing.py
new file mode 100644
index 000000000..5be199121
--- /dev/null
+++ b/lib/exabgp/environment/parsing.py
@@ -0,0 +1,192 @@
+"""
+environment.py
+
+Created by Thomas Mangin on 2020-05-14.
+Copyright (c) 2011-2017 Exa Networks. All rights reserved.
+License: 3-clause BSD. (See the COPYRIGHT file)
+"""
+
+import os
+import sys
+import pwd
+
+import syslog
+
+from exabgp.util.ip import isip
+from exabgp.protocol.ip import IP
+
+from exabgp.environment import base
+
+
+log_levels = ['EMERG', 'ALERT', 'CRIT', 'CRITICAL', 'ERR', 'ERROR', 'WARNING', 'NOTICE', 'INFO', 'DEBUG']
+
+
+def integer(_):
+    return int(_)
+
+
+def real(_):
+    return float(_)
+
+
+def lowunquote(_):
+    return _.strip().strip('\'"').lower()
+
+
+def unquote(_):
+    return _.strip().strip('\'"')
+
+
+def quote(_):
+    return "'%s'" % str(_)
+
+
+def quote_list(_):
+    return "'%s'" % ' '.join([str(x) for x in _])
+
+
+def nop(_):
+    return _
+
+
+def boolean(_):
+    return _.lower() in ('1', 'yes', 'on', 'enable', 'true')
+
+
+def api(_):
+    encoder = _.lower()
+    if encoder not in ('text', 'json'):
+        raise TypeError('invalid encoder')
+    return encoder
+
+
+def methods(_):
+    return _.upper().split()
+
+
+def list(_):
+    return "'%s'" % ' '.join(_)
+
+
+def lower(_):
+    return str(_).lower()
+
+
+def ip(_):
+    if isip(_):
+        return _
+    raise TypeError('ip %s is invalid' % _)
+
+
+def ip_list(_):
+    ips = []
+    for ip in _.split(' '):
+        if not ip:
+            continue
+        elif isip(ip):
+            ips.append(IP.create(ip))
+        else:
+            raise TypeError('ip %s is invalid' % ip)
+    return ips
+
+
+def user(_):
+    # XXX: incomplete
+    try:
+        pwd.getpwnam(_)
+        # uid = answer[2]
+    except KeyError:
+        raise TypeError('user %s is not found on this system' % _)
+    return _
+
+
+def folder(path):
+    paths = root(path)
+    options = [p for p in paths if os.path.exists(path)]
+    if not options:
+        raise TypeError('%s does not exists' % path)
+    first = options[0]
+    if not first:
+        raise TypeError('%s does not exists' % first)
+    return first
+
+
+def path(path):
+    split = sys.argv[0].split('lib/exabgp')
+    if len(split) > 1:
+        prefix = os.sep.join(split[:1])
+        if prefix and path.startswith(prefix):
+            path = path[len(prefix) :]
+    home = os.path.expanduser('~')
+    if path.startswith(home):
+        return "'~%s'" % path[len(home) :]
+    return "'%s'" % path
+
+
+def conf(path):
+    first = environment.folder(path)
+    if not os.path.isfile(first):
+        raise TypeError('%s is not a file' % path)
+    return first
+
+
+def exe(path):
+    first = conf(path)
+    if not os.access(first, os.X_OK):
+        raise TypeError('%s is not an executable' % first)
+    return first
+
+
+# def syslog(path):
+#     path = unquote(path)
+#     if path in ('stdout', 'stderr'):
+#         return path
+#     if path.startswith('host:'):
+#         return path
+#     return path
+
+
+def umask_read(_):
+    return int(_, 8)
+
+
+def umask_write(_):
+    return "'%s'" % (oct(_))
+
+
+def syslog_value(log):
+    if log not in log_levels:
+        if log == 'CRITICAL':
+            log = 'CRIT'
+        if log == 'ERROR':
+            log = 'ERR'
+        raise TypeError('invalid log level %s' % log)
+    return getattr(syslog, 'LOG_%s' % log)
+
+
+def syslog_name(log):
+    for name in log_levels:
+        if name == 'CRITICAL':
+            name = 'CRIT'
+        if name == 'ERROR':
+            name = 'ERR'
+        if getattr(syslog, 'LOG_%s' % name) == log:
+            return name
+    raise TypeError('invalid log level %s' % log)
+
+
+def root(path):
+    roots = base.root.split(os.sep)
+    location = []
+    for index in range(len(roots) - 1, -1, -1):
+        if roots[index] == 'lib':
+            if index:
+                location = roots[:index]
+            break
+    root = os.path.join(*location)
+    paths = [
+        os.path.normpath(os.path.join(os.path.join(os.sep, root, path))),
+        os.path.normpath(os.path.expanduser(unquote(path))),
+        os.path.normpath(os.path.join('/', path)),
+    ]
+    return paths
diff --git a/lib/exabgp/configuration/setup.py b/lib/exabgp/environment/setup.py
similarity index 61%
rename from lib/exabgp/configuration/setup.py
rename to lib/exabgp/environment/setup.py
index eb4b05896..00c51a8a7 100644
--- a/lib/exabgp/configuration/setup.py
+++ b/lib/exabgp/environment/setup.py
@@ -7,11 +7,14 @@
 License: 3-clause BSD. (See the COPYRIGHT file)
 """
 
-from exabgp.configuration.environment import environment
+
+from exabgp.environment import parsing
+from exabgp.environment.environment import Env
+
 
 _SPACE = {'space': ' ' * 33}
 
-HELP_STDOUT = (
+LOGGING_HELP_STDOUT = (
     """\
 where logging should log
 %(space)s syslog (or no setting) sends the data to the local syslog syslog
@@ -23,258 +26,267 @@
 )
 
 
-environment.application = 'exabgp'
-environment.configuration = {
+CONFIGURATION = {
     'profile': {
         'enable': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'toggle profiling of the code',
         },
         'file': {
-            'read': environment.unquote,
-            'write': environment.quote,
+            'read': parsing.unquote,
+            'write': parsing.quote,
             'value': '',
             'help': 'profiling result file, none means stdout, no overwriting',
         },
     },
     'pdb': {
         'enable': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'on program fault, start pdb the python interactive debugger',
         }
     },
     'daemon': {
         'pid': {
-            'read': environment.unquote,
-            'write': environment.quote,
+            'read': parsing.unquote,
+            'write': parsing.quote,
             'value': '',
             'help': 'where to save the pid if we manage it',
         },
-        'user': {'read': environment.user, 'write': environment.quote, 'value': 'nobody', 'help': 'user to run as',},
+        'user': {
+            'read': parsing.user,
+            'write': parsing.quote,
+            'value': 'nobody',
+            'help': 'user to run the program as',
+        },
         'daemonize': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'should we run in the background',
         },
         'drop': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'drop privileges before forking processes',
         },
         'umask': {
-            'read': environment.umask_read,
-            'write': environment.umask_write,
+            'read': parsing.umask_read,
+            'write': parsing.umask_write,
             'value': '0137',
             'help': 'run daemon with this umask, governs perms of logfiles etc.',
         },
     },
     'log': {
-        'enable': {'read': environment.boolean, 'write': environment.lower, 'value': 'true', 'help': 'enable logging',},
+        'enable': {
+            'read': parsing.boolean,
+            'write': parsing.lower,
+            'value': 'true',
+            'help': 'enable logging to file or syslog',
+        },
         'level': {
-            'read': environment.syslog_value,
-            'write': environment.syslog_name,
+            'read': parsing.syslog_value,
+            'write': parsing.syslog_name,
             'value': 'INFO',
             'help': 'log message with at least the priority SYSLOG.<level>',
         },
         'destination': {
-            'read': environment.unquote,
-            'write': environment.quote,
+            'read': parsing.unquote,
+            'write': parsing.quote,
             'value': 'stdout',
-            'help': HELP_STDOUT,
+            'help': LOGGING_HELP_STDOUT,
         },
         'all': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report debug information for everything',
         },
         'configuration': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'report command parsing',
         },
         'reactor': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'report signal received, command reload',
         },
         'daemon': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'report pid change, forking, ...',
         },
         'processes': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'report handling of forked processes',
         },
         'network': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'report networking information (TCP/IP, network state,...)',
         },
         'packets': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report BGP packets sent and received',
         },
         'rib': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report change in locally configured routes',
         },
         'message': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report changes in route announcement on config reload',
         },
         'timers': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report keepalives timers',
         },
         'routes': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report received routes',
         },
         'parser': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'report BGP message parsing details',
         },
         'short': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'use short log format (not prepended with time,level,pid and source)',
         },
     },
     'tcp': {
         'once': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'only one tcp connection attempt per peer (for debuging scripts)',
         },
         'delay': {
-            'read': environment.integer,
-            'write': environment.nop,
+            'read': parsing.integer,
+            'write': parsing.nop,
             'value': '0',
             'help': 'start to announce route when the minutes in the hours is a modulo of this number',
         },
         'bind': {
-            'read': environment.ip_list,
-            'write': environment.quote_list,
+            'read': parsing.ip_list,
+            'write': parsing.quote_list,
             'value': '',
             'help': 'Space separated list of IPs to bind on when listening (no ip to disable)',
         },
         'port': {
-            'read': environment.integer,
-            'write': environment.nop,
+            'read': parsing.integer,
+            'write': parsing.nop,
             'value': '179',
             'help': 'port to bind on when listening',
         },
         'acl': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': '',
-            'help': '(experimental) unimplemented',
+            'help': '(experimental please do not use) unimplemented',
         },
     },
     'bgp': {
         'openwait': {
-            'read': environment.integer,
-            'write': environment.nop,
+            'read': parsing.integer,
+            'write': parsing.nop,
             'value': '60',
             'help': 'how many second we wait for an open once the TCP session is established',
         },
     },
     'cache': {
         'attributes': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'cache all attributes (configuration and wire) for faster parsing',
         },
         'nexthops': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'cache routes next-hops (deprecated: next-hops are always cached)',
         },
     },
     'api': {
         'ack': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'acknowledge api command(s) and report issues',
         },
         'chunk': {
-            'read': environment.integer,
-            'write': environment.nop,
+            'read': parsing.integer,
+            'write': parsing.nop,
             'value': '1',
             'help': 'maximum lines to print before yielding in show routes api',
         },
         'encoder': {
-            'read': environment.api,
-            'write': environment.lower,
+            'read': parsing.api,
+            'write': parsing.lower,
             'value': 'json',
             'help': '(experimental) default encoder to use with with external API (text or json)',
         },
         'compact': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'shorter JSON encoding for IPv4/IPv6 Unicast NLRI',
         },
         'respawn': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'should we try to respawn helper processes if they dies',
         },
         'terminate': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'should we terminate ExaBGP if any helper process dies',
         },
         'cli': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'true',
             'help': 'should we create a named pipe for the cli',
         },
         'pipename': {
-            'read': environment.unquote,
-            'write': environment.quote,
+            'read': parsing.unquote,
+            'write': parsing.quote,
             'value': 'exabgp',
             'help': 'name to be used for the exabgp pipe',
         },
     },
     'reactor': {
         'speed': {
-            'read': environment.real,
-            'write': environment.nop,
+            'read': parsing.real,
+            'write': parsing.nop,
             'value': '1.0',
             'help': 'reactor loop time\n%(space)s use only if you understand the code.' % _SPACE,
         },
@@ -282,46 +294,49 @@
     # Here for internal use
     'debug': {
         'pdb': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'enable python debugger on errors',
         },
         'memory': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'command line option --memory',
         },
         'configuration': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'undocumented option: raise when parsing configuration errors',
         },
         'selfcheck': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'does a self check on the configuration file',
         },
         'route': {
-            'read': environment.unquote,
-            'write': environment.quote,
+            'read': parsing.unquote,
+            'write': parsing.quote,
             'value': '',
             'help': 'decode the route using the configuration',
         },
         'defensive': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'generate random fault in the code in purpose',
         },
         'rotate': {
-            'read': environment.boolean,
-            'write': environment.lower,
+            'read': parsing.boolean,
+            'write': parsing.lower,
             'value': 'false',
             'help': 'rotate configurations file on reload (signal)',
         },
     },
 }
+
+# load the environment
+Env.setup(CONFIGURATION)
diff --git a/lib/exabgp/logger.py b/lib/exabgp/logger.py
index 41a1cf288..ffc32441f 100644
--- a/lib/exabgp/logger.py
+++ b/lib/exabgp/logger.py
@@ -20,7 +20,8 @@
 from collections import deque
 
 from exabgp.util.od import od
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
+from exabgp.environment import APPLICATION
 
 
 def _can_write(location):
@@ -174,33 +175,33 @@ def _record(self, timestamp, message, source, level):
     def __init__(self):
         if self._instance.get('class', None) is not None:
             return
-
         self._instance['class'] = self
 
-        command = environment.settings()
-        self.short = command.log.short
-        self.level = command.log.level
+        env = getenv()
+
+        self.short = env.log.short
+        self.level = env.log.level
 
         self._option = {
-            'pdb': command.debug.pdb,
-            'reactor': command.log.enable and (command.log.all or command.log.reactor),
-            'daemon': command.log.enable and (command.log.all or command.log.daemon),
-            'processes': command.log.enable and (command.log.all or command.log.processes),
-            'configuration': command.log.enable and (command.log.all or command.log.configuration),
-            'network': command.log.enable and (command.log.all or command.log.network),
-            'wire': command.log.enable and (command.log.all or command.log.packets),
-            'message': command.log.enable and (command.log.all or command.log.message),
-            'rib': command.log.enable and (command.log.all or command.log.rib),
-            'timer': command.log.enable and (command.log.all or command.log.timers),
-            'routes': command.log.enable and (command.log.all or command.log.routes),
-            'parser': command.log.enable and (command.log.all or command.log.parser),
+            'pdb': env.debug.pdb,
+            'reactor': env.log.enable and (env.log.all or env.log.reactor),
+            'daemon': env.log.enable and (env.log.all or env.log.daemon),
+            'processes': env.log.enable and (env.log.all or env.log.processes),
+            'configuration': env.log.enable and (env.log.all or env.log.configuration),
+            'network': env.log.enable and (env.log.all or env.log.network),
+            'wire': env.log.enable and (env.log.all or env.log.packets),
+            'message': env.log.enable and (env.log.all or env.log.message),
+            'rib': env.log.enable and (env.log.all or env.log.rib),
+            'timer': env.log.enable and (env.log.all or env.log.timers),
+            'routes': env.log.enable and (env.log.all or env.log.routes),
+            'parser': env.log.enable and (env.log.all or env.log.parser),
         }
 
-        if not command.log.enable:
+        if not env.log.enable:
             self.destination = ''
             return
 
-        self.destination = command.log.destination
+        self.destination = env.log.destination
 
         self.restart(True)
 
@@ -317,7 +318,7 @@ def _format(self, message, source, level, timestamp=None):
         elif self._where in [
             'syslog',
         ]:
-            return "%s[%d]: %-13s %s" % (environment.application, self._pid, source, message)
+            return "%s[%d]: %-13s %s" % (APPLICATION, self._pid, source, message)
         elif self._where in [
             'file',
         ]:
diff --git a/lib/exabgp/reactor/api/command/rib.py b/lib/exabgp/reactor/api/command/rib.py
index 352918c48..df50f3107 100644
--- a/lib/exabgp/reactor/api/command/rib.py
+++ b/lib/exabgp/reactor/api/command/rib.py
@@ -17,7 +17,7 @@
 from exabgp.bgp.message.update.nlri.vpls import VPLS
 from exabgp.bgp.message.update.nlri.evpn.nlri import EVPN
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 
 def register_rib():
@@ -26,7 +26,7 @@ def register_rib():
 
 def _show_adjrib_callback(reactor, service, last, route_type, advertised, rib_name, extensive):
     def callback():
-        lines_per_yield = environment.settings().api.chunk
+        lines_per_yield = getenv().api.chunk
         if last in ('routes', 'extensive', 'static', 'flow', 'l2vpn'):
             peers = reactor.peers()
         else:
diff --git a/lib/exabgp/reactor/api/processes.py b/lib/exabgp/reactor/api/processes.py
index 8db02cae4..3cdf06cc7 100644
--- a/lib/exabgp/reactor/api/processes.py
+++ b/lib/exabgp/reactor/api/processes.py
@@ -26,7 +26,7 @@
 from exabgp.version import json as json_version
 from exabgp.version import text as text_version
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 from threading import Thread
 
 
@@ -60,9 +60,9 @@ def __init__(self):
         self._configuration = {}
         self._restart = {}
 
-        self.respawn_number = 5 if environment.settings().api.respawn else 0
-        self.terminate_on_error = environment.settings().api.terminate
-        self.ack = environment.settings().api.ack
+        self.respawn_number = 5 if getenv().api.respawn else 0
+        self.terminate_on_error = getenv().api.terminate
+        self.ack = getenv().api.ack
 
     def number(self):
         return len(self._process)
diff --git a/lib/exabgp/reactor/api/response/json.py b/lib/exabgp/reactor/api/response/json.py
index 0c7e29a45..eb2293bcc 100755
--- a/lib/exabgp/reactor/api/response/json.py
+++ b/lib/exabgp/reactor/api/response/json.py
@@ -19,7 +19,7 @@
 from exabgp.bgp.message import Message
 from exabgp.bgp.message import IN
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 from exabgp.bgp.message.open.capability.refresh import REFRESH
 
 
@@ -38,7 +38,7 @@ class JSON(object):
     def __init__(self, version):
         self.version = version
         self.time = nop
-        self.compact = environment.settings().api.compact
+        self.compact = getenv().api.compact
 
     # def _reset (self, neighbor):
     # 	self._count[neighbor.uid] = 0
diff --git a/lib/exabgp/reactor/daemon.py b/lib/exabgp/reactor/daemon.py
index cdfefb17d..a3eca73a0 100644
--- a/lib/exabgp/reactor/daemon.py
+++ b/lib/exabgp/reactor/daemon.py
@@ -13,7 +13,7 @@
 import errno
 import socket
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 from exabgp.logger import Logger
 
@@ -22,10 +22,10 @@
 
 class Daemon(object):
     def __init__(self, reactor):
-        self.pid = environment.settings().daemon.pid
-        self.user = environment.settings().daemon.user
-        self.daemonize = environment.settings().daemon.daemonize
-        self.umask = environment.settings().daemon.umask
+        self.pid = getenv().daemon.pid
+        self.user = getenv().daemon.user
+        self.daemonize = getenv().daemon.daemonize
+        self.umask = getenv().daemon.umask
 
         self.logger = Logger()
 
@@ -171,7 +171,7 @@ def daemonise(self):
         if not self.daemonize:
             return
 
-        log = environment.settings().log
+        log = getenv().log
         if log.enable and log.destination.lower() in ('stdout', 'stderr'):
             self.logger.critical('ExaBGP can not fork when logs are going to %s' % log.destination.lower(), 'daemon')
             return
diff --git a/lib/exabgp/reactor/loop.py b/lib/exabgp/reactor/loop.py
index e532d3491..14d36705c 100644
--- a/lib/exabgp/reactor/loop.py
+++ b/lib/exabgp/reactor/loop.py
@@ -24,7 +24,7 @@
 
 from exabgp.reactor.api import API
 from exabgp.configuration.configuration import Configuration
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 from exabgp.bgp.fsm import FSM
 
@@ -51,16 +51,16 @@ class Exit(object):
     clear = b''.join(bytes([int(c, 16)]) for c in ['0x1b', '0x5b', '0x48', '0x1b', '0x5b', '0x32', '0x4a'])
 
     def __init__(self, configurations):
-        self._ips = environment.settings().tcp.bind
-        self._port = environment.settings().tcp.port
-        self._stopping = environment.settings().tcp.once
+        self._ips = getenv().tcp.bind
+        self._port = getenv().tcp.port
+        self._stopping = getenv().tcp.once
         self.exit_code = self.Exit.unknown
 
-        self.max_loop_time = environment.settings().reactor.speed
+        self.max_loop_time = getenv().reactor.speed
         self._sleep_time = self.max_loop_time / 100
         self._busyspin = {}
         self._ratelimit = {}
-        self.early_drop = environment.settings().daemon.drop
+        self.early_drop = getenv().daemon.drop
 
         self.processes = None
 
@@ -291,7 +291,7 @@ def run(self, validate, root):
         # did we complete the run of updates caused by the last SIGUSR1/SIGUSR2 ?
         reload_completed = False
 
-        wait = environment.settings().tcp.delay
+        wait = getenv().tcp.delay
         if wait:
             sleeptime = (wait * 60) - int(time.time()) % (wait * 60)
             self.logger.debug('waiting for %d seconds before connecting' % sleeptime, 'reactor')
diff --git a/lib/exabgp/reactor/network/connection.py b/lib/exabgp/reactor/network/connection.py
index 8d00eb997..eb760c860 100644
--- a/lib/exabgp/reactor/network/connection.py
+++ b/lib/exabgp/reactor/network/connection.py
@@ -12,7 +12,7 @@
 import select
 from struct import unpack
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 from exabgp.util.errstr import errstr
 
@@ -44,7 +44,7 @@ def __init__(self, afi, peer, local):
 
         # peer and local are strings of the IP
         try:
-            self.defensive = environment.settings().debug.defensive
+            self.defensive = getenv().debug.defensive
             self.logger = Logger()
         except RuntimeError:
             self.defensive = True
diff --git a/lib/exabgp/reactor/peer.py b/lib/exabgp/reactor/peer.py
index 8a19a4608..083ad54dc 100644
--- a/lib/exabgp/reactor/peer.py
+++ b/lib/exabgp/reactor/peer.py
@@ -29,7 +29,7 @@
 
 from exabgp.rib.change import Change
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 from exabgp.logger import Logger
 from exabgp.logger import FakeLogger
 from exabgp.logger import LazyFormat
@@ -78,8 +78,8 @@ def __init__(self, neighbor, reactor):
         try:
             self.logger = Logger()
             # We only to try to connect via TCP once
-            self.once = environment.settings().tcp.once
-            self.bind = True if environment.settings().tcp.bind else False
+            self.once = getenv().tcp.once
+            self.bind = True if getenv().tcp.bind else False
         except RuntimeError:
             self.logger = FakeLogger()
             self.once = False
@@ -308,7 +308,7 @@ def _send_open(self):
         yield message
 
     def _read_open(self):
-        wait = environment.settings().bgp.openwait
+        wait = getenv().bgp.openwait
         opentimer = ReceiveTimer(
             self.proto.connection.session, wait, 1, 1, 'waited for open too long, we do not like stuck in active'
         )
diff --git a/lib/exabgp/reactor/protocol.py b/lib/exabgp/reactor/protocol.py
index 1e8063fae..76892c014 100644
--- a/lib/exabgp/reactor/protocol.py
+++ b/lib/exabgp/reactor/protocol.py
@@ -72,9 +72,9 @@ def __init__(self, peer):
         else:
             self.port = 179
 
-        from exabgp.configuration.environment import environment
+        from exabgp.environment import getenv
 
-        self.log_routes = peer.neighbor.adj_rib_in or environment.settings().log.routes
+        self.log_routes = peer.neighbor.adj_rib_in or getenv().log.routes
 
     def fd(self):
         if self.connection is None:
diff --git a/lib/exabgp/util/hashtable.py b/lib/exabgp/util/hashtable.py
deleted file mode 100644
index 86a680e7e..000000000
--- a/lib/exabgp/util/hashtable.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# encoding: utf-8
-"""
-hashtable.py
-
-Created by Thomas Mangin on 2009-09-06.
-Copyright (c) 2009-2017 Exa Networks. All rights reserved.
-License: 3-clause BSD. (See the COPYRIGHT file)
-"""
-
-
-class HashTable(dict):
-    def __getitem__(self, key):
-        return dict.__getitem__(self, key.replace('_', '-'))
-
-    def __setitem__(self, key, value):
-        return dict.__setitem__(self, key.replace('_', '-'), value)
-
-    def __getattr__(self, key):
-        return dict.__getitem__(self, key.replace('_', '-'))
-
-    def __setattr__(self, key, value):
-        return dict.__setitem__(self, key.replace('_', '-'), value)
diff --git a/qa/tests/datatype.py b/qa/tests/datatype.py
index ca4d87e51..2fefef82b 100755
--- a/qa/tests/datatype.py
+++ b/qa/tests/datatype.py
@@ -10,7 +10,7 @@
 
 import unittest
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 environment.setup('')
 
diff --git a/qa/tests/flow_test.py b/qa/tests/flow_test.py
index 187a50864..6e15c4f62 100755
--- a/qa/tests/flow_test.py
+++ b/qa/tests/flow_test.py
@@ -21,7 +21,7 @@
 
 from exabgp.protocol.ip import IPv4
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 environment.setup('')
 
diff --git a/qa/tests/open_test.py b/qa/tests/open_test.py
index 134be5a88..57ecee49f 100755
--- a/qa/tests/open_test.py
+++ b/qa/tests/open_test.py
@@ -23,7 +23,7 @@
 from exabgp.bgp.message.open.capability import Capabilities
 from exabgp.bgp.message.open.capability import RouteRefresh
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 environment.setup('')
 
diff --git a/qa/tests/protocol.py b/qa/tests/protocol.py
index 58c4da050..5d508938b 100755
--- a/qa/tests/protocol.py
+++ b/qa/tests/protocol.py
@@ -25,7 +25,7 @@
 from exabgp.reactor.protocol import Protocol
 from exabgp.bgp.neighbor import Neighbor
 
-from exabgp.configuration.environment import environment
+from exabgp.environment import getenv
 
 environment.setup('')
 
diff --git a/requirements.txt b/requirements.txt
index 9a6357475..b07dace2f 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,2 +1 @@
 # ExaBGP dependencies are included in its code tree
-# it uses docopt
diff --git a/sbin/exabgp b/sbin/exabgp
index bcec4b4c1..0b7d9b70e 100755
--- a/sbin/exabgp
+++ b/sbin/exabgp
@@ -15,6 +15,7 @@ fi
 
 path="$(cd "$(dirname "$0")"/.. ; pwd)"
 
+export EXABGP_ROOT=$path
 export PYTHONPATH="$path"/lib
 
 # Prefer `python` binary when in a venv
@@ -38,9 +39,9 @@ import os
 
 path = [os.path.join(_,'exabgp')
         for _ in sys.path
-        if os.path.isfile('/'.join((_, 'exabgp', 'application', 'bgp.py')))][0]
+        if os.path.isfile('/'.join((_, 'exabgp', 'application', 'main.py')))][0]
 
-print(os.path.join(path,'application','bgp.py'))
+print(os.path.join(path,'application','main.py'))
 
 def remove (file):
     try: os.remove(file)
@@ -51,4 +52,4 @@ if 'exabgp' not in os.environ.get('SKIPCLEANUP',''):
 
 ")"
 
-exec "$INTERPRETER" "$APPLICATION" --root "$path" "$@"
+exec "$INTERPRETER" "$APPLICATION" "$@"