diff --git a/pylint/__init__.py b/pylint/__init__.py
index c3a924a45a..9d6f28a053 100644
--- a/pylint/__init__.py
+++ b/pylint/__init__.py
@@ -13,9 +13,9 @@
 
 def run_pylint():
     """run pylint"""
-    from pylint.lint import Run
+    from pylint.lint import CLIRunner
     try:
-        Run(sys.argv[1:])
+        CLIRunner().run(sys.argv[1:])
     except KeyboardInterrupt:
         sys.exit(1)
 
diff --git a/pylint/checkers/__init__.py b/pylint/checkers/__init__.py
index 4cc60d60a2..fe471bcbb0 100644
--- a/pylint/checkers/__init__.py
+++ b/pylint/checkers/__init__.py
@@ -42,7 +42,6 @@
 import tokenize
 import warnings
 
-from pylint.config import OptionsProviderMixIn
 from pylint.reporters import diff_string
 from pylint.utils import register_plugins
 from pylint.interfaces import UNDEFINED
@@ -69,7 +68,7 @@ def table_lines_from_stats(stats, old_stats, columns):
     return lines
 
 
-class BaseChecker(OptionsProviderMixIn):
+class BaseChecker(object):
     """base class for checkers"""
     # checker name (you may reuse an existing one)
     name = None
@@ -84,13 +83,9 @@ class BaseChecker(OptionsProviderMixIn):
     # mark this checker as enabled or not.
     enabled = True
 
-    def __init__(self, linter=None):
-        """checker instances should have the linter as argument
+    priority = -1
 
-        linter is an object implementing ILinter
-        """
-        self.name = self.name.lower()
-        OptionsProviderMixIn.__init__(self)
+    def __init__(self, linter=None):
         self.linter = linter
 
     def add_message(self, msg_id, line=None, node=None, args=None, confidence=UNDEFINED,
@@ -115,8 +110,13 @@ def process_tokens(self, tokens):
         raise NotImplementedError()
 
 
-def initialize(linter):
-    """initialize linter with checkers in this package """
-    register_plugins(linter, __path__[0])
+def initialize(registry):
+    """Register the checkers in this package.
+
+    :param registry: The registry to register checkers with.
+    :type registry: PluginRegistry
+    """
+    register_plugins(registry, __path__[0])
+
 
 __all__ = ('BaseChecker', 'initialize')
diff --git a/pylint/config.py b/pylint/config.py
index fff6ebcbbd..388fd4916d 100644
--- a/pylint/config.py
+++ b/pylint/config.py
@@ -30,16 +30,11 @@
 
 import abc
 import argparse
-import contextlib
 import collections
-import copy
-import functools
-import io
 import os
 import pickle
 import re
 import sys
-import time
 
 import configparser
 import six
@@ -125,10 +120,10 @@ def find_nearby_pylintrc(search_dir=''):
     path = find_pylintrc_in(search_dir)
 
     if not path:
-        for search_dir in utils.walk_up(search_dir):
-            if not os.path.isfile(os.path.join(search_dir, '__init__.py')):
+        for cur_dir in utils.walk_up(search_dir):
+            if not os.path.isfile(os.path.join(cur_dir, '__init__.py')):
                 break
-            path = find_pylintrc_in(search_dir)
+            path = find_pylintrc_in(cur_dir)
             if path:
                 break
 
@@ -195,51 +190,22 @@ class UnsupportedAction(Exception):
     """raised by set_option when it doesn't know what to do for an action"""
 
 
-def _multiple_choice_validator(choices, name, value):
-    values = utils._check_csv(value)
-    for csv_value in values:
-        if csv_value not in choices:
-            msg = "option %s: invalid value: %r, should be in %s"
-            raise argparse.ArgumentError(msg % (name, csv_value, choices))
-    return values
-
-
-def _choice_validator(choices, name, value):
-    if value not in choices:
-        msg = "option %s: invalid value: %r, should be in %s"
-        raise argparse.ArgumentError(msg % (name, value, choices))
-    return value
-
-# pylint: disable=unused-argument
-def _csv_validator(_, name, value):
-    return utils._check_csv(value)
-
-
-# pylint: disable=unused-argument
-def _regexp_validator(_, name, value):
-    if hasattr(value, 'pattern'):
-        return value
-    return re.compile(value)
+def _regexp_csv_validator(value):
+    return [re.compile(val) for val in utils._check_csv(value)]
 
-# pylint: disable=unused-argument
-def _regexp_csv_validator(_, name, value):
-    return [_regexp_validator(_, name, val) for val in _csv_validator(_, name, value)]
-
-def _yn_validator(opt, _, value):
-    if isinstance(value, int):
-        return bool(value)
+def _yn_validator(value):
     if value in ('y', 'yes'):
         return True
     if value in ('n', 'no'):
         return False
-    msg = "option %s: invalid yn value %r, should be in (y, yes, n, no)"
-    raise argparse.ArgumentError(msg % (opt, value))
+    msg = "invalid yn value %r, should be in (y, yes, n, no)"
+    raise argparse.ArgumentTypeError(msg % (value,))
 
 
-def _non_empty_string_validator(opt, _, value):
+def _non_empty_string_validator(value):
     if not value:
         msg = "indent string can't be empty."
-        raise argparse.ArgumentError(msg)
+        raise argparse.ArgumentTypeError(msg)
     return utils._unquote(value)
 
 
@@ -248,443 +214,20 @@ def _non_empty_string_validator(opt, _, value):
     'int': int,
     'regexp': re.compile,
     'regexp_csv': _regexp_csv_validator,
-    'csv': _csv_validator,
+    'csv': utils._check_csv,
     'yn': _yn_validator,
-    'choice': lambda opt, name, value: _choice_validator(opt['choices'], name, value),
-    'multiple_choice': lambda opt, name, value: _multiple_choice_validator(opt['choices'],
-                                                                           name, value),
     'non_empty_string': _non_empty_string_validator,
 }
 
-def _call_validator(opttype, optdict, option, value):
-    if opttype not in VALIDATORS:
-        raise Exception('Unsupported type "%s"' % opttype)
-    try:
-        return VALIDATORS[opttype](optdict, option, value)
-    except TypeError:
-        try:
-            return VALIDATORS[opttype](value)
-        except Exception:
-            raise argparse.ArgumentError('%s value (%r) should be of type %s' %
-                                            (option, value, opttype))
-
-
-def _validate(value, optdict, name=''):
-    """return a validated value for an option according to its type
-
-    optional argument name is only used for error message formatting
-    """
-    try:
-        _type = optdict['type']
-    except KeyError:
-        # FIXME
-        return value
-    return _call_validator(_type, optdict, name, value)
-
-
-def _level_options(group, outputlevel):
-    return [option for option in group.option_list
-            if (getattr(option, 'level', 0) or 0) <= outputlevel
-            and option.help is not argparse.SUPPRESS]
-
-
-def _multiple_choices_validating_option(opt, name, value):
-    return _multiple_choice_validator(opt.choices, name, value)
-
-
-class OptionsManagerMixIn(object):
-    """Handle configuration from both a configuration file and command line options"""
-
-    class CallbackAction(argparse.Action):
-        """Doesn't store the value on the config."""
-        def __init__(self, nargs=None, **kwargs):
-            nargs = nargs or int('metavar' in kwargs)
-            super(OptionsManagerMixIn.CallbackAction, self).__init__(
-                nargs=nargs, **kwargs
-            )
-
-        def __call__(self, parser, namespace, values, option_string):
-            # If no value was passed, argparse didn't call the callback via
-            # `type`, so we need to do it ourselves.
-            if not self.nargs and callable(self.type):
-                self.type(self, option_string, values, parser)
-
-    def __init__(self, usage, config_file=None, version=None, quiet=0):
-        self.config_file = config_file
-        self.reset_parsers(usage, version=version)
-        # list of registered options providers
-        self.options_providers = []
-        # dictionary associating option name to checker
-        self._all_options = collections.OrderedDict()
-        self._short_options = {}
-        self._nocallback_options = {}
-        self._mygroups = {}
-        # verbosity
-        self.quiet = quiet
-        self._maxlevel = 0
-
-    def reset_parsers(self, usage='', version=None):
-        # configuration file parser
-        self.cfgfile_parser = IniFileParser()
-        # command line parser
-        self.cmdline_parser = CLIParser(usage)
-
-    def register_options_provider(self, provider, own_group=True):
-        """register an options provider"""
-        assert provider.priority <= 0, "provider's priority can't be >= 0"
-        for i in range(len(self.options_providers)):
-            if provider.priority > self.options_providers[i].priority:
-                self.options_providers.insert(i, provider)
-                break
-        else:
-            self.options_providers.append(provider)
-        non_group_spec_options = [option for option in provider.options
-                                  if 'group' not in option[1]]
-        groups = getattr(provider, 'option_groups', ())
-        if own_group and non_group_spec_options:
-            self.add_option_group(provider.name.upper(), provider.__doc__,
-                                  non_group_spec_options, provider)
-        else:
-            for opt, optdict in non_group_spec_options:
-                self.add_optik_option(provider, self.cmdline_parser, opt, optdict)
-        for gname, gdoc in groups:
-            gname = gname.upper()
-            goptions = [option for option in provider.options
-                        if option[1].get('group', '').upper() == gname]
-            self.add_option_group(gname, gdoc, goptions, provider)
-
-    def add_option_group(self, group_name, _, options, provider):
-        # add option group to the command line parser
-        if group_name in self._mygroups:
-            group = self._mygroups[group_name]
-        else:
-            group = self.cmdline_parser._parser.add_argument_group(
-                group_name.capitalize(), level=provider.level,
-            )
-            self._mygroups[group_name] = group
-            # add section to the config file
-            if group_name != "DEFAULT":
-                try:
-                    self.cfgfile_parser._parser.add_section(group_name)
-                except configparser.DuplicateSectionError:
-                    pass
-
-        # add provider's specific options
-        for opt, optdict in options:
-            self.add_optik_option(provider, group, opt, optdict)
-
-    def add_optik_option(self, provider, optikcontainer, opt, optdict):
-        args, optdict = self.optik_option(provider, opt, optdict)
-        if hasattr(optikcontainer, '_parser'):
-            optikcontainer = optikcontainer._parser
-        if 'group' in optdict:
-            optikcontainer = self._mygroups[optdict['group'].upper()]
-            del optdict['group']
-
-        # Some sanity checks for things that trip up argparse
-        assert not any(' ' in arg for arg in args)
-        assert all(optdict.values())
-        assert not ('metavar' in optdict and '[' in optdict['metavar'])
-
-        level = optdict.pop('level', 0)
-        option = optikcontainer.add_argument(*args, **optdict)
-        option.level = level
-        self._all_options[opt] = provider
-        self._maxlevel = max(self._maxlevel, optdict.get('level', 0))
-
-    def optik_option(self, provider, opt, optdict):
-        """get our personal option definition and return a suitable form for
-        use with optik/argparse
-        """
-        # TODO: Changed to work with argparse but this should call
-        # self.cmdline_parser.add_argument_definitions and not use callbacks
-        optdict = copy.copy(optdict)
-        if 'action' in optdict:
-            self._nocallback_options[provider] = opt
-            if optdict['action'] == 'callback':
-                optdict['type'] = optdict['callback']
-                optdict['action'] = self.CallbackAction
-                del optdict['callback']
-        else:
-            callback = functools.partial(
-                self.cb_set_provider_option, None, '--' + str(opt), parser=None,
-            )
-            optdict['type'] = callback
-            optdict.setdefault('action', 'store')
-        # default is handled here and *must not* be given to optik if you
-        # want the whole machinery to work
-        if 'default' in optdict:
-            if ('help' in optdict
-                    and optdict.get('default') is not None
-                    and optdict['action'] not in ('store_true', 'store_false')):
-                default = optdict['default']
-                if isinstance(default, (tuple, list)):
-                    default = ','.join(str(x) for x in default)
-                optdict['help'] += ' [current: {0}]'.format(default)
-            del optdict['default']
-        args = ['--' + str(opt)]
-        if 'short' in optdict:
-            self._short_options[optdict['short']] = opt
-            args.append('-' + optdict['short'])
-            del optdict['short']
-        if optdict.get('action') == 'callback':
-            optdict['type'] = optdict['callback']
-            del optdict['action']
-            del optdict['callback']
-        if optdict.get('hide'):
-            optdict['help'] = argparse.SUPPRESS
-            del optdict['hide']
-        return args, optdict
-
-    def cb_set_provider_option(self, option, opt, value, parser):
-        """optik callback for option setting"""
-        if opt.startswith('--'):
-            # remove -- on long option
-            opt = opt[2:]
-        else:
-            # short option, get its long equivalent
-            opt = self._short_options[opt[1:]]
-        # trick since we can't set action='store_true' on options
-        if value is None:
-            value = 1
-        self.global_set_option(opt, value)
-        return value
-
-    def global_set_option(self, opt, value):
-        """set option on the correct option provider"""
-        self._all_options[opt].set_option(opt, value)
-
-    def generate_config(self, stream=None, skipsections=(), encoding=None):
-        """write a configuration file according to the current configuration
-        into the given stream or stdout
-        """
-        options_by_section = {}
-        sections = []
-        for provider in self.options_providers:
-            for section, options in provider.options_by_section():
-                if section is None:
-                    section = provider.name
-                if section in skipsections:
-                    continue
-                options = [(n, d, v) for (n, d, v) in options
-                           if d.get('type') is not None
-                           and not d.get('deprecated')]
-                if not options:
-                    continue
-                if section not in sections:
-                    sections.append(section)
-                alloptions = options_by_section.setdefault(section, [])
-                alloptions += options
-        stream = stream or sys.stdout
-        encoding = utils._get_encoding(encoding, stream)
-        printed = False
-        for section in sections:
-            if printed:
-                print('\n', file=stream)
-            utils.format_section(stream, section.upper(),
-                                 sorted(options_by_section[section]),
-                                 encoding)
-            printed = True
-
-    def generate_manpage(self, pkginfo, section=1, stream=None):
-        # TODO
-        raise NotImplementedError
-
-    def load_provider_defaults(self):
-        """initialize configuration using default values"""
-        for provider in self.options_providers:
-            provider.load_defaults()
-
-    def read_config_file(self, config_file=None):
-        """read the configuration file but do not load it (i.e. dispatching
-        values to each options provider)
-        """
-        if config_file is None:
-            config_file = self.config_file
-        if config_file is not None:
-            config_file = os.path.expanduser(config_file)
-            if not os.path.exists(config_file):
-                raise IOError("The config file {:s} doesn't exist!".format(config_file))
-
-        use_config_file = config_file and os.path.exists(config_file)
-        if use_config_file:
-            self.cfgfile_parser.parse(config_file, Configuration())
-
-        if self.quiet:
-            return
-
-        if use_config_file:
-            msg = 'Using config file {0}'.format(os.path.abspath(config_file))
-        else:
-            msg = 'No config file found, using default configuration'
-        print(msg, file=sys.stderr)
-
-    def load_config_file(self):
-        """dispatch values previously read from a configuration file to each
-        options provider)
-        """
-        for section in self.cfgfile_parser._parser.sections():
-            for option, value in self.cfgfile_parser._parser.items(section):
-                try:
-                    self.global_set_option(option, value)
-                except (KeyError, argparse.ArgumentError):
-                    # TODO handle here undeclared options appearing in the config file
-                    continue
-
-    def load_configuration(self, **kwargs):
-        """override configuration according to given parameters"""
-        return self.load_configuration_from_config(kwargs)
-
-    def load_configuration_from_config(self, config):
-        for opt, opt_value in config.items():
-            opt = opt.replace('_', '-')
-            provider = self._all_options[opt]
-            provider.set_option(opt, opt_value)
-
-    def load_command_line_configuration(self, args=None):
-        """Override configuration according to command line parameters
-
-        return additional arguments
-        """
-        if args is None:
-            args = sys.argv[1:]
-        else:
-            args = list(args)
-        for provider in self._nocallback_options:
-            self.cmdline_parser.parse(args, provider.config)
-        config = Configuration()
-        self.cmdline_parser.parse(args, config)
-        return config.module_or_package
-
-    def add_help_section(self, title, description, level=0):
-        """add a dummy option section for help purpose """
-        group = self.cmdline_parser._parser.add_argument_group(
-            title.capitalize(), description, level=level
-        )
-        self._maxlevel = max(self._maxlevel, level)
-
-    def help(self, level=0):
-        """return the usage string for available options """
-        return self.cmdline_parser._parser.format_help(level)
-
-
-class OptionsProviderMixIn(object):
-    """Mixin to provide options to an OptionsManager"""
-
-    # those attributes should be overridden
-    priority = -1
-    name = 'default'
-    options = ()
-    level = 0
-
-    def __init__(self):
-        self.config = Configuration()
-        self.load_defaults()
-
-    def load_defaults(self):
-        """initialize the provider using default values"""
-        for opt, optdict in self.options:
-            action = optdict.get('action')
-            if action != 'callback':
-                # callback action have no default
-                if optdict is None:
-                    optdict = self.get_option_def(opt)
-                default = optdict.get('default')
-                self.set_option(opt, default, action, optdict)
-
-    def option_attrname(self, opt, optdict=None):
-        """get the config attribute corresponding to opt"""
-        if optdict is None:
-            optdict = self.get_option_def(opt)
-        return optdict.get('dest', opt.replace('-', '_'))
-
-    def option_value(self, opt):
-        """get the current value for the given option"""
-        return getattr(self.config, self.option_attrname(opt), None)
-
-    def set_option(self, optname, value, action=None, optdict=None):
-        """method called to set an option (registered in the options list)"""
-        if optdict is None:
-            optdict = self.get_option_def(optname)
-        if value is not None:
-            value = _validate(value, optdict, optname)
-        if action is None:
-            action = optdict.get('action', 'store')
-        if action == 'store':
-            setattr(self.config, self.option_attrname(optname, optdict), value)
-        elif action in ('store_true', 'count'):
-            setattr(self.config, self.option_attrname(optname, optdict), 0)
-        elif action == 'store_false':
-            setattr(self.config, self.option_attrname(optname, optdict), 1)
-        elif action == 'append':
-            optname = self.option_attrname(optname, optdict)
-            _list = getattr(self.config, optname, None)
-            if _list is None:
-                if isinstance(value, (list, tuple)):
-                    _list = value
-                elif value is not None:
-                    _list = []
-                    _list.append(value)
-                setattr(self.config, optname, _list)
-            elif isinstance(_list, tuple):
-                setattr(self.config, optname, _list + (value,))
-            else:
-                _list.append(value)
-        elif action == 'callback':
-            optdict['callback'](None, optname, value, None)
-        else:
-            raise UnsupportedAction(action)
-
-    def get_option_def(self, opt):
-        """return the dictionary defining an option given its name"""
-        assert self.options
-        for option in self.options:
-            if option[0] == opt:
-                return option[1]
-        raise argparse.ArgumentError('no such option %s in section %r'
-                                   % (opt, self.name), opt)
-
-    def options_by_section(self):
-        """return an iterator on options grouped by section
-
-        (section, [list of (optname, optdict, optvalue)])
-        """
-        sections = {}
-        for optname, optdict in self.options:
-            sections.setdefault(optdict.get('group'), []).append(
-                (optname, optdict, self.option_value(optname)))
-        if None in sections:
-            yield None, sections.pop(None)
-        for section, options in sorted(sections.items()):
-            yield section.upper(), options
-
-    def options_and_values(self, options=None):
-        if options is None:
-            options = self.options
-        for optname, optdict in options:
-            yield (optname, optdict, self.option_value(optname))
-
-
-class ConfigurationMixIn(OptionsManagerMixIn, OptionsProviderMixIn):
-    """basic mixin for simple configurations which don't need the
-    manager / providers model
-    """
-    def __init__(self, *args, **kwargs):
-        if not args:
-            kwargs.setdefault('usage', '')
-        kwargs.setdefault('quiet', 1)
-        OptionsManagerMixIn.__init__(self, *args, **kwargs)
-        OptionsProviderMixIn.__init__(self)
-        if not getattr(self, 'option_groups', None):
-            self.option_groups = []
-            for _, optdict in self.options:
-                try:
-                    gdef = (optdict['group'].upper(), '')
-                except KeyError:
-                    continue
-                if gdef not in self.option_groups:
-                    self.option_groups.append(gdef)
-        self.register_options_provider(self, own_group=False)
+UNVALIDATORS = {
+    'string': str,
+    'int': str,
+    'regexp': lambda value: getattr(value, 'pattern', value),
+    'regexp_csv': (lambda value: ','.join(r.pattern for r in value)),
+    'csv': (lambda value: ','.join(value)),
+    'yn': (lambda value: 'y' if value else 'n'),
+    'non_empty_string': str,
+}
 
 
 OptionDefinition = collections.namedtuple(
@@ -700,14 +243,18 @@ def add_option(self, option_definition):
         name, definition = option_definition
         if name in self._option_definitions:
             raise exceptions.ConfigurationError('Option "{0}" already exists.')
-        self._option_definitions[name] = definition
 
+        self._option_definitions[name] = definition
+        if 'default' in definition:
+            dest = definition.get('dest', name)
+            self.set_option(dest, definition['default'])
 
     def add_options(self, option_definitions):
         for option_definition in option_definitions:
             self.add_option(option_definition)
 
     def set_option(self, option, value):
+        option = option.replace('-', '_')
         setattr(self, option, value)
 
     def copy(self):
@@ -729,8 +276,9 @@ def __iadd__(self, other):
         self._option_definitions.update(other._option_definitions)
 
         for option in other._option_definitions:
+            option = option.replace('-', '_')
             value = getattr(other, option)
-            setattr(result, option, value)
+            setattr(self, option, value)
 
         return self
 
@@ -801,7 +349,7 @@ def get_config_for(self, path):
             config = self.global_config.copy()
 
             parent_configs = self._get_parent_configs(path)
-            for parent_config in reversed(parent_configs):
+            for parent_config in reversed(list(parent_configs)):
                 config += parent_config
 
             self._cache['path'] = config
@@ -826,7 +374,7 @@ def add_option_definitions(self, option_definitions):
 
         for _, definition_dict in option_definitions:
             try:
-                group = optdict['group'].upper()
+                group = definition_dict['group'].upper()
             except KeyError:
                 continue
             else:
@@ -859,11 +407,12 @@ def __init__(self, usage=''):
         self._parser.add_argument('module_or_package', nargs=argparse.REMAINDER)
 
     def add_option_definitions(self, option_definitions):
+        self._option_definitions.update(option_definitions)
         option_groups = collections.defaultdict(list)
 
         for option, definition in option_definitions:
             group, args, kwargs = self._convert_definition(option, definition)
-            option_groups[group].append(args, kwargs)
+            option_groups[group].append((args, kwargs))
 
         for args, kwargs in option_groups['DEFAULT']:
             self._parser.add_argument(*args, **kwargs)
@@ -872,9 +421,9 @@ def add_option_definitions(self, option_definitions):
 
         for group, arguments in six.iteritems(option_groups):
             self._option_groups.add(group)
-            self._parser.add_argument_group(group.title())
+            group = self._parser.add_argument_group(group.title())
             for args, kwargs in arguments:
-                self._parser.add_argument(*args, **kwargs)
+                group.add_argument(*args, **kwargs)
 
     @staticmethod
     def _convert_definition(option, definition):
@@ -908,7 +457,7 @@ def _convert_definition(option, definition):
                 if 'choices' not in definition:
                     msg = 'No choice list given for option "{0}" of type "choice".'
                     msg = msg.format(option)
-                    raise ConfigurationError(msg)
+                    raise exceptions.ConfigurationError(msg)
 
                 if definition['type'] == 'multiple_choice':
                     kwargs['type'] = VALIDATORS['csv']
@@ -916,7 +465,7 @@ def _convert_definition(option, definition):
                 kwargs['choices'] = definition['choices']
             else:
                 msg = 'Unsupported type "{0}"'.format(definition['type'])
-                raise ConfigurationError(msg)
+                raise exception.ConfigurationError(msg)
 
         if definition.get('hide'):
             kwargs['help'] = argparse.SUPPRESS
@@ -924,15 +473,15 @@ def _convert_definition(option, definition):
         group = definition.get('group', 'DEFAULT').upper()
         return group, args, kwargs
 
-    def parse(self, argv, config):
+    def parse(self, to_parse, config):
         """Parse the command line arguments into the given config object.
 
-        :param argv: The command line arguments to parse.
-        :type argv: list(str)
+        :param to_parse: The command line arguments to parse.
+        :type to_parse: list(str)
         :param config: The config object to parse the command line into.
         :type config: Configuration
         """
-        self._parser.parse_args(argv, config)
+        self._parser.parse_args(to_parse, config)
 
     def preprocess(self, argv, *options):
         """Do some guess work to get a value for the specified option.
@@ -945,20 +494,35 @@ def preprocess(self, argv, *options):
         :returns: A config with the processed options.
         :rtype: Configuration
         """
-        config = Config()
-        config.add_options(self._option_definitions)
+        config = Configuration()
+        config.add_options(self._option_definitions.items())
 
         args = self._parser.parse_known_args(argv)[0]
         for option in options:
+            option = option.replace('-', '_')
             config.set_option(option, getattr(args, option, None))
 
         return config
 
+    def add_help_section(self, title, description, level=0):
+        """Add an extra help section to the help message.
+
+        :param title: The title of the section.
+            This is included as part of the help message.
+        :type title: str
+        :param description: The description of the help section.
+        :type description: str
+        :param level: The minimum level of help needed to include this
+            in the help message.
+        :type level: int
+        """
+        self._parser.add_argument_group(title, description, level=level)
+
 
 @six.add_metaclass(abc.ABCMeta)
 class FileParser(ConfigParser):
     @abc.abstractmethod
-    def parse(self, file_path, config):
+    def parse(self, to_parse, config):
         pass
 
 
@@ -972,17 +536,20 @@ def __init__(self):
         )
 
     def add_option_definitions(self, option_definitions):
+        self._option_definitions.update(option_definitions)
         for option, definition in option_definitions:
             group, default = self._convert_definition(option, definition)
 
-            try:
-                self._parser.add_section(group)
-            except configparser.DuplicateSectionError:
-                pass
-            else:
-                self._option_groups.add(group)
+            if group != self._parser.default_section:
+                try:
+                    self._parser.add_section(group)
+                except configparser.DuplicateSectionError:
+                    pass
+                else:
+                    self._option_groups.add(group)
 
-            self._parser['DEFAULT'].update(default)
+            if default is not None:
+                self._parser['DEFAULT'].update(default)
 
     @staticmethod
     def _convert_definition(option, definition):
@@ -996,13 +563,17 @@ def _convert_definition(option, definition):
         :returns: The converted definition.
         :rtype: tuple(str, dict)
         """
-        default = {option: definition.get('default')}
+        default = None
+        if definition.get('default'):
+            unvalidator = UNVALIDATORS.get(definition.get('type'), str)
+            default_value = unvalidator(definition['default'])
+            default = {option: default_value}
 
         group = definition.get('group', 'DEFAULT').upper()
         return group, default
 
-    def parse(self, file_path, config):
-        self._parser.read(file_path)
+    def parse(self, to_parse, config):
+        self._parser.read(to_parse)
 
         for section in self._parser.sections():
             # Normalise the section titles
@@ -1014,8 +585,17 @@ def parse(self, file_path, config):
                 section = section.upper()
 
             for option, value in self._parser.items(section):
+                if isinstance(value, str):
+                    definition = self._option_definitions.get(option, {})
+                    type_ = definition.get('type')
+                    validator = VALIDATORS.get(type_, lambda x: x)
+                    value = validator(value)
                 config.set_option(option, value)
 
+    def write(self, stream=sys.stdout):
+        # TODO: Check if option descriptions are written out
+        self._parser.write(stream)
+
 
 class LongHelpFormatter(argparse.HelpFormatter):
     output_level = None
@@ -1067,6 +647,25 @@ def __call__(self, parser, namespace, values, option_string=None):
         parser.exit()
 
 
+class LongHelpArgumentGroup(argparse._ArgumentGroup):
+    def __init__(self, *args, level=0, **kwargs):
+        super(LongHelpArgumentGroup, self).__init__(*args, **kwargs)
+        self.level = level
+
+    def add_argument(self, *args, **kwargs):
+        """See :func:`argparse.ArgumentParser.add_argument`.
+
+        Patches in the level to each created action instance.
+
+        :returns: The created action.
+        :rtype: argparse.Action
+        """
+        level = kwargs.pop('level', 0)
+        action = super(LongHelpArgumentGroup, self).add_argument(*args, **kwargs)
+        action.level = level
+        return action
+
+
 class LongHelpArgumentParser(argparse.ArgumentParser):
     def __init__(self, formatter_class=LongHelpFormatter, **kwargs):
         self._max_level = 0
@@ -1117,11 +716,9 @@ def add_argument(self, *args, **kwargs):
         action.level = level
         return action
 
-    def add_argument_group(self, *args, level=0, **kwargs):
-        group = super(LongHelpArgumentParser, self).add_argument_group(
-            *args, **kwargs
-        )
-        group.level = level
+    def add_argument_group(self, *args, **kwargs):
+        group = LongHelpArgumentGroup(self, *args, **kwargs)
+        self._action_groups.append(group)
         return group
 
     # These methods use yucky way of passing the level to the formatter class
diff --git a/pylint/lint.py b/pylint/lint.py
index e5a277c998..ed9dfcd337 100644
--- a/pylint/lint.py
+++ b/pylint/lint.py
@@ -53,10 +53,6 @@
 import contextlib
 import operator
 import os
-try:
-    import multiprocessing
-except ImportError:
-    multiprocessing = None
 import sys
 import tokenize
 import warnings
@@ -216,58 +212,8 @@ def _patch_sysmodules():
     }
 
 
-if multiprocessing is not None:
-    class ChildRunner(multiprocessing.Process):
-        def run(self):
-            # pylint: disable=no-member, unbalanced-tuple-unpacking
-            tasks_queue, results_queue, self._config = self._args
-
-            self._config["jobs"] = 1  # Child does not parallelize any further.
-            self._python3_porting_mode = self._config.pop(
-                'python3_porting_mode', None)
-            self._plugins = self._config.pop('plugins', None)
-
-            # Run linter for received files/modules.
-            for file_or_module in iter(tasks_queue.get, 'STOP'):
-                try:
-                    result = self._run_linter(file_or_module[0])
-                    results_queue.put(result)
-                except Exception as ex:
-                    print("internal error with sending report for module %s" %
-                          file_or_module, file=sys.stderr)
-                    print(ex, file=sys.stderr)
-                    results_queue.put({})
-
-        def _run_linter(self, file_or_module):
-            linter = PyLinter()
-
-            # Register standard checkers.
-            linter.load_default_plugins()
-            # Load command line plugins.
-            if self._plugins:
-                linter.load_plugin_modules(self._plugins)
-
-            linter.load_configuration_from_config(self._config)
-            linter.set_reporter(reporters.CollectingReporter())
-
-            # Enable the Python 3 checker mode. This option is
-            # passed down from the parent linter up to here, since
-            # the Python 3 porting flag belongs to the Run class,
-            # instead of the Linter class.
-            if self._python3_porting_mode:
-                linter.python3_porting_mode()
-
-            # Run the checks.
-            linter.check(file_or_module)
-
-            msgs = [_get_new_args(m) for m in linter.reporter.messages]
-            return (file_or_module, linter.file_state.base_name, linter.current_name,
-                    msgs, linter.stats, linter.msg_status)
-
-
 # pylint: disable=too-many-instance-attributes
-class PyLinter(config.OptionsManagerMixIn,
-               utils.MessagesHandlerMixIn,
+class PyLinter(utils.MessagesHandlerMixIn,
                utils.ReportsHandlerMixIn,
                checkers.BaseTokenChecker):
     """lint Python modules using external checkers.
@@ -290,151 +236,149 @@ class PyLinter(config.OptionsManagerMixIn,
     level = 0
     msgs = MSGS
 
-    @staticmethod
-    def make_options():
-        return (('ignore',
-                 {'type' : 'csv', 'metavar' : '<file>,...',
-                  'dest' : 'black_list', 'default' : ('CVS',),
-                  'help' : 'Add files or directories to the blacklist. '
-                           'They should be base names, not paths.'}),
-
-                ('ignore-patterns',
-                 {'type' : 'regexp_csv', 'metavar' : '<pattern>,...',
-                  'dest' : 'black_list_re', 'default' : (),
-                  'help' : 'Add files or directories matching the regex patterns to the'
-                           ' blacklist. The regex matches against base names, not paths.'}),
-
-                ('persistent',
-                 {'default': True, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'level': 1,
-                  'help' : 'Pickle collected data for later comparisons.'}),
-
-                ('load-plugins',
-                 {'type' : 'csv', 'metavar' : '<modules>', 'default' : (),
-                  'level': 1,
-                  'help' : 'List of plugins (as comma separated values of '
-                           'python modules names) to load, usually to register '
-                           'additional checkers.'}),
-
-                ('output-format',
-                 {'default': 'text', 'type': 'string', 'metavar' : '<format>',
-                  'short': 'f',
-                  'group': 'Reports',
-                  'help' : 'Set the output format. Available formats are text,'
-                           ' parseable, colorized, json and msvs (visual studio).'
-                           'You can also give a reporter class, eg mypackage.mymodule.'
-                           'MyReporterClass.'}),
-
-                ('reports',
-                 {'default': False, 'type' : 'yn', 'metavar' : '<y_or_n>',
-                  'short': 'r',
-                  'group': 'Reports',
-                  'help' : 'Tells whether to display a full report or only the '
-                           'messages'}),
-
-                ('evaluation',
-                 {'type' : 'string', 'metavar' : '<python_expression>',
-                  'group': 'Reports', 'level': 1,
-                  'default': '10.0 - ((float(5 * error + warning + refactor + '
-                             'convention) / statement) * 10)',
-                  'help' : 'Python expression which should return a note less '
-                           'than 10 (10 is the highest note). You have access '
-                           'to the variables errors warning, statement which '
-                           'respectively contain the number of errors / '
-                           'warnings messages and the total number of '
-                           'statements analyzed. This is used by the global '
-                           'evaluation report (RP0004).'}),
-                ('score',
-                 {'default': True, 'type': 'yn', 'metavar': '<y_or_n>',
-                  'short': 's',
-                  'group': 'Reports',
-                  'help': 'Activate the evaluation score.'}),
-
-                ('confidence',
-                 {'type' : 'multiple_choice', 'metavar': '<levels>',
-                  'default': '',
-                  'choices': [c.name for c in interfaces.CONFIDENCE_LEVELS],
-                  'group': 'Messages control',
-                  'help' : 'Only show warnings with the listed confidence levels.'
-                           ' Leave empty to show all. Valid levels: %s' % (
-                               ', '.join(c.name for c in interfaces.CONFIDENCE_LEVELS),)}),
-
-                ('enable',
-                 {'type' : 'csv', 'metavar': '<msg ids>',
-                  'short': 'e',
-                  'group': 'Messages control',
-                  'help' : 'Enable the message, report, category or checker with the '
-                           'given id(s). You can either give multiple identifier '
-                           'separated by comma (,) or put this option multiple time '
-                           '(only on the command line, not in the configuration file '
-                           'where it should appear only once). '
-                           'See also the "--disable" option for examples. '}),
-
-                ('disable',
-                 {'type' : 'csv', 'metavar': '<msg ids>',
-                  'short': 'd',
-                  'group': 'Messages control',
-                  'help' : 'Disable the message, report, category or checker '
-                           'with the given id(s). You can either give multiple identifiers'
-                           ' separated by comma (,) or put this option multiple times '
-                           '(only on the command line, not in the configuration file '
-                           'where it should appear only once).'
-                           'You can also use "--disable=all" to disable everything first '
-                           'and then reenable specific checks. For example, if you want '
-                           'to run only the similarities checker, you can use '
-                           '"--disable=all --enable=similarities". '
-                           'If you want to run only the classes checker, but have no '
-                           'Warning level messages displayed, use'
-                           '"--disable=all --enable=classes --disable=W"'}),
-
-                ('msg-template',
-                 {'type' : 'string', 'metavar': '<template>',
-                  'group': 'Reports',
-                  'help' : ('Template used to display messages. '
-                            'This is a python new-style format string '
-                            'used to format the message information. '
-                            'See doc for all details')
-                 }),
-
-                ('jobs',
-                 {'type' : 'int', 'metavar': '<n-processes>',
-                  'short': 'j',
-                  'default': 1,
-                  'help' : '''Use multiple processes to speed up Pylint.''',
-                 }),
-
-                ('unsafe-load-any-extension',
-                 {'type': 'yn', 'metavar': '<yn>', 'default': False, 'hide': True,
-                  'help': ('Allow loading of arbitrary C extensions. Extensions'
-                           ' are imported into the active Python interpreter and'
-                           ' may run arbitrary code.')}),
-
-                ('extension-pkg-whitelist',
-                 {'type': 'csv', 'metavar': '<pkg>,...', 'default': [],
-                  'help': ('A comma-separated list of package or module names'
-                           ' from where C extensions may be loaded. Extensions are'
-                           ' loading into the active Python interpreter and may run'
-                           ' arbitrary code')}),
-                ('suggestion-mode',
-                 {'type': 'yn', 'metavar': '<yn>', 'default': True,
-                  'help': ('When enabled, pylint would attempt to guess common '
-                           'misconfiguration and emit user-friendly hints instead '
-                           'of false-positive error messages')}),
-               )
+    options = (
+        ('ignore',
+         {'type' : 'csv', 'metavar' : '<file>,...',
+          'dest' : 'black_list', 'default' : ('CVS',),
+          'help' : 'Add files or directories to the blacklist. '
+          'They should be base names, not paths.'}),
+
+        ('ignore-patterns',
+         {'type' : 'regexp_csv', 'metavar' : '<pattern>,...',
+          'dest' : 'black_list_re', 'default' : (),
+          'help' : 'Add files or directories matching the regex patterns to the'
+          ' blacklist. The regex matches against base names, not paths.'}),
+
+        ('persistent',
+         {'default': True, 'type' : 'yn', 'metavar' : '<y_or_n>',
+          'level': 1,
+          'help' : 'Pickle collected data for later comparisons.'}),
+
+        ('load-plugins',
+         {'type' : 'csv', 'metavar' : '<modules>', 'default' : (),
+          'level': 1,
+          'help' : 'List of plugins (as comma separated values of '
+          'python modules names) to load, usually to register '
+          'additional checkers.'}),
+
+        ('output-format',
+         {'default': 'text', 'type': 'string', 'metavar' : '<format>',
+          'short': 'f',
+          'group': 'Reports',
+          'help' : 'Set the output format. Available formats are text,'
+          ' parseable, colorized, json and msvs (visual studio).'
+          'You can also give a reporter class, eg mypackage.mymodule.'
+          'MyReporterClass.'}),
+
+        ('reports',
+         {'default': False, 'type' : 'yn', 'metavar' : '<y_or_n>',
+          'short': 'r',
+          'group': 'Reports',
+          'help' : 'Tells whether to display a full report or only the '
+          'messages'}),
+
+        ('evaluation',
+         {'type' : 'string', 'metavar' : '<python_expression>',
+          'group': 'Reports', 'level': 1,
+          'default': '10.0 - ((float(5 * error + warning + refactor + '
+          'convention) / statement) * 10)',
+          'help' : 'Python expression which should return a note less '
+          'than 10 (10 is the highest note). You have access '
+          'to the variables errors warning, statement which '
+          'respectively contain the number of errors / '
+          'warnings messages and the total number of '
+          'statements analyzed. This is used by the global '
+          'evaluation report (RP0004).'}),
+    ('score',
+     {'default': True, 'type': 'yn', 'metavar': '<y_or_n>',
+      'short': 's',
+      'group': 'Reports',
+      'help': 'Activate the evaluation score.'}),
+
+    ('confidence',
+     {'type' : 'multiple_choice', 'metavar': '<levels>',
+      'default': '',
+      'choices': [c.name for c in interfaces.CONFIDENCE_LEVELS],
+      'group': 'Messages control',
+      'help' : 'Only show warnings with the listed confidence levels.'
+      ' Leave empty to show all. Valid levels: %s' % (
+          ', '.join(c.name for c in interfaces.CONFIDENCE_LEVELS),)}),
+
+    ('enable',
+     {'type' : 'csv', 'metavar': '<msg ids>',
+      'short': 'e',
+      'group': 'Messages control',
+      'help' : 'Enable the message, report, category or checker with the '
+      'given id(s). You can either give multiple identifier '
+      'separated by comma (,) or put this option multiple time '
+      '(only on the command line, not in the configuration file '
+      'where it should appear only once). '
+      'See also the "--disable" option for examples. '}),
+
+    ('disable',
+     {'type' : 'csv', 'metavar': '<msg ids>',
+      'short': 'd',
+      'group': 'Messages control',
+      'help' : 'Disable the message, report, category or checker '
+      'with the given id(s). You can either give multiple identifiers'
+      ' separated by comma (,) or put this option multiple times '
+      '(only on the command line, not in the configuration file '
+      'where it should appear only once).'
+      'You can also use "--disable=all" to disable everything first '
+      'and then reenable specific checks. For example, if you want '
+      'to run only the similarities checker, you can use '
+      '"--disable=all --enable=similarities". '
+      'If you want to run only the classes checker, but have no '
+      'Warning level messages displayed, use'
+      '"--disable=all --enable=classes --disable=W"'}),
+
+    ('msg-template',
+     {'type' : 'string', 'metavar': '<template>', 'default': '',
+      'group': 'Reports',
+      'help' : ('Template used to display messages. '
+                'This is a python new-style format string '
+                'used to format the message information. '
+                'See doc for all details')
+      }),
+
+    ('jobs',
+     {'type' : 'int', 'metavar': '<n-processes>',
+      'short': 'j',
+      'default': 1,
+      'help' : '''Use multiple processes to speed up Pylint.''',
+      }),
+
+    ('unsafe-load-any-extension',
+     {'type': 'yn', 'metavar': '<yn>', 'default': False, 'hide': True,
+      'help': ('Allow loading of arbitrary C extensions. Extensions'
+               ' are imported into the active Python interpreter and'
+               ' may run arbitrary code.')}),
+
+    ('extension-pkg-whitelist',
+     {'type': 'csv', 'metavar': '<pkg>,...', 'default': [],
+      'help': ('A comma-separated list of package or module names'
+               ' from where C extensions may be loaded. Extensions are'
+               ' loading into the active Python interpreter and may run'
+               ' arbitrary code')}),
+    ('suggestion-mode',
+     {'type': 'yn', 'metavar': '<yn>', 'default': True,
+      'help': ('When enabled, pylint would attempt to guess common '
+               'misconfiguration and emit user-friendly hints instead '
+               'of false-positive error messages')}),
+    )
 
     option_groups = (
         ('Messages control', 'Options controlling analysis messages'),
         ('Reports', 'Options related to output formatting and reporting'),
         )
 
-    def __init__(self, options=(), reporter=None, option_groups=(),
-                 pylintrc=None):
+    def __init__(self, config=None):
         # some stuff has to be done before ancestors initialization...
         #
         # messages store / checkers / reporter / astroid manager
+        self.config = config
         self.msgs_store = utils.MessagesStore()
         self.reporter = None
-        self._reporter_name = None
         self._reporters = {}
         self._checkers = collections.defaultdict(list)
         self._pragma_lineno = {}
@@ -444,23 +388,12 @@ def __init__(self, options=(), reporter=None, option_groups=(),
         self.current_name = None
         self.current_file = None
         self.stats = None
-        # init options
-        self._external_opts = options
-        self.options = options + PyLinter.make_options()
-        self.option_groups = option_groups + PyLinter.option_groups
-        self._options_methods = {
-            'enable': self.enable,
-            'disable': self.disable}
-        self._bw_options_methods = {'disable-msg': self.disable,
-                                    'enable-msg': self.enable}
+
+        # TODO: Runner needs to give this to parser?
         full_version = '%%prog %s\nastroid %s\nPython %s' % (
             version, astroid_version, sys.version)
         utils.MessagesHandlerMixIn.__init__(self)
         utils.ReportsHandlerMixIn.__init__(self)
-        super(PyLinter, self).__init__(
-            usage=__doc__,
-            version=full_version,
-            config_file=pylintrc or config.PYLINTRC)
         checkers.BaseTokenChecker.__init__(self)
         # provided reports
         self.reports = (('RP0001', 'Messages by category',
@@ -470,35 +403,12 @@ def __init__(self, options=(), reporter=None, option_groups=(),
                         ('RP0003', 'Messages',
                          report_messages_stats),
                        )
-        self.register_checker(self)
         self._dynamic_plugins = set()
         self._python3_porting_mode = False
         self._error_mode = False
-        self.load_provider_defaults()
-        if reporter:
-            self.set_reporter(reporter)
 
-    def load_default_plugins(self):
-        checkers.initialize(self)
-        reporters.initialize(self)
-        # Make sure to load the default reporter, because
-        # the option has been set before the plugins had been loaded.
-        if not self.reporter:
-            self._load_reporter()
-
-    def load_plugin_modules(self, modnames):
-        """take a list of module names which are pylint plugins and load
-        and register them
-        """
-        for modname in modnames:
-            if modname in self._dynamic_plugins:
-                continue
-            self._dynamic_plugins.add(modname)
-            module = modutils.load_module_from_name(modname)
-            module.register(self)
-
-    def _load_reporter(self):
-        name = self._reporter_name.lower()
+    def load_reporter(self):
+        name = self.config.output_format.lower()
         if name in self._reporters:
             self.set_reporter(self._reporters[name]())
         else:
@@ -510,7 +420,7 @@ def _load_reporter(self):
                 self.set_reporter(reporter_class())
 
     def _load_reporter_class(self):
-        qname = self._reporter_name
+        qname = self.config.output_format
         module = modutils.load_module_from_name(
             modutils.get_module_part(qname))
         class_name = qname.split('.')[-1]
@@ -522,43 +432,10 @@ def set_reporter(self, reporter):
         self.reporter = reporter
         reporter.linter = self
 
-    def set_option(self, optname, value, action=None, optdict=None):
-        """overridden from config.OptionsProviderMixin to handle some
-        special options
-        """
-        if optname in self._options_methods or \
-                optname in self._bw_options_methods:
-            if value:
-                try:
-                    meth = self._options_methods[optname]
-                except KeyError:
-                    meth = self._bw_options_methods[optname]
-                    warnings.warn('%s is deprecated, replace it by %s' % (optname,
-                                                                          optname.split('-')[0]),
-                                  DeprecationWarning)
-                value = utils._check_csv(value)
-                if isinstance(value, (list, tuple)):
-                    for _id in value:
-                        meth(_id, ignore_unknown=True)
-                else:
-                    meth(value)
-                return # no need to call set_option, disable/enable methods do it
-        elif optname == 'output-format':
-            self._reporter_name = value
-            # If the reporters are already available, load
-            # the reporter class.
-            if self._reporters:
-                self._load_reporter()
-
-        try:
-            checkers.BaseTokenChecker.set_option(self, optname,
-                                                 value, action, optdict)
-        except config.UnsupportedAction:
-            print('option %s can\'t be read from config file' % \
-                  optname, file=sys.stderr)
-
     def register_reporter(self, reporter_class):
         self._reporters[reporter_class.name] = reporter_class
+        if reporter_class.name == self.config.output_format.lower():
+            self.load_reporter()
 
     def report_order(self):
         reports = sorted(self._reports, key=lambda x: getattr(x, 'name', ''))
@@ -574,25 +451,6 @@ def report_order(self):
 
     # checkers manipulation methods ############################################
 
-    def register_checker(self, checker):
-        """register a new checker
-
-        checker is an object implementing IRawChecker or / and IAstroidChecker
-        """
-        assert checker.priority <= 0, 'checker priority can\'t be >= 0'
-        self._checkers[checker.name].append(checker)
-        for r_id, r_title, r_cb in checker.reports:
-            self.register_report(r_id, r_title, r_cb, checker)
-        self.register_options_provider(checker)
-        if hasattr(checker, 'msgs'):
-            self.msgs_store.register_messages(checker)
-        checker.load_defaults()
-
-        # Register the checker, but disable all of its messages.
-        # TODO(cpopa): we should have a better API for this.
-        if not getattr(checker, 'enabled', True):
-            self.disable(checker.name)
-
     def disable_noerror_messages(self):
         for msgcat, msgids in six.iteritems(self.msgs_store._msgs_by_category):
             # enable only messages with 'error' severity and above ('fatal')
@@ -656,6 +514,10 @@ def process_tokens(self, tokens):
         """process tokens from the current module to search for module/block
         level options
         """
+        options_methods = {
+            'enable': self.enable,
+            'disable': self.disable,
+        }
         control_pragmas = {'disable', 'enable'}
         for (tok_type, content, start, _, _) in tokens:
             if tok_type != tokenize.COMMENT:
@@ -678,14 +540,8 @@ def process_tokens(self, tokens):
                                  line=start[0])
                 continue
             opt = opt.strip()
-            if opt in self._options_methods or opt in self._bw_options_methods:
-                try:
-                    meth = self._options_methods[opt]
-                except KeyError:
-                    meth = self._bw_options_methods[opt]
-                    # found a "(dis|en)able-msg" pragma deprecated suppression
-                    self.add_message('deprecated-pragma', line=start[0],
-                                     args=(opt, opt.replace('-msg', '')))
+            if opt in options_methods:
+                meth = options_methods[opt]
                 for msgid in utils._splitstrip(value):
                     # Add the line where a control pragma was encountered.
                     if opt in control_pragmas:
@@ -763,6 +619,7 @@ def check(self, files_or_modules):
         """main checking entry: check a list of files or modules from their
         name.
         """
+        assert self.reporter, "A reporter has not been loaded"
         # initialize msgs_state now that all messages have been registered into
         # the store
         self._init_msg_states()
@@ -1009,49 +866,9 @@ def report_messages_by_module_stats(sect, stats, _):
 # utilities ###################################################################
 
 
-class ArgumentPreprocessingError(Exception):
-    """Raised if an error occurs during argument preprocessing."""
-
-
-def preprocess_options(args, search_for):
-    """look for some options (keys of <search_for>) which have to be processed
-    before others
-
-    values of <search_for> are callback functions to call when the option is
-    found
-    """
-    i = 0
-    while i < len(args):
-        arg = args[i]
-        if arg.startswith('--'):
-            try:
-                option, val = arg[2:].split('=', 1)
-            except ValueError:
-                option, val = arg[2:], None
-            try:
-                cb, takearg = search_for[option]
-            except KeyError:
-                i += 1
-            else:
-                del args[i]
-                if takearg and val is None:
-                    if i >= len(args) or args[i].startswith('-'):
-                        msg = 'Option %s expects a value' % option
-                        raise ArgumentPreprocessingError(msg)
-                    val = args[i]
-                    del args[i]
-                elif not takearg and val is not None:
-                    msg = "Option %s doesn't expects a value" % option
-                    raise ArgumentPreprocessingError(msg)
-                cb(option, val)
-        else:
-            i += 1
-
-
 @contextlib.contextmanager
 def fix_import_path(args):
     """Prepare sys.path for running the linter checks.
-
     Within this context, each of the given arguments is importable.
     Paths are added to sys.path in corresponding order to the arguments.
     We avoid adding duplicate directories to sys.path.
@@ -1072,104 +889,190 @@ def fix_import_path(args):
         sys.path[:] = orig
 
 
-class Run(object):
-    """helper class to use as main for pylint :
+def guess_lint_path(args):
+    """Attempt to determine the file being linted from a list of arguments.
+
+    :param args: The list of command line arguments to guess from.
+    :type args: list(str)
+
+    :returns: The path to file being linted if it can be guessed.
+        None otherwise.
+    :rtype: str or None
+    """
+    value = None
+
+    # We only care if it's a path. If it's a module,
+    # we can't get a config from it
+    if args and os.path.exists(args[-1]):
+        value = args[-1]
+
+    return value
+
+
+class PluginRegistry(object):
+    """A class to register checkers to."""
 
-    run(*sys.argv[1:])
+    def __init__(self, linter, register_options=(lambda options: None)):
+        super(PluginRegistry, self).__init__()
+        self.register_options = register_options
+        self._checkers = collections.defaultdict(list)
+        # TODO: Remove. This is needed for the MessagesHandlerMixIn for now.
+        linter._checkers = self._checkers
+        self._linter = linter
+        self.register_checker(linter)
+
+    def for_all_checkers(self):
+        """Loop through all registered checkers.
+
+        :returns: Each registered checker.
+        :rtype: iterable(BaseChecker)
+        """
+        for checkers in self._checkers.values():
+            yield from checkers
+
+    def register_checker(self, checker):
+        """Register a checker.
+
+        :param checker: The checker to register.
+        :type checker: BaseChecker
+
+        :raises ValueError: If the priority of the checker is invalid.
+        """
+        if checker.name in self._checkers:
+            # TODO: Raise if classes are the same
+            for duplicate in self._checkers[checker.name]:
+                msg = 'A checker called {} has already been registered ({}).'
+                msg = msg.format(checker.name, duplicate.__class__)
+                warnings.warn(msg)
+
+        if checker.priority > 0:
+            # TODO: Use a custom exception
+             msg = '{}.priority must be <= 0'.format(checker.__class__)
+             raise ValueError(msg)
+
+        self._checkers[checker.name].append(checker)
+
+        # TODO: Move elsewhere
+        for r_id, r_title, r_cb in checker.reports:
+            self._linter.register_report(r_id, r_title, r_cb, checker)
+
+        self.register_options(checker.options)
+
+        # TODO: Move elsewhere
+        if hasattr(checker, 'msgs'):
+            self._linter.msgs_store.register_messages(checker)
+
+        # Register the checker, but disable all of its messages.
+        # TODO(cpopa): we should have a better API for this.
+        if not getattr(checker, 'enabled', True):
+            self._linter.disable(checker.name)
+
+    # For now simply defer missing attributs to the linter,
+    # until we know what API we want.
+    def __getattr__(self, attribute):
+        return getattr(self._linter, attribute)
+
+
+class Runner(object):
+    """A class to manager how the linter runs."""
+
+    option_definitions = ()
+    """The runner specific configuration options.
+
+    :type: set(OptionDefinition)
     """
-    LinterClass = PyLinter
+
+
+class CLIRunner(Runner):
+    option_definitions = (
+        ('rcfile',
+         {'type': 'string', 'metavar': '<file>',
+          'help' : 'Specify a configuration file.'}),
+
+        ('init-hook',
+         {'type' : 'string', 'metavar': '<code>',
+          'level': 1,
+          'help' : 'Python code to execute, usually for sys.path '
+          'manipulation such as pygtk.require().'}),
+
+        ('help-msg',
+         {'type' : 'string', 'metavar': '<msg-id>',
+          'group': 'Commands', 'default': None,
+          'help' : 'Display a help message for the given message id and '
+          'exit. The value may be a comma separated list of message ids.'}),
+
+        ('list-msgs',
+         {'metavar': '<msg-id>',
+          'group': 'Commands', 'level': 1, 'default': None,
+          'help' : "Generate pylint's messages."}),
+
+        ('list-conf-levels',
+         {'group': 'Commands', 'level': 1,
+          'action': 'store_true', 'default': False,
+          'help' : "Generate pylint's confidence levels."}),
+
+        ('full-documentation',
+         {'metavar': '<msg-id>', 'default': None,
+          'group': 'Commands', 'level': 1,
+          'help' : "Generate pylint's full documentation."}),
+
+        ('generate-rcfile',
+         {'group': 'Commands', 'action': 'store_true', 'default': False,
+          'help' : 'Generate a sample configuration file according to '
+          'the current configuration. You can put other options '
+          'before this one to get them in the generated '
+          'configuration.'}),
+
+        ('generate-man',
+         {'group': 'Commands', 'action': 'store_true', 'default': False,
+          'help' : "Generate pylint's man page.", 'hide': True}),
+
+        ('errors-only',
+         {'short': 'E', 'action': 'store_true', 'default': False,
+          'help' : 'In error mode, checkers without error messages are '
+          'disabled and for others, only the ERROR messages are '
+          'displayed, and no reports are done by default'''}),
+
+        ('py3k',
+         {'action': 'store_true', 'default': False,
+          'help' : 'In Python 3 porting mode, all checkers will be '
+          'disabled and only messages emitted by the porting '
+          'checker will be displayed'}),
+    )
+
     option_groups = (
         ('Commands', 'Options which are actually commands. Options in this \
 group are mutually exclusive.'),
         )
 
-    def __init__(self, args, reporter=None, do_exit=True):
-        self._rcfile = None
-        self._plugins = []
-        try:
-            preprocess_options(args, {
-                # option: (callback, takearg)
-                'init-hook':   (cb_init_hook, True),
-                'rcfile':       (self.cb_set_rcfile, True),
-                'load-plugins': (self.cb_add_plugins, True),
-                })
-        except ArgumentPreprocessingError as ex:
-            print(ex, file=sys.stderr)
-            sys.exit(32)
-
-        self.linter = linter = self.LinterClass((
-            ('rcfile',
-             {'action' : 'callback', 'callback' : lambda *args: 1,
-              'type': 'string', 'metavar': '<file>',
-              'help' : 'Specify a configuration file.'}),
-
-            ('init-hook',
-             {'action' : 'callback', 'callback' : lambda *args: 1,
-              'type' : 'string', 'metavar': '<code>',
-              'level': 1,
-              'help' : 'Python code to execute, usually for sys.path '
-                       'manipulation such as pygtk.require().'}),
-
-            ('help-msg',
-             {'action' : 'callback', 'type' : 'string', 'metavar': '<msg-id>',
-              'callback' : self.cb_help_message,
-              'group': 'Commands',
-              'help' : 'Display a help message for the given message id and '
-                       'exit. The value may be a comma separated list of message ids.'}),
-
-            ('list-msgs',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_list_messages,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's messages."}),
-
-            ('list-conf-levels',
-             {'action' : 'callback',
-              'callback' : cb_list_confidence_levels,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's confidence levels."}),
-
-            ('full-documentation',
-             {'action' : 'callback', 'metavar': '<msg-id>',
-              'callback' : self.cb_full_documentation,
-              'group': 'Commands', 'level': 1,
-              'help' : "Generate pylint's full documentation."}),
-
-            ('generate-rcfile',
-             {'action' : 'callback', 'callback' : self.cb_generate_config,
-              'group': 'Commands',
-              'help' : 'Generate a sample configuration file according to '
-                       'the current configuration. You can put other options '
-                       'before this one to get them in the generated '
-                       'configuration.'}),
-
-            ('generate-man',
-             {'action' : 'callback', 'callback' : self.cb_generate_manpage,
-              'group': 'Commands',
-              'help' : "Generate pylint's man page.", 'hide': True}),
-
-            ('errors-only',
-             {'action' : 'callback', 'callback' : self.cb_error_mode,
-              'short': 'E',
-              'help' : 'In error mode, checkers without error messages are '
-                       'disabled and for others, only the ERROR messages are '
-                       'displayed, and no reports are done by default'''}),
-
-            ('py3k',
-             {'action' : 'callback', 'callback' : self.cb_python3_porting_mode,
-              'help' : 'In Python 3 porting mode, all checkers will be '
-                       'disabled and only messages emitted by the porting '
-                       'checker will be displayed'}),
-
-            ), option_groups=self.option_groups, pylintrc=self._rcfile)
-        # register standard checkers
-        linter.load_default_plugins()
-        # load command line plugins
-        linter.load_plugin_modules(self._plugins)
-        # add some help section
-        linter.add_help_section('Environment variables', config.ENV_HELP, level=1)
+    description = (
+        'pylint [options] module_or_package\n'
+        '\n'
+        '  Check that a module satisfies a coding standard (and more !).\n'
+        '\n'
+        '    pylint --help\n'
+        '\n'
+        '  Display this help message and exit.\n'
+        '\n'
+        '    pylint --help-msg <msg-id>[,<msg-id>]\n'
+        '\n'
+        '  Display help messages about given message identifiers and exit.\n'
+    )
+
+    def __init__(self):
+        super(CLIRunner, self).__init__()
+        self._linter = PyLinter()
+        self._plugin_registry = PluginRegistry(self._linter)
+        self._loaded_plugins = set()
+
+    def run(self, args):
+        # Phase 1: Preprocessing
+        option_definitions = self.option_definitions + self._linter.options
+        parser = config.CLIParser(self.description)
+        parser.add_option_definitions(option_definitions)
+        parser.add_help_section('Environment variables', config.ENV_HELP, level=1)
         # pylint: disable=bad-continuation
-        linter.add_help_section('Output',
+        parser.add_help_section('Output',
 'Using the default text output, the message format is :                          \n'
 '                                                                                \n'
 '        MESSAGE_TYPE: LINE_NUM:[OBJECT:] MESSAGE                                \n'
@@ -1182,7 +1085,7 @@ def __init__(self, args, reporter=None, do_exit=True):
 '    * (F) fatal, if an error occurred which prevented pylint from doing further\n'
 'processing.\n'
                                 , level=1)
-        linter.add_help_section('Output status code',
+        parser.add_help_section('Output status code',
 'Pylint should leave with following status code:                                 \n'
 '    * 0 if everything went fine                                                 \n'
 '    * 1 if a fatal message was issued                                           \n'
@@ -1195,224 +1098,128 @@ def __init__(self, args, reporter=None, do_exit=True):
 'status 1 to 16 will be bit-ORed so you can know which different categories has\n'
 'been issued by analysing pylint output status code\n',
                                 level=1)
-        # read configuration
-        linter.disable('I')
-        linter.enable('c-extension-no-member')
-        linter.read_config_file()
-        config_parser = linter.cfgfile_parser
-        # run init hook, if present, before loading plugins
-        if config_parser._parser.has_option('MASTER', 'init-hook'):
-            cb_init_hook('init-hook',
-                         utils._unquote(config_parser._parser.get('MASTER',
-                                                          'init-hook')))
-        # is there some additional plugins in the file configuration, in
-        if config_parser._parser.has_option('MASTER', 'load-plugins'):
-            plugins = utils._splitstrip(
-                config_parser._parser.get('MASTER', 'load-plugins'))
-            linter.load_plugin_modules(plugins)
-        # now we can load file config and command line, plugins (which can
-        # provide options) have been registered
-        linter.load_config_file()
-        if reporter:
-            # if a custom reporter is provided as argument, it may be overridden
-            # by file parameters, so re-set it here, but before command line
-            # parsing so it's still overrideable by command line option
-            linter.set_reporter(reporter)
-        try:
-            args = linter.load_command_line_configuration(args)
-        except SystemExit as exc:
-            if exc.code == 2: # bad options
-                exc.code = 32
-            raise
-        if not args:
-            print(linter.help())
-            sys.exit(32)
-
-        if linter.config.jobs < 0:
-            print("Jobs number (%d) should be greater than 0"
-                  % linter.config.jobs, file=sys.stderr)
-            sys.exit(32)
-        if linter.config.jobs > 1 or linter.config.jobs == 0:
-            if multiprocessing is None:
-                print("Multiprocessing library is missing, "
-                      "fallback to single process", file=sys.stderr)
-                linter.set_option("jobs", 1)
-            elif linter.config.jobs == 0:
-                linter.config.jobs = multiprocessing.cpu_count()
-
-        # insert current working directory to the python path to have a correct
-        # behaviour
-        with fix_import_path(args):
-            if linter.config.jobs == 1:
-                linter.check(args)
-            else:
-                self._parallel_run(args)
 
-            linter.generate_reports()
-        if do_exit:
-            sys.exit(self.linter.msg_status)
+        global_config = config.Configuration()
+        global_config.add_options(option_definitions)
+        self._linter.config = global_config
+
+        parsed = parser.preprocess(
+            args,
+            'init_hook',
+            'rcfile',
+            'load_plugins',
+            'ignore',
+            'ignore_patterns',
+        )
 
-    def _parallel_run(self, files_or_modules):
-        with _patch_sysmodules():
-            self.linter._init_msg_states()
-            self._parallel_check(files_or_modules)
+        # Call init-hook
+        if parsed.init_hook:
+            exec(parsed.init_hook)
 
-    def _parallel_task(self, files_or_modules):
-        # Prepare configuration for child linters.
-        child_config = self._get_jobs_config()
+        # Load rcfile, else system rcfile
+        file_parser = config.IniFileParser()
+        file_parser.add_option_definitions(self._linter.options)
+        rcfile = parsed.rcfile or config.PYLINTRC
+        if rcfile:
+            file_parser.parse(rcfile, global_config)
 
-        children = []
-        manager = multiprocessing.Manager()
-        tasks_queue = manager.Queue()
-        results_queue = manager.Queue()
+        def register_options(options):
+            global_config.add_options(options)
+            parser.add_option_definitions(options)
+            file_parser.add_option_definitions(options)
+        self._plugin_registry.register_options = register_options
 
-        for _ in range(self.linter.config.jobs):
-            child_linter = ChildRunner(args=(tasks_queue, results_queue,
-                                             child_config))
-            child_linter.start()
-            children.append(child_linter)
+        checkers.initialize(self._plugin_registry)
 
-        # Send files to child linters.
-        expanded_files = utils.expand_files(
-            files_or_modules,
-            self.linter,
-            self.linter.config.black_list,
-            self.linter.config.black_list_re
-        )
-        for module_desc in expanded_files:
-            tasks_queue.put([module_desc.path])
+        # Load plugins from CLI
+        plugins = parsed.load_plugins or []
+        for plugin in plugins:
+            self.load_plugin(plugin)
 
-        # collect results from child linters
-        failed = False
-        for _ in expanded_files:
-            try:
-                result = results_queue.get()
-            except Exception as ex:
-                print("internal error while receiving results from child linter",
-                      file=sys.stderr)
-                print(ex, file=sys.stderr)
-                failed = True
-                break
-            yield result
-
-        # Stop child linters and wait for their completion.
-        for _ in range(self.linter.config.jobs):
-            tasks_queue.put('STOP')
-        for child in children:
-            child.join()
-
-        if failed:
-            print("Error occured, stopping the linter.", file=sys.stderr)
-            sys.exit(32)
-
-    def _parallel_check(self, files_or_modules):
-        # Reset stats.
-        self.linter.open()
-
-        all_stats = []
-        module = None
-        for result in self._parallel_task(files_or_modules):
-            if not result:
-                continue
-            (
-                _,
-                self.linter.file_state.base_name,
-                module,
-                messages,
-                stats,
-                msg_status
-            ) = result
-
-            for msg in messages:
-                msg = utils.Message(*msg)
-                self.linter.set_current_module(module)
-                self.linter.reporter.handle_message(msg)
-
-            all_stats.append(stats)
-            self.linter.msg_status |= msg_status
-
-        self.linter.stats = _merge_stats(all_stats)
-        self.linter.current_name = module
-
-        # Insert stats data to local checkers.
-        for checker in self.linter.get_checkers():
-            if checker is not self.linter:
-                checker.stats = self.linter.stats
-
-    def _get_jobs_config(self):
-        child_config = collections.OrderedDict()
-        filter_options = {'long-help'}
-        filter_options.update((opt_name for opt_name, _ in self.linter._external_opts))
-        for opt_providers in six.itervalues(self.linter._all_options):
-            for optname, optdict, val in opt_providers.options_and_values():
-                if optdict.get('deprecated'):
-                    continue
-
-                if optname not in filter_options:
-                    child_config[optname] = utils._format_option_value(
-                        optdict, val)
-        child_config['python3_porting_mode'] = self.linter._python3_porting_mode
-        child_config['plugins'] = self.linter._dynamic_plugins
-        return child_config
-
-    def cb_set_rcfile(self, name, value):
-        """callback for option preprocessing (i.e. before option parsing)"""
-        self._rcfile = value
-
-    def cb_add_plugins(self, name, value):
-        """callback for option preprocessing (i.e. before option parsing)"""
-        self._plugins.extend(utils._splitstrip(value))
-
-    def cb_error_mode(self, *args, **kwargs):
-        """error mode:
-        * disable all but error messages
-        * disable the 'miscellaneous' checker which can be safely deactivated in
-          debug
-        * disable reports
-        * do not save execution information
-        """
-        self.linter.error_mode()
+        # TODO: This is for per directory config support (#618)
+        # Phase 2: Discover more plugins found in config files
+        # Walk and discover config files, watching for blacklists as we go
+
+        # Load plugins from config files
+
+        # Phase 3: Full load
+        # Fully load config files
+        if rcfile:
+            file_parser.parse(rcfile, global_config)
+        # Fully load CLI into global config
+        parser.parse(args, global_config)
 
-    def cb_generate_config(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        self.linter.generate_config(skipsections=('COMMANDS',))
-        sys.exit(0)
+        if global_config.generate_rcfile:
+            file_parser.write()
+            sys.exit(0)
 
-    def cb_generate_manpage(self, *args, **kwargs):
-        """optik callback for sample config file generation"""
-        from pylint import __pkginfo__
-        self.linter.generate_manpage(__pkginfo__)
-        sys.exit(0)
+        # TODO: if global_config.generate_man
 
-    def cb_help_message(self, option, optname, value, parser):
-        """optik callback for printing some help about a particular message"""
-        self.linter.msgs_store.help_message(utils._splitstrip(value))
-        sys.exit(0)
+        if global_config.errors_only:
+            self._linter.errors_mode()
 
-    def cb_full_documentation(self, option, optname, value, parser):
-        """optik callback for printing full documentation"""
-        self.linter.print_full_documentation()
-        sys.exit(0)
+        if global_config.py3k:
+            self._linter.python3_porting_mode()
 
-    def cb_list_messages(self, option, optname, value, parser): # FIXME
-        """optik callback for printing available messages"""
-        self.linter.msgs_store.list_messages()
-        sys.exit(0)
+        if global_config.full_documentation:
+            self._linter.print_full_documentation()
+            sys.exit(0)
 
-    def cb_python3_porting_mode(self, *args, **kwargs):
-        """Activate only the python3 porting checker."""
-        self.linter.python3_porting_mode()
+        if global_config.list_conf_levels:
+            for level in interfaces.CONFIDENCE_LEVELS:
+                print('%-18s: %s' % level)
+            sys.exit(0)
 
+        if global_config.list_msgs:
+            self._linter.msgs_store.list_messages()
+            sys.exit(0)
 
-def cb_list_confidence_levels(option, optname, value, parser):
-    for level in interfaces.CONFIDENCE_LEVELS:
-        print('%-18s: %s' % level)
-    sys.exit(0)
+        if global_config.help_msg:
+            msg = utils._splitstrip(global_config.help_msg)
+            self._linter.msgs_store.help_message(msg)
+            sys.exit(0)
 
-def cb_init_hook(optname, value):
-    """exec arbitrary code to set sys.path for instance"""
-    exec(value) # pylint: disable=exec-used
+        self.load_default_plugins()
+
+        self._linter.disable('I')
+        self._linter.enable('c-extension-no-member')
+
+        for checker in self._plugin_registry.for_all_checkers():
+            checker.config = global_config
+
+        with fix_import_path(global_config.module_or_package):
+            assert self._linter.config.jobs == 1
+            self._linter.check(global_config.module_or_package)
+
+            self._linter.generate_reports()
+
+        sys.exit(self._linter.msg_status)
+
+    def load_plugin(self, module_name):
+        if module_name in self._loaded_plugins:
+            msg = 'Already loaded plugin {0}. Ignoring'.format(module_name)
+            warnings.warn(msg)
+        else:
+            module = astroid.modutils.load_module_from_name(module_name)
+            module.register(self._plugin_registry)
+
+    def load_plugins(self, module_names):
+        """Load a plugin.
+
+        Args:
+            module_names (list(str)): The name of plugin modules to load.
+        """
+        for module_name in module_names:
+            self.load_plugin(module_name)
+
+    def load_default_plugins(self):
+        """Load all of the default plugins."""
+        reporters.initialize(self._linter)
+        # Make sure to load the default reporter, because
+        # the option has been set before the plugins had been loaded.
+        if not self._linter.reporter:
+            self._linter.load_reporter()
 
 
 if __name__ == '__main__':
-    Run(sys.argv[1:])
+     CLIRunner().run(sys.argv[1:])
diff --git a/pylint/test/test_functional.py b/pylint/test/test_functional.py
index f0f1302bca..11e91c609d 100644
--- a/pylint/test/test_functional.py
+++ b/pylint/test/test_functional.py
@@ -29,6 +29,7 @@
 from pylint import interfaces
 from pylint import lint
 from pylint import reporters
+import pylint.config
 
 class test_dialect(csv.excel):
     if sys.version_info[0] < 3:
@@ -231,15 +232,17 @@ class LintModuleTest(object):
     def __init__(self, test_file):
         test_reporter = FunctionalTestReporter()
         self._linter = lint.PyLinter()
+        global_config = pylint.config.Configuration()
+        self._linter.config = global_config
+        global_config.add_options(self._linter.options)
+        registry = lint.PluginRegistry(self._linter)
+        file_parser = pylint.config.IniFileParser()
+        file_parser.add_option_definitions(self._linter.options)
         self._linter.set_reporter(test_reporter)
         self._linter.config.persistent = 0
-        checkers.initialize(self._linter)
+        checkers.initialize(registry)
         self._linter.disable('I')
-        try:
-            self._linter.read_config_file(test_file.option_file)
-            self._linter.load_config_file()
-        except NoFileError:
-            pass
+        file_parser.parse(test_file.option_file, global_config)
         self._test_file = test_file
 
     def setUp(self):
diff --git a/pylint/test/test_self.py b/pylint/test/test_self.py
index 8e2e564d57..c000b15560 100644
--- a/pylint/test/test_self.py
+++ b/pylint/test/test_self.py
@@ -27,7 +27,7 @@
 
 import six
 
-from pylint.lint import Run
+from pylint.lint import CLIRunner
 from pylint.reporters import BaseReporter
 from pylint.reporters.text import *
 from pylint.reporters.json import JSONReporter
@@ -115,7 +115,8 @@ def _run_pylint(self, args, out, reporter=None):
             with pytest.raises(SystemExit) as cm:
                 with warnings.catch_warnings():
                     warnings.simplefilter("ignore")
-                    Run(args, reporter=reporter)
+                    runner = CLIRunner()
+                    runner.run(args)
             return cm.value.code
 
     def _test_output(self, args, expected_output):
@@ -210,10 +211,12 @@ def test_no_out_encoding(self):
                        '--enable=all'],
                       out=strio, code=28)
 
+    @pytest.mark.xfail(reason='Removed parallel execution for now')
     def test_parallel_execution(self):
         self._runtest(['-j 2', 'pylint/test/functional/arguments.py',
                        'pylint/test/functional/bad_continuation.py'], code=1)
 
+    @pytest.mark.xfail(reason='Removed parallel execution for now')
     def test_parallel_execution_missing_arguments(self):
         self._runtest(['-j 2', 'not_here', 'not_here_too'], code=1)
 
diff --git a/pylint/test/unittest_config.py b/pylint/test/unittest_config.py
index 50029c6e0d..d832558f8d 100644
--- a/pylint/test/unittest_config.py
+++ b/pylint/test/unittest_config.py
@@ -16,17 +16,17 @@
 import pytest
 
 def test__regexp_validator_valid():
-    result = config._regexp_validator(None, None, "test_.*")
+    result = config.VALIDATORS['regex']("test_.*")
     assert isinstance(result, re._pattern_type)
     assert result.pattern == "test_.*"
 
 def test__regexp_validator_invalid():
     with pytest.raises(sre_constants.error):
-        config._regexp_validator(None, None, "test_)")
+        config.VALIDATORS['regex']("test_)")
 
 def test__csv_validator_no_spaces():
     values = ["One", "Two", "Three"]
-    result = config._csv_validator(None, None, ",".join(values))
+    result = config.VALIDATORS['csv'](",".join(values))
     assert isinstance(result, list)
     assert len(result) == 3
     for i, value in enumerate(values):
@@ -34,7 +34,7 @@ def test__csv_validator_no_spaces():
 
 def test__csv_validator_spaces():
     values = ["One", "Two", "Three"]
-    result = config._csv_validator(None, None, ", ".join(values))
+    result = config.VALIDATORS['csv'](", ".join(values))
     assert isinstance(result, list)
     assert len(result) == 3
     for i, value in enumerate(values):
@@ -42,7 +42,7 @@ def test__csv_validator_spaces():
 
 def test__regexp_csv_validator_valid():
     pattern_strings = ["test_.*", "foo\\.bar", "^baz$"]
-    result = config._regexp_csv_validator(None, None, ",".join(pattern_strings))
+    result = config.VALIDATORS['regexp_csv'](",".join(pattern_strings))
     for i, regex in enumerate(result):
         assert isinstance(regex, re._pattern_type)
         assert regex.pattern == pattern_strings[i]
@@ -50,4 +50,4 @@ def test__regexp_csv_validator_valid():
 def test__regexp_csv_validator_invalid():
     pattern_strings = ["test_.*", "foo\\.bar", "^baz)$"]
     with pytest.raises(sre_constants.error):
-        config._regexp_csv_validator(None, None, ",".join(pattern_strings))
+        config.VALIDATORS['regexp_csv'](",".join(pattern_strings))
diff --git a/pylint/test/unittest_lint.py b/pylint/test/unittest_lint.py
index 2a05f052a0..1d4f486b58 100644
--- a/pylint/test/unittest_lint.py
+++ b/pylint/test/unittest_lint.py
@@ -33,7 +33,7 @@
 from six.moves import reload_module
 
 from pylint import config, lint
-from pylint.lint import PyLinter, Run, preprocess_options, ArgumentPreprocessingError
+from pylint.lint import CLIRunner, PluginRegistry, PyLinter
 from pylint.utils import MSG_STATE_SCOPE_CONFIG, MSG_STATE_SCOPE_MODULE, MSG_STATE_CONFIDENCE, \
     MessagesStore, MessageDefinition, FileState, tokenize_module
 from pylint.exceptions import InvalidMessageError, UnknownMessageError
@@ -488,10 +488,11 @@ def test_addmessage_invalid(linter):
 
 
 def test_init_hooks_called_before_load_plugins():
+    runner = CLIRunner()
     with pytest.raises(RuntimeError):
-        Run(['--load-plugins', 'unexistant', '--init-hook', 'raise RuntimeError'])
+        runner.run(['--load-plugins', 'unexistant', '--init-hook', 'raise RuntimeError'])
     with pytest.raises(RuntimeError):
-        Run(['--init-hook', 'raise RuntimeError', '--load-plugins', 'unexistant'])
+        runner.run(['--init-hook', 'raise RuntimeError', '--load-plugins', 'unexistant'])
 
 
 def test_analyze_explicit_script(linter):
@@ -612,37 +613,6 @@ def test_pylintrc_parentdir_no_package():
                 assert config.find_pylintrc() == expected
 
 
-class TestPreprocessOptions(object):
-    def _callback(self, name, value):
-        self.args.append((name, value))
-
-    def test_value_equal(self):
-        self.args = []
-        preprocess_options(['--foo', '--bar=baz', '--qu=ux'],
-                           {'foo': (self._callback, False),
-                            'qu': (self._callback, True)})
-        assert [('foo', None), ('qu', 'ux')] == self.args
-
-    def test_value_space(self):
-        self.args = []
-        preprocess_options(['--qu', 'ux'],
-                           {'qu': (self._callback, True)})
-        assert [('qu', 'ux')] == self.args
-
-    def test_error_missing_expected_value(self):
-        with pytest.raises(ArgumentPreprocessingError):
-            preprocess_options(['--foo', '--bar', '--qu=ux'],
-                               {'bar': (None, True)})
-        with pytest.raises(ArgumentPreprocessingError):
-            preprocess_options(['--foo', '--bar'],
-                               {'bar': (None, True)})
-
-    def test_error_unexpected_value(self):
-        with pytest.raises(ArgumentPreprocessingError):
-            preprocess_options(['--foo', '--bar=spam', '--qu=ux'],
-                               {'bar': (None, False)})
-
-
 @pytest.fixture
 def store():
     store = MessagesStore()
@@ -744,7 +714,9 @@ def should_analyze_file(self, modname, path, is_argument=False):
     package_dir = os.path.join(HERE, 'regrtest_data', 'bad_package')
     wrong_file = os.path.join(package_dir, 'wrong.py')
     reporter = testutils.TestReporter()
-    linter = CustomPyLinter()
+    global_config = config.Configuration()
+    linter = CustomPyLinter(global_config)
+    registry = PluginRegistry(linter, register_options=global_config.add_options)
     linter.config.persistent = 0
     linter.open()
     linter.set_reporter(reporter)
diff --git a/pylint/test/unittest_reporters_json.py b/pylint/test/unittest_reporters_json.py
index 00ad766fa5..46f6c17432 100644
--- a/pylint/test/unittest_reporters_json.py
+++ b/pylint/test/unittest_reporters_json.py
@@ -13,7 +13,8 @@
 
 import six
 
-from pylint.lint import PyLinter
+import pylint.config
+from pylint.lint import PluginRegistry, PyLinter
 from pylint import checkers
 from pylint.reporters.json import JSONReporter
 
@@ -22,8 +23,11 @@ def test_simple_json_output():
     output = six.StringIO()
 
     reporter = JSONReporter()
-    linter = PyLinter(reporter=reporter)
-    checkers.initialize(linter)
+    global_config = pylint.config.Configuration()
+    linter = PyLinter(global_config)
+    registry = PluginRegistry(linter, register_options=global_config.add_options)
+    checkers.initialize(registry)
+    linter.set_reporter(reporter)
 
     linter.config.persistent = 0
     linter.reporter.set_output(output)
diff --git a/pylint/test/unittest_reporting.py b/pylint/test/unittest_reporting.py
index b5744acdf8..f1bdf2ef63 100644
--- a/pylint/test/unittest_reporting.py
+++ b/pylint/test/unittest_reporting.py
@@ -13,7 +13,8 @@
 
 import six
 
-from pylint.lint import PyLinter
+import pylint.config
+from pylint.lint import PluginRegistry, PyLinter
 from pylint import checkers
 from pylint.reporters.text import TextReporter, ParseableTextReporter
 import pytest
@@ -55,12 +56,15 @@ def test_parseable_output_deprecated():
 def test_parseable_output_regression():
     output = six.StringIO()
     with warnings.catch_warnings(record=True):
-        linter = PyLinter(reporter=ParseableTextReporter())
+        global_config = pylint.config.Configuration()
+        linter = PyLinter(global_config)
+        registry = PluginRegistry(linter, register_options=global_config.add_options)
+        linter.set_reporter(ParseableTextReporter())
 
-    checkers.initialize(linter)
+    checkers.initialize(registry)
     linter.config.persistent = 0
     linter.reporter.set_output(output)
-    linter.set_option('output-format', 'parseable')
+    linter.config.output_format = 'parseable'
     linter.open()
     linter.set_current_module('0123')
     linter.add_message('line-too-long', line=1, args=(1, 2))
diff --git a/pylint/testutils.py b/pylint/testutils.py
index 925e219992..51d09edf3a 100644
--- a/pylint/testutils.py
+++ b/pylint/testutils.py
@@ -35,10 +35,11 @@
 
 import astroid
 from pylint import checkers
+import pylint.config
 from pylint.utils import PyLintASTWalker
 from pylint.reporters import BaseReporter
 from pylint.interfaces import IReporter
-from pylint.lint import PyLinter
+from pylint.lint import PluginRegistry, PyLinter
 
 # Utils
 
@@ -169,6 +170,7 @@ class UnittestLinter(object):
     def __init__(self):
         self._messages = []
         self.stats = {}
+        self.config = pylint.config.Configuration()
 
     def release_messages(self):
         try:
@@ -216,7 +218,9 @@ class CheckerTestCase(object):
 
     def setup_method(self):
         self.linter = UnittestLinter()
-        self.checker = self.CHECKER_CLASS(self.linter) # pylint: disable=not-callable
+        registry = pylint.config.PluginRegistry(self.linter)
+        registry.register_options = self.linter.config.add_options
+        self.checker = self.CHECKER_CLASS(registry) # pylint: disable=not-callable
         for key, value in six.iteritems(self.CONFIG):
             setattr(self.checker.config, key, value)
         self.checker.open()
@@ -251,10 +255,10 @@ def walk(self, node):
 
 # Init
 test_reporter = TestReporter()
-linter = PyLinter()
+linter = PyLinter(pylint.config.Configuration())
 linter.set_reporter(test_reporter)
 linter.config.persistent = 0
-checkers.initialize(linter)
+checkers.initialize(PluginRegistry(linter))
 
 
 def _tokenize_str(code):
diff --git a/pylint/utils.py b/pylint/utils.py
index 6228ec4e2c..eed1f9e905 100644
--- a/pylint/utils.py
+++ b/pylint/utils.py
@@ -1075,29 +1075,36 @@ def walk(self, astroid):
 
 PY_EXTS = ('.py', '.pyc', '.pyo', '.pyw', '.so', '.dll')
 
-def register_plugins(linter, directory):
-    """load all module and package in the given directory, looking for a
-    'register' function in each one, used to register pylint checkers
+def register_plugins(registry, directory):
+    """Load plugins from all modules and packages in the given directory.
+
+    Args:
+        registry (PluginRegistry): The registry to register the checkers with.
+        directory (str): The directory to search for plugins.
     """
-    imported = {}
+    imported = {'__init__', '__pycache__'}
     for filename in os.listdir(directory):
-        base, extension = splitext(filename)
-        if base in imported or base == '__pycache__':
+        base, extension = os.path.splitext(filename)
+        if base in imported:
             continue
-        if extension in PY_EXTS and base != '__init__' or (
-                not extension and isdir(join(directory, base))):
+
+        package_dir = os.path.join(directory, base)
+        if (extension in PY_EXTS
+                or (not extension and os.path.isdir(package_dir))):
+            file_path = os.path.join(directory, filename)
             try:
-                module = modutils.load_module_from_file(join(directory, filename))
+                module = modutils.load_module_from_file(file_path)
             except ValueError:
-                # empty module name (usually emacs auto-save files)
+                # Empty module name
                 continue
             except ImportError as exc:
                 print("Problem importing module %s: %s" % (filename, exc),
                       file=sys.stderr)
             else:
                 if hasattr(module, 'register'):
-                    module.register(linter)
-                    imported[base] = 1
+                    module.register(registry)
+                    imported.add(base)
+
 
 def get_global_option(checker, option, default=None):
     """ Retrieve an option defined by the given *checker* or