diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index c6e5085d..23e4d1c5 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -11,7 +11,7 @@ Changes
 * FIX: Fixed explicit profiling of class methods; added handling for profiling static, bound, and partial methods, ``functools.partial`` objects, (cached) properties, and async generator functions
 * FIX: Fixed namespace bug when running ``kernprof -m`` on certain modules (e.g. ``calendar`` on Python 3.12+).
 * FIX: Fixed ``@contextlib.contextmanager`` bug where the cleanup code (e.g. restoration of ``sys`` attributes) is not run if exceptions occurred inside the context
-* ENH: Added CLI arguments ``-c`` to ``kernprof`` for (auto-)profiling inline-script execution instead of that of script files; passing ``'-'`` as the script-file name now also reads from and profiles ``stdin``
+* ENH: Added CLI arguments ``-c`` to ``kernprof`` for (auto-)profiling module/package/inline-script execution instead of that of script files; passing ``'-'`` as the script-file name now also reads from and profiles ``stdin``
 * ENH: In Python >=3.11, profiled objects are reported using their qualified name.
 * ENH: Highlight final summary using rich if enabled
 * ENH: Made it possible to use multiple profiler instances simultaneously
@@ -24,6 +24,7 @@ Changes
   * On-import profiling is now more aggressive so that it doesn't miss entities
     like class methods and properties
   * ``LineProfiler`` can now be used as a class decorator
+* ENH: Added capability to parse TOML config files for defaults for ``kernprof`` and ``python -m line_profiler`` CLI options, ``GlobalProfiler`` configurations, and profiler output (e.g. ``LineProfiler.print_stats()``) formatting #335
 
 4.2.0
 ~~~~~
diff --git a/MANIFEST.in b/MANIFEST.in
index c9d9793e..93aba83b 100644
--- a/MANIFEST.in
+++ b/MANIFEST.in
@@ -1,3 +1,4 @@
+graft line_profiler/rc
 include *.md
 include *.rst
 include *.py
diff --git a/kernprof.py b/kernprof.py
index a94f8dc2..0699945c 100755
--- a/kernprof.py
+++ b/kernprof.py
@@ -73,11 +73,20 @@ def main():
 
 .. code::
 
-    usage: kernprof [-h] [-V] [-l] [-b] [-o OUTFILE] [-s SETUP] [-v] [-q] [-r] [-u UNIT] [-z] [-i [OUTPUT_INTERVAL]] [-p {path/to/script | object.dotted.path}[,...]]
-                    [--no-preimports] [--prof-imports]
+    usage: kernprof [-h] [-V] [--config CONFIG] [--no-config]
+                    [--line-by-line [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [--builtin [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [-s SETUP] [-p {path/to/script | object.dotted.path}[,...]]
+                    [--preimports [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [--prof-imports [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [-o OUTFILE] [-v] [-q]
+                    [--rich [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [-u UNIT]
+                    [--skip-zero [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [-i [OUTPUT_INTERVAL]]
                     {path/to/script | -m path.to.module | -c "literal code"} ...
 
-    Run and profile a python script.
+    Run and profile a python script or module.
 
     positional arguments:
       {path/to/script | -m path.to.module | -c "literal code"}
@@ -87,28 +96,73 @@ def main():
     options:
       -h, --help            show this help message and exit
       -V, --version         show program's version number and exit
-      -l, --line-by-line    Use the line-by-line profiler instead of cProfile. Implies --builtin.
-      -b, --builtin         Put 'profile' in the builtins. Use 'profile.enable()'/'.disable()', '@profile' to decorate functions, or 'with profile:' to profile a section of code.
+      --config CONFIG       Path to the TOML file, from the `tool.line_profiler.kernprof`
+                            table of which to load defaults for the options. (Default:
+                            'pyproject.toml')
+      --no-config           Disable the loading of configuration files other than the
+                            default one
+
+    profiling options:
+      --line-by-line [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            Use the line-by-line profiler instead of cProfile. Implies
+                            `--builtin`. (Default: False; short form: -l)
+      --builtin [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            Put `profile` in the builtins. Use
+                            `profile.enable()`/`.disable()` to toggle profiling,
+                            `@profile` to decorate functions, or `with profile:` to
+                            profile a section of code. (Default: False; short form: -b)
+      -s, --setup SETUP     Path to the Python source file containing setup code to
+                            execute before the code to profile. (Default: N/A)
+      -p, --prof-mod PROF_MOD
+                            List of modules, functions and/or classes to profile specified
+                            by their name or path. These profiling targets can be supplied
+                            both as comma-separated items, or separately with multiple
+                            copies of this flag. Packages are automatically recursed into
+                            unless they are specified with `<pkg>.__init__`. Adding the
+                            current script/module profiles the entirety of it. Only works
+                            with line profiling (`-l`/`--line-by-line`). (Default: N/A;
+                            pass an empty string to clear the defaults (or any `-p` target
+                            specified earlier)
+      ---preimports [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            Instead of eagerly importing all profiling targets specified
+                            via `-p` and profiling them, only profile those that are
+                            directly imported in the profiled code. Only works with
+                            line profiling (`-l`/`--line-by-line`). (Default: False)
+                            Eagerly import all profiling targets specified via `-p` and
+                            profile them, instead of only profiling those that are
+                            directly imported in the profiled code. Only works with line
+                            profiling (`-l`/`--line-by-line`). (Default: True)
+      --prof-imports [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            If the script/module profiled is in `--prof-mod`, autoprofile
+                            all its imports. Only works with line profiling (`-l`/`--line-
+                            by-line`). (Default: False)
+
+    output options:
       -o, --outfile OUTFILE
-                            Save stats to <outfile> (default: 'scriptname.lprof' with --line-by-line, 'scriptname.prof' without)
-      -s, --setup SETUP     Code to execute before the code to profile
+                            Save stats to OUTFILE. (Default:
+                            '<script_or_module_name>.lprof' in line-profiling mode
+                            (`-l`/`--line-by-line`); '<script_or_module_name>.prof'
+                            otherwise)
       -v, --verbose, --view
-                            Increase verbosity level. At level 1, view the profiling results in addition to saving them; at level 2, show other diagnostic info.
-      -q, --quiet           Decrease verbosity level. At level -1, disable helpful messages (e.g. "Wrote profile results to <...>"); at level -2, silence the stdout; at level -3,
-                            silence the stderr.
-      -r, --rich            Use rich formatting if viewing output
-      -u, --unit UNIT       Output unit (in seconds) in which the timing info is displayed (default: 1e-6)
-      -z, --skip-zero       Hide functions which have not been called
+                            Increase verbosity level (default: 0). At level 1, view the
+                            profiling results in addition to saving them; at level 2,
+                            show other diagnostic info.
+      -q, --quiet           Decrease verbosity level (default: 0). At level -1, disable
+                            helpful messages (e.g. "Wrote profile results to <...>"); at
+                            level -2, silence the stdout; at level -3, silence the stderr.
+      --rich [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            Use rich formatting if viewing output. (Default: False; short
+                            form: -r)
+      -u, --unit UNIT       Output unit (in seconds) in which the timing info is
+                            displayed. (Default: 1e-06 s)
+      --skip-zero [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            Hide functions which have not been called. (Default: False;
+                            short form: -z)
       -i, --output-interval [OUTPUT_INTERVAL]
-                            Enables outputting of cumulative profiling results to file every n seconds. Uses the threading module. Minimum value is 1 (second). Defaults to
-                            disabled.
-      -p, --prof-mod {path/to/script | object.dotted.path}[,...]
-                            List of modules, functions and/or classes to profile specified by their name or path. These profiling targets can be supplied both as comma-separated
-                            items, or separately with multiple copies of this flag. Packages are automatically recursed into unless they are specified with `<pkg>.__init__`. Adding
-                            the current script/module profiles the entirety of it. Only works with line_profiler -l, --line-by-line.
-      --no-preimports       Instead of eagerly importing all profiling targets specified via -p and profiling them, only profile those that are directly imported in the profiled
-                            code. Only works with line_profiler -l, --line-by-line.
-      --prof-imports        If specified, modules specified to `--prof-mod` will also autoprofile modules that they import. Only works with line_profiler -l, --line-by-line
+                            Enables outputting of cumulative profiling results to OUTFILE
+                            every OUTPUT_INTERVAL seconds. Uses the threading module.
+                            Minimum value (and the value implied if the bare option is
+                            given) is 1 s. (Default: 0 s (disabled))
 
 NOTE:
 
@@ -127,7 +181,7 @@ def main():
 
     To restore the old behavior, pass the :option:`!--no-preimports`
     flag.
-"""
+"""  # noqa: E501
 import atexit
 import builtins
 import functools
@@ -141,7 +195,7 @@ def main():
 import tempfile
 import time
 import warnings
-from argparse import ArgumentError, ArgumentParser
+from argparse import ArgumentParser
 from io import StringIO
 from operator import methodcaller
 from runpy import run_module
@@ -162,6 +216,11 @@ def main():
 except ImportError:
     from profile import Profile  # type: ignore[assignment,no-redef]
 
+import line_profiler
+from line_profiler.cli_utils import (
+    add_argument, get_cli_config,
+    get_python_executable as _python_command,  # Compatibility
+    positive_float, short_string_path)
 from line_profiler.profiler_mixin import ByCountProfilerMixin
 from line_profiler._logger import Logger
 from line_profiler import _diagnostics as diagnostics
@@ -217,7 +276,7 @@ class RepeatedTimer:
 
     References:
         .. [SO474528] https://stackoverflow.com/questions/474528/execute-function-every-x-seconds/40965385#40965385
-    """
+    """  # noqa: E501
     def __init__(self, interval, dump_func, outfile):
         self._timer = None
         self.interval = interval
@@ -235,7 +294,8 @@ def _run(self):
     def start(self):
         if not self.is_running:
             self.next_call += self.interval
-            self._timer = threading.Timer(self.next_call - time.time(), self._run)
+            self._timer = threading.Timer(self.next_call - time.time(),
+                                          self._run)
             self._timer.start()
             self.is_running = True
 
@@ -244,7 +304,7 @@ def stop(self):
         self.is_running = False
 
 
-def find_module_script(module_name):
+def find_module_script(module_name, *, exit_on_error=True):
     """Find the path to the executable script for a module or package."""
     from line_profiler.autoprofile.util_static import modname_to_modpath
 
@@ -253,11 +313,15 @@ def find_module_script(module_name):
         if fname:
             return fname
 
-    sys.stderr.write('Could not find module %s\n' % module_name)
-    raise SystemExit(1)
+    msg = f'Could not find module `{module_name}`'
+    if exit_on_error:
+        print(msg, file=sys.stderr)
+        raise SystemExit(1)
+    else:
+        raise ModuleNotFoundError(msg)
 
 
-def find_script(script_name, exit_on_error=True):
+def find_script(script_name, *, exit_on_error=True):
     """ Find the script.
 
     If the input is not a file, then :envvar:`PATH` will be searched.
@@ -280,16 +344,6 @@ def find_script(script_name, exit_on_error=True):
         raise FileNotFoundError(msg)
 
 
-def _python_command():
-    """
-    Return a command that corresponds to :py:data:`sys.executable`.
-    """
-    for abbr in 'python', 'python3':
-        if os.path.samefile(shutil.which(abbr), sys.executable):
-            return abbr
-    return sys.executable
-
-
 def _normalize_profiling_targets(targets):
     """
     Normalize the parsed :option:`!--prof-mod` by:
@@ -298,6 +352,8 @@ def _normalize_profiling_targets(targets):
       subsequently to absolute paths.
     * Splitting non-file paths at commas into (presumably) file paths
       and/or dotted paths.
+    * Allowing paths specified earlier to be invalidated by an empty
+      string.
     * Removing duplicates.
     """
     def find(path):
@@ -309,6 +365,9 @@ def find(path):
 
     results = {}
     for chunk in targets:
+        if not chunk:
+            results.clear()
+            continue
         filename = find(chunk)
         if filename is not None:
             results.setdefault(filename)
@@ -490,80 +549,120 @@ def pre_parse_single_arg_directive(args, flag, sep='--'):
     return args, thing, post_args
 
 
-def positive_float(value):
-    val = float(value)
-    if val <= 0:
-        raise ArgumentError
-    return val
-
-
 def no_op(*_, **__) -> None:
     pass
 
 
 def _add_core_parser_arguments(parser):
     """
-    Add the core kernprof args to a ArgumentParser
+    Add the core kernprof args to a
+    :py:class:`~argparse.ArgumentParser`.
     """
-    parser.add_argument('-V', '--version', action='version', version=__version__)
-    parser.add_argument('-l', '--line-by-line', action='store_true',
-                        help='Use the line-by-line profiler instead of cProfile. Implies --builtin.')
-    parser.add_argument('-b', '--builtin', action='store_true',
-                        help="Put 'profile' in the builtins. Use 'profile.enable()'/'.disable()', "
-                        "'@profile' to decorate functions, or 'with profile:' to profile a "
-                        'section of code.')
-    parser.add_argument('-o', '--outfile',
-                        help="Save stats to <outfile> (default: 'scriptname.lprof' with "
-                        "--line-by-line, 'scriptname.prof' without)")
-    parser.add_argument('-s', '--setup',
-                        help='Code to execute before the code to profile')
-    parser.add_argument('-v', '--verbose', '--view',
-                        action='count', default=0,
-                        help='Increase verbosity level. '
-                        'At level 1, view the profiling results '
-                        'in addition to saving them; '
-                        'at level 2, show other diagnostic info.')
-    parser.add_argument('-q', '--quiet',
-                        action='count', default=0,
-                        help='Decrease verbosity level. '
-                        'At level -1, disable helpful messages '
-                        '(e.g. "Wrote profile results to <...>"); '
-                        'at level -2, silence the stdout; '
-                        'at level -3, silence the stderr.')
-    parser.add_argument('-r', '--rich', action='store_true',
-                        help='Use rich formatting if viewing output')
-    parser.add_argument('-u', '--unit', default='1e-6', type=positive_float,
-                        help='Output unit (in seconds) in which the timing info is '
-                        'displayed (default: 1e-6)')
-    parser.add_argument('-z', '--skip-zero', action='store_true',
-                        help="Hide functions which have not been called")
-    parser.add_argument('-i', '--output-interval', type=int, default=0, const=0, nargs='?',
-                        help="Enables outputting of cumulative profiling results to file every n seconds. Uses the threading module. "
-                        "Minimum value is 1 (second). Defaults to disabled.")
-    parser.add_argument('-p', '--prof-mod',
-                        action='append',
-                        metavar=("{path/to/script | object.dotted.path}"
-                                 "[,...]"),
-                        help="List of modules, functions and/or classes "
-                        "to profile specified by their name or path. "
-                        "These profiling targets can be supplied both as "
-                        "comma-separated items, or separately with "
-                        "multiple copies of this flag. "
-                        "Packages are automatically recursed into unless "
-                        "they are specified with `<pkg>.__init__`. "
-                        "Adding the current script/module profiles the "
-                        "entirety of it. "
-                        "Only works with line_profiler -l, --line-by-line.")
-    parser.add_argument('--no-preimports',
-                        action='store_true',
-                        help="Instead of eagerly importing all profiling "
-                        "targets specified via -p and profiling them, "
-                        "only profile those that are directly imported in "
-                        "the profiled code. "
-                        "Only works with line_profiler -l, --line-by-line.")
-    parser.add_argument('--prof-imports', action='store_true',
-                        help="If specified, modules specified to `--prof-mod` will also autoprofile modules that they import. "
-                        "Only works with line_profiler -l, --line-by-line")
+    defaults, default_source = get_cli_config('kernprof')
+    add_argument(parser, '-V', '--version',
+                 action='version', version=__version__)
+    add_argument(parser, '--config',
+                 help='Path to the TOML file, from the '
+                 '`tool.line_profiler.kernprof` table of which to load '
+                 'defaults for the options. '
+                 f'(Default: {short_string_path(default_source)!r})')
+    add_argument(parser, '--no-config',
+                 action='store_const', dest='config', const=False,
+                 help='Disable the loading of configuration files other '
+                 'than the default one')
+    prof_opts = parser.add_argument_group('profiling options')
+    add_argument(prof_opts, '-l', '--line-by-line', action='store_true',
+                 help='Use the line-by-line profiler instead of cProfile. '
+                 'Implies `--builtin`. '
+                 f'(Default: {defaults["line_by_line"]})')
+    add_argument(prof_opts, '-b', '--builtin', action='store_true',
+                 help="Put `profile` in the builtins. "
+                 "Use `profile.enable()`/`.disable()` to "
+                 "toggle profiling, "
+                 "`@profile` to decorate functions, "
+                 "or `with profile:` to profile a section of code. "
+                 f"(Default: {defaults['builtin']})")
+    if defaults['setup']:
+        def_setupfile = repr(defaults['setup'])
+    else:
+        def_setupfile = 'N/A'
+    add_argument(prof_opts, '-s', '--setup',
+                 help='Path to the Python source file containing setup '
+                 'code to execute before the code to profile. '
+                 f'(Default: {def_setupfile})')
+    if defaults['prof_mod']:
+        def_prof_mod = repr(defaults['prof_mod'])
+    else:
+        def_prof_mod = 'N/A'
+    add_argument(prof_opts, '-p', '--prof-mod', action='append',
+                 help="List of modules, functions and/or classes to profile "
+                 "specified by their name or path. These profiling targets "
+                 "can be supplied both as comma-separated items, or "
+                 "separately with multiple copies of this flag. Packages "
+                 "are automatically recursed into unless they are specified "
+                 "with `<pkg>.__init__`. Adding the current script/module "
+                 "profiles the entirety of it. Only works with line "
+                 "profiling (`-l`/`--line-by-line`). "
+                 f"(Default: {def_prof_mod}; "
+                 "pass an empty string to clear the defaults (or any `-p` "
+                 "target specified earlier))")
+    add_argument(prof_opts, '--preimports', action='store_true',
+                 help="Eagerly import all profiling targets specified via "
+                 "`-p` and profile them, instead of only profiling those "
+                 "that are directly imported in the profiled code. "
+                 "Only works with line profiling (`-l`/`--line-by-line`). "
+                 f"(Default: {defaults['preimports']})")
+    add_argument(prof_opts, '--prof-imports', action='store_true',
+                 help="If the script/module profiled is in `--prof-mod`, "
+                 "autoprofile all its imports. "
+                 "Only works with line profiling (`-l`/`--line-by-line`). "
+                 f"(Default: {defaults['prof_imports']})")
+    out_opts = parser.add_argument_group('output options')
+    if defaults['outfile']:
+        def_outfile = repr(defaults['outfile'])
+    else:
+        def_outfile = (
+            "'<script_or_module_name>.lprof' in line-profiling mode "
+            "(`-l`/`--line-by-line`); "
+            "'<script_or_module_name>.prof' otherwise")
+    add_argument(out_opts, '-o', '--outfile',
+                 help=f'Save stats to OUTFILE. (Default: {def_outfile})')
+    add_argument(out_opts, '-v', '--verbose', '--view',
+                 action='count', default=defaults['verbose'],
+                 help="Increase verbosity level "
+                 f"(default: {defaults['verbose']}). "
+                 "At level 1, view the profiling results in addition to "
+                 "saving them; "
+                 "at level 2, show other diagnostic info.")
+    add_argument(out_opts, '-q', '--quiet',
+                 action='count', default=0,
+                 help='Decrease verbosity level '
+                 f"(default: {defaults['verbose']}). "
+                 'At level -1, disable '
+                 'helpful messages (e.g. "Wrote profile results to <...>"); '
+                 'at level -2, silence the stdout; '
+                 'at level -3, silence the stderr.')
+    add_argument(out_opts, '-r', '--rich', action='store_true',
+                 help='Use rich formatting if viewing output. '
+                 f'(Default: {defaults["rich"]})')
+    add_argument(out_opts, '-u', '--unit', type=positive_float,
+                 help='Output unit (in seconds) in which '
+                 'the timing info is displayed. '
+                 f'(Default: {defaults["unit"]} s)')
+    add_argument(out_opts, '-z', '--skip-zero', action='store_true',
+                 help="Hide functions which have not been called. "
+                 f"(Default: {defaults['skip_zero']})")
+    if defaults['output_interval']:
+        def_out_int = f'{defaults["output_interval"]} s'
+    else:
+        def_out_int = '0 s (disabled)'
+    add_argument(out_opts, '-i', '--output-interval',
+                 type=int, const=1, nargs='?',
+                 help="Enables outputting of cumulative profiling results "
+                 "to OUTFILE every OUTPUT_INTERVAL seconds. "
+                 "Uses the threading module. "
+                 "Minimum value (and the value implied if the bare option "
+                 f"is given) is 1 s. (Default: {def_out_int})")
 
 
 def _build_parsers(args=None):
@@ -606,12 +705,13 @@ def _build_parsers(args=None):
         _add_core_parser_arguments(parser)
 
         if parser is help_parser or module is literal_code is None:
-            parser.add_argument('script',
-                                metavar='{path/to/script'
-                                ' | -m path.to.module | -c "literal code"}',
-                                help='The python script file, module, or '
-                                'literal code to run')
-        parser.add_argument('args', nargs='...', help='Optional script arguments')
+            add_argument(parser, 'script',
+                         metavar='{path/to/script'
+                         ' | -m path.to.module | -c "literal code"}',
+                         help='The python script file, module, or '
+                         'literal code to run')
+        add_argument(parser, 'args',
+                     nargs='...', help='Optional script arguments')
     special_info = {
         'module': module,
         'literal_code': literal_code,
@@ -621,7 +721,8 @@ def _build_parsers(args=None):
     return real_parser, help_parser, special_info
 
 
-def _parse_arguments(real_parser, help_parser, special_info, args):
+def _parse_arguments(
+        real_parser, help_parser, special_info, args, exit_on_error):
 
     module = special_info['module']
     literal_code = special_info['literal_code']
@@ -629,17 +730,41 @@ def _parse_arguments(real_parser, help_parser, special_info, args):
 
     # Hand off to the dummy parser if necessary to generate the help
     # text
-    options = SimpleNamespace(**vars(real_parser.parse_args(args)))
+    try:
+        options = SimpleNamespace(**vars(real_parser.parse_args(args)))
+    except SystemExit as e:
+        # If `exit_on_error` is true, let `SystemExit` bubble up and
+        # kill the interpretor;
+        # else, catch and handle it more gracefully
+        # (Note: can't use `ArgumentParser(exit_on_error=False)` in
+        # Python 3.8)
+        if exit_on_error:
+            raise
+        elif e.code:
+            raise RuntimeError from None
+        else:
+            return
     # TODO: make flags later where appropriate
     options.dryrun = diagnostics.NO_EXEC
     options.static = diagnostics.STATIC_ANALYSIS
     if help_parser and getattr(options, 'help', False):
         help_parser.print_help()
-        exit()
+        if exit_on_error:
+            raise SystemExit(0)
+        else:
+            return
+
+    # Parse the provided config file (if any), and resolve the values
+    # of the un-specified options
     try:
         del options.help
     except AttributeError:
         pass
+    defaults, options.config = get_cli_config('kernprof', options.config)
+    for key, default in defaults.items():
+        if getattr(options, key, None) is None:
+            setattr(options, key, default)
+
     # Add in the pre-partitioned arguments cut off by `-m <module>` or
     # `-c <script>`
     options.args += post_args
@@ -678,13 +803,15 @@ def _parse_arguments(real_parser, help_parser, special_info, args):
             options.rich = False
             diagnostics.log.debug('`rich` not installed, unsetting --rich')
 
+    diagnostics.log.debug(
+        f'Loaded configs from {short_string_path(options.config)!r}')
     return options, tempfile_source_and_content
 
 
 @_restore.sequence(sys.argv)
 @_restore.sequence(sys.path)
 @_restore.instance_dict(diagnostics)
-def main(args=None):
+def main(args=None, *, exit_on_error=True):
     """
     Runs the command line interface
 
@@ -698,7 +825,7 @@ def main(args=None):
     module = special_info['module']
 
     options, tempfile_source_and_content = _parse_arguments(
-        real_parser, help_parser, special_info, args)
+        real_parser, help_parser, special_info, args, exit_on_error)
 
     if module is not None:
         diagnostics.log.debug(f'Profiling module: {module}')
@@ -706,7 +833,8 @@ def main(args=None):
         diagnostics.log.debug(
             f'Profiling script read from: {tempfile_source_and_content[0]}')
     else:
-        diagnostics.log.debug(f'Profiling script: {options.script!r}')
+        diagnostics.log.debug(
+            f'Profiling script: {short_string_path(options.script)!r}')
 
     with contextlib.ExitStack() as stack:
         enter = stack.enter_context
@@ -733,7 +861,7 @@ def main(args=None):
                 cleanup()
                 raise
         try:
-            _main_profile(options, module)
+            _main_profile(options, module, exit_on_error)
         except BaseException:
             # Defer deletion to after the traceback has been formatted
             # if needs be
@@ -774,7 +902,8 @@ def _write_tempfile(source, content, options):
     fname = os.path.join(options.tmpdir, file_prefix + '.py')
     with open(fname, mode='w') as fobj:
         print(content, file=fobj)
-    diagnostics.log.debug(f'Wrote temporary script file to {fname!r}:')
+    diagnostics.log.debug(
+        f'Wrote temporary script file to {short_string_path(fname)!r}:')
     options.script = fname
     # Add the tempfile to `--prof-mod`
     if options.prof_mod:
@@ -789,7 +918,8 @@ def _write_tempfile(source, content, options):
                                           prefix=file_prefix + '-',
                                           suffix='.' + extension)
         diagnostics.log.debug(
-            f'Using default output destination {options.outfile!r}')
+            'Using default output destination '
+            f'{short_string_path(options.outfile)!r}')
 
 
 def _gather_preimport_targets(options, exclude):
@@ -869,7 +999,8 @@ def _write_preimports(prof, options, exclude):
         with temp_file as fobj:
             print(code, file=fobj)
         diagnostics.log.debug(
-            f'Wrote temporary module for pre-imports to {temp_mod_path!r}')
+            'Wrote temporary module for pre-imports to '
+            f'{short_string_path(temp_mod_path)!r}')
     else:
         with temp_file as fobj:
             write_eager_import_module(stream=fobj, **write_module_kwargs)
@@ -963,7 +1094,7 @@ def _call_with_diagnostics(options, func, *args, **kwargs):
     return func(*args, **kwargs)
 
 
-def _pre_profile(options, module):
+def _pre_profile(options, module, exit_on_error):
     """
     Prepare the environment to execute profiling with requested options.
 
@@ -974,7 +1105,8 @@ def _pre_profile(options, module):
         extension = 'lprof' if options.line_by_line else 'prof'
         options.outfile = f'{os.path.basename(options.script)}.{extension}'
         diagnostics.log.debug(
-            f'Using default output destination {options.outfile!r}')
+            'Using default output destination '
+            f'{short_string_path(options.outfile)!r}')
 
     sys.argv = [options.script] + options.args
     if module:
@@ -983,21 +1115,21 @@ def _pre_profile(options, module):
         # Note: this NEEDS to happen here, before the setup script (or
         # any other code) has a chance to `os.chdir()`
         sys.path.insert(0, os.path.abspath(os.curdir))
-    if options.setup is not None:
+    if options.setup:
         # Run some setup code outside of the profiler. This is good for large
         # imports.
-        setup_file = find_script(options.setup)
+        setup_file = find_script(options.setup, exit_on_error=exit_on_error)
         # Make sure the script's directory is on sys.path instead of just
         # kernprof.py's.
         sys.path.insert(0, os.path.dirname(setup_file))
         ns = {'__file__': setup_file, '__name__': '__main__'}
         diagnostics.log.debug(
-            f'Executing file {setup_file!r} as pre-profiling setup')
+            f'Executing file {short_string_path(setup_file)!r} '
+            'as pre-profiling setup')
         if not options.dryrun:
             execfile(setup_file, ns, ns)
 
     if options.line_by_line:
-        import line_profiler
         prof = line_profiler.LineProfiler()
         options.builtin = True
     elif Profile.__module__ == 'profile':
@@ -1006,25 +1138,19 @@ def _pre_profile(options, module):
     else:
         prof = ContextualProfile()
 
-    # If line_profiler is installed, then overwrite the explicit decorator
-    try:
-        import line_profiler
-    except ImportError:  # Shouldn't happen
-        install_profiler = global_profiler = None
-    else:
-        global_profiler = line_profiler.profile
-        install_profiler = global_profiler._kernprof_overwrite
-
-    if global_profiler:
-        install_profiler(prof)
+    # Overwrite the explicit decorator
+    global_profiler = line_profiler.profile
+    install_profiler = global_profiler._kernprof_overwrite
+    install_profiler(prof)
 
     if options.builtin:
         builtins.__dict__['profile'] = prof
 
     if module:
-        script_file = find_module_script(options.script)
+        script_file = find_module_script(options.script,
+                                         exit_on_error=exit_on_error)
     else:
-        script_file = find_script(options.script)
+        script_file = find_script(options.script, exit_on_error=exit_on_error)
         # Make sure the script's directory is on sys.path instead of
         # just kernprof.py's.
         sys.path.insert(0, os.path.dirname(script_file))
@@ -1037,8 +1163,8 @@ def _pre_profile(options, module):
         # them
         options.prof_mod = _normalize_profiling_targets(options.prof_mod)
     if not options.prof_mod:
-        options.no_preimports = True
-    if options.line_by_line and not options.no_preimports:
+        options.preimports = False
+    if options.line_by_line and options.preimports:
         # We assume most items in `.prof_mod` to be import-able without
         # significant side effects, but the same cannot be said if it
         # contains the script file to be run. E.g. the script may not
@@ -1050,19 +1176,20 @@ def _pre_profile(options, module):
     options.global_profiler = global_profiler
     options.install_profiler = install_profiler
     if options.output_interval and not options.dryrun:
-        options.rt = RepeatedTimer(max(options.output_interval, 1), prof.dump_stats, options.outfile)
+        options.rt = RepeatedTimer(max(options.output_interval, 1),
+                                   prof.dump_stats, options.outfile)
     else:
         options.rt = None
     options.original_stdout = sys.stdout
     return script_file, prof
 
 
-def _main_profile(options, module=False):
+def _main_profile(options, module=False, exit_on_error=True):
     """
     Called by :py:func:`main()` for the actual execution and profiling of code
     after initial parsing of options; not to be invoked on its own.
     """
-    script_file, prof = _pre_profile(options, module)
+    script_file, prof = _pre_profile(options, module, exit_on_error)
     try:
         rmod = functools.partial(run_module,
                                  run_name='__main__', alter_sys=True)
@@ -1077,20 +1204,18 @@ def _main_profile(options, module=False):
                 prof_mod=options.prof_mod,
                 profile_imports=options.prof_imports,
                 as_module=module is not None)
-        elif module and options.builtin:
-            _call_with_diagnostics(options, rmod, options.script, ns)
-        elif options.builtin:
-            _call_with_diagnostics(options, execfile, script_file, ns, ns)
-        elif module:
-            _call_with_diagnostics(
-                options,
-                prof.runctx, f'rmod({options.script!r}, globals())',
-                ns, ns)
         else:
-            _call_with_diagnostics(
-                options,
-                prof.runctx, f'execfile({script_file!r}, globals())',
-                ns, ns)
+            if module:
+                runner, target = 'rmod', options.script
+            else:
+                runner, target = 'execfile', script_file
+            assert runner in ns
+            if options.builtin:
+                _call_with_diagnostics(options, ns[runner], target, ns)
+            else:
+                _call_with_diagnostics(
+                    options, prof.runctx,
+                    f'{runner}({target!r}, globals())', ns, ns)
     finally:
         _post_profile(options, prof)
 
@@ -1103,11 +1228,12 @@ def _post_profile(options, prof):
         options.rt.stop()
     if not options.dryrun:
         _dump_filtered_stats(options.tmpdir, prof, options.outfile)
+    short_outfile = short_string_path(options.outfile)
     diagnostics.log.info(
         ('Profile results would have been written to '
          if options.dryrun else
          'Wrote profile results ')
-        + f'to {options.outfile!r}')
+        + f'to {short_outfile!r}')
     if options.verbose > 0 and not options.dryrun:
         if isinstance(prof, ContextualProfile):
             prof.print_stats()
@@ -1115,7 +1241,8 @@ def _post_profile(options, prof):
             prof.print_stats(output_unit=options.unit,
                              stripzeros=options.skip_zero,
                              rich=options.rich,
-                             stream=options.original_stdout)
+                             stream=options.original_stdout,
+                             config=options.config)
     else:
         py_exe = _python_command()
         if isinstance(prof, ContextualProfile):
@@ -1124,7 +1251,7 @@ def _post_profile(options, prof):
             show_mod = 'line_profiler -rmt'
         diagnostics.log.info('Inspect results with:\n'
                              f'{quote(py_exe)} -m {show_mod} '
-                             f'{quote(options.outfile)}')
+                             f'{quote(short_outfile)}')
     # Fully disable the profiler
     for _ in range(prof.enable_count):
         prof.disable_by_count()
@@ -1134,4 +1261,4 @@ def _post_profile(options, prof):
 
 
 if __name__ == '__main__':
-    main(sys.argv[1:])
+    main()
diff --git a/line_profiler/cli_utils.py b/line_profiler/cli_utils.py
new file mode 100644
index 00000000..e4fc0a46
--- /dev/null
+++ b/line_profiler/cli_utils.py
@@ -0,0 +1,279 @@
+"""
+Shared utilities between the `python -m line_profiler` and `kernprof`
+CLI tools.
+"""
+import argparse
+import functools
+import os
+import pathlib
+import shutil
+import sys
+from .toml_config import get_config
+
+
+_BOOLEAN_VALUES = {**{k.casefold(): False
+                      for k in ('', '0', 'off', 'False', 'F', 'no', 'N')},
+                   **{k.casefold(): True
+                      for k in ('1', 'on', 'True', 'T', 'yes', 'Y')}}
+
+
+def add_argument(parser_like, arg, /, *args,
+                 hide_complementary_options=True, **kwargs):
+    """
+    Override the 'store_true' and 'store_false' actions so that they
+    are turned into options which:
+    - Don't set the default to the opposite boolean, thus allowing us to
+      later distinguish between cases where the flag has been passed or
+      not, and
+    - Set the destination value to the corresponding value in the no-arg
+      form, but also allow (for long options) for a single arg which is
+      parsed by :py:func:`.boolean()`.
+    Also automatically generates complementary boolean options for
+    ``action='store_true'`` options.
+    If ``hide_complementary_options`` is
+    true, the auto-generated option (all the long flags prefixed
+    with 'no-', e.g. '--foo' is negated by '--no-foo') is hidden
+    from the help text.
+
+    Arguments:
+        parser_like (Any):
+            Object having a method ``add_argument()``, which has the
+            same semantics and call signature as
+            ``ArgumentParser.add_argument()``.
+        hide_complementary_options (bool):
+            Whether to hide the auto-generated complementary options to
+            ``action='store_true'`` options from the help text for
+            brevity.
+        arg, *args, **kwargs
+            Passed to ``parser_like.add_argument()``
+
+    Returns:
+        action_like (Any):
+            Return value of ``parser_like.add_argument()``
+
+    Notes:
+        * Short and long flags for 'store_true' and 'store_false'
+          actions are implemented in separate actions so as to allow for
+          short-flag concatenation.
+        * If an option has both short and long flags, the short-flag
+          action is hidden from the help text, but the long-flag
+          action's help text is updated to mention the corresponding
+          short flag(s).
+    """
+    def negate_result(func):
+        @functools.wraps(func)
+        def negated(*args, **kwargs):
+            return not func(*args, **kwargs)
+
+        negated.__name__ = 'negated_' + negated.__name__
+        return negated
+
+    # Make sure there's at least one positional argument
+    args = [arg, *args]
+
+    if kwargs.get('action') not in ('store_true', 'store_false'):
+        return parser_like.add_argument(*args, **kwargs)
+
+    # Long and short boolean flags should be handled separately: short
+    # flags should remain 0-arg to permit flag concatenation, while long
+    # flag should be able to take an optional arg parsable into a bool
+    prefix_chars = tuple(parser_like.prefix_chars)
+    short_flags = []
+    long_flags = []
+    for arg in args:
+        assert arg.startswith(prefix_chars)
+        if arg.startswith(tuple(char * 2 for char in prefix_chars)):
+            long_flags.append(arg)
+        else:
+            short_flags.append(arg)
+
+    kwargs['const'] = const = kwargs.pop('action') == 'store_true'
+    for key, value in dict(
+            default=None,
+            metavar='Y[es] | N[o] | T[rue] | F[alse] '
+            '| on | off | 1 | 0').items():
+        kwargs.setdefault(key, value)
+    long_kwargs = kwargs.copy()
+    short_kwargs = {**kwargs, 'action': 'store_const'}
+    for key, value in dict(
+            nargs='?',
+            type=functools.partial(boolean, invert=not const)).items():
+        long_kwargs.setdefault(key, value)
+
+    # Mention the short options in the long options' documentation, and
+    # suppress the short options in the help
+    if (
+            long_flags
+            and short_flags
+            and long_kwargs.get('help') != argparse.SUPPRESS):
+        additional_msg = 'Short {}: {}'.format(
+            'form' if len(short_flags) == 1 else 'forms',
+            ', '.join(short_flags))
+        if long_kwargs.get('help'):
+            help_text = long_kwargs['help'].strip()
+            if help_text.endswith((')', ']')):
+                # Interpolate into existing parenthetical
+                help_text = '{}; {}{}{}'.format(
+                    help_text[:-1],
+                    additional_msg[0].lower(),
+                    additional_msg[1:],
+                    help_text[-1])
+            else:
+                help_text = f'{help_text} ({additional_msg})'
+            long_kwargs['help'] = help_text
+        else:
+            long_kwargs['help'] = f'({additional_msg})'
+        short_kwargs['help'] = argparse.SUPPRESS
+
+    long_action = short_action = None
+    if long_flags:
+        long_action = parser_like.add_argument(*long_flags, **long_kwargs)
+        short_kwargs['dest'] = long_action.dest
+    if short_flags:
+        short_action = parser_like.add_argument(*short_flags, **short_kwargs)
+    if long_action:
+        action = long_action
+    else:
+        assert short_action
+        action = short_action
+    if not (const and long_flags):  # Negative or short-only flag
+        return action
+
+    # Automatically generate a complementary option for a long boolean
+    # option
+    # (in Python 3.9+ one can use `argparse.BooleanOptionalAction`,
+    # but we want to maintain compatibility with Python 3.8)
+    if hide_complementary_options:
+        falsy_help_text = argparse.SUPPRESS
+    else:
+        falsy_help_text = 'Negate these flags: ' + ', '.join(args)
+    parser_like.add_argument(
+        *(flag[:2] + 'no-' + flag[2:] for flag in long_flags),
+        **{**long_kwargs,
+           'const': False,
+           'dest': action.dest,
+           'type': negate_result(action.type),
+           'help': falsy_help_text})
+    return action
+
+
+def get_cli_config(subtable, /, *args, **kwargs):
+    """
+    Get the ``tool.line_profiler.<subtable>`` configs and normalize
+    its keys (``some-key`` -> ``some_key``).
+
+    Arguments:
+        subtable (str):
+            Name of the subtable the CLI app should refer to (e.g.
+            'kernprof')
+        *args, **kwargs
+            Passed to ``line_profiler.toml_config.get_config()``
+
+    Returns:
+        subconf_dict, path (tuple[dict, Path])
+            - ``subconf_dict``: the combination of the
+              ``tool.line_profiler.<subtable>`` subtables of the
+              provided/looked-up config file (if any) and the default as
+              a dictionary
+            - ``path``: absolute path to the config file whence the
+              config options are loaded
+    """
+    conf, source = get_config(*args, **kwargs)
+    cli_conf = {key.replace('-', '_'): value
+                for key, value in conf[subtable].items()}
+    return cli_conf, source
+
+
+def get_python_executable():
+    """
+    Returns:
+        command (str)
+            Command or path thereto corresponding to ``sys.executable``.
+    """
+    if os.path.samefile(shutil.which('python'), sys.executable):
+        return 'python'
+    elif os.path.samefile(shutil.which('python3'), sys.executable):
+        return 'python3'
+    else:
+        return short_string_path(sys.executable)
+
+
+def positive_float(value):
+    """
+    Arguments:
+        value (str)
+
+    Returns:
+        x (float > 0)
+    """
+    val = float(value)
+    if val <= 0:
+        # Note: parsing functions should raise either a `ValueError` or
+        # a `TypeError` instead of an `argparse.ArgumentError`, which
+        # expects extra context and in general should be raised by the
+        # parser object
+        raise ValueError
+    return val
+
+
+def boolean(value, *, fallback=None, invert=False):
+    """
+    Arguments:
+        value (str)
+            Value to be parsed into a boolean (case insensitive)
+        fallback (Union[bool, None])
+            Optional value to fall back to in case ``value`` doesn't
+            match any of the specified
+        invert (bool)
+            If ``True``, invert the result of parsing ``value`` (but not
+            ``fallback``)
+
+    Returns:
+        b (bool)
+
+    Notes:
+        These values are parsed into ``False``:
+
+        * The empty string
+        * ``'0'``, ``'F'``, ``'N'``
+        * ``'off'``, ``'False'``, ``'no'``
+
+        And these into ``True``:
+
+        * ``'1'``, ``'T'``, ``'Y'``
+        * ``'on'``, ``'True'``, ``'yes'``
+    """
+    try:
+        result = _BOOLEAN_VALUES[value.casefold()]
+    except KeyError:
+        pass
+    else:
+        return (not result) if invert else result
+    if fallback is None:
+        raise ValueError(f'value = {value!r}: '
+                         'cannot be parsed into a boolean; valid values are'
+                         f'({{string: bool}}): {_BOOLEAN_VALUES!r}')
+    return fallback
+
+
+def short_string_path(path):
+    """
+    Arguments:
+        path (Union[str, PurePath]):
+            Path-like
+
+    Returns:
+        short_path (str):
+            The shortest formatted ``path`` among the provided path, the
+            corresponding absolute path, and its relative path to the
+            current directory.
+    """
+    path = pathlib.Path(path)
+    paths = {str(path)}
+    abspath = path.absolute()
+    paths.add(str(abspath))
+    try:
+        paths.add(str(abspath.relative_to(path.cwd().absolute())))
+    except ValueError:  # Not relative to the curdir
+        pass
+    return min(paths, key=len)
diff --git a/line_profiler/cli_utils.pyi b/line_profiler/cli_utils.pyi
new file mode 100644
index 00000000..c9fd2143
--- /dev/null
+++ b/line_profiler/cli_utils.pyi
@@ -0,0 +1,57 @@
+"""
+Shared utilities between the `python -m line_profiler` and `kernprof`
+CLI tools.
+"""
+import argparse
+import pathlib
+from typing import Protocol, Sequence, Tuple, TypeVar, Union
+
+
+A_co = TypeVar('A_co', bound='ActionLike', covariant=True)
+
+
+class ActionLike(Protocol):
+    def __call__(self, parser: 'ParserLike',
+                 namespace: argparse.Namespace,
+                 values: Sequence,
+                 option_string: Union[str, None] = None) -> None:
+        ...
+
+    def format_usage(self) -> str:
+        ...
+
+
+class ParserLike(Protocol[A_co]):
+    def add_argument(self, arg: str, /, *args: str, **kwargs) -> A_co:
+        ...
+
+    @property
+    def prefix_chars(self) -> str:
+        ...
+
+
+def add_argument(parser_like: ParserLike[A_co], arg: str, /, *args: str,
+                 hide_complementary_options: bool = True, **kwargs) -> A_co:
+    ...
+
+
+def get_cli_config(subtable: str, /,
+                   *args, **kwargs) -> Tuple[dict, pathlib.Path]:
+    ...
+
+
+def get_python_executable() -> str:
+    ...
+
+
+def positive_float(value: str) -> float:
+    ...
+
+
+def boolean(value: str, *,
+            fallback: Union[bool, None] = None, invert: bool = False) -> bool:
+    ...
+
+
+def short_string_path(path: Union[str, pathlib.PurePath]) -> str:
+    ...
diff --git a/line_profiler/explicit_profiler.py b/line_profiler/explicit_profiler.py
index 936f6805..48e7dcad 100644
--- a/line_profiler/explicit_profiler.py
+++ b/line_profiler/explicit_profiler.py
@@ -162,13 +162,13 @@ def func4():
 
 The core functionality in this module was ported from :mod:`xdev`.
 """
-from .line_profiler import LineProfiler
-import sys
-import os
 import atexit
-
-
-_FALSY_STRINGS = {'', '0', 'off', 'false', 'no'}
+import os
+import sys
+# This is for compatibility
+from .cli_utils import boolean, get_python_executable as _python_command
+from .line_profiler import LineProfiler
+from .toml_config import get_config
 
 
 class GlobalProfiler:
@@ -177,22 +177,46 @@ class GlobalProfiler:
 
     The :py:obj:`line_profile.profile` decorator is an instance of this object.
 
+    Arguments:
+        config (Union[str, PurePath, bool, None]):
+            Optional TOML config file from which to load the
+            configurations (see Attributes);
+            if not explicitly given (= ``True`` or ``None``), it is
+            either resolved from the ``LINE_PROFILER_RC`` environment
+            variable or looked up among the current directory or its
+            ancestors.  Should all that fail, the default config file at
+            ``importlib.resources.path('line_profiler.rc',
+            'line_profiler.toml')``
+            is used;
+            passing ``False`` disables all lookup and falls back to the
+            default configuration
+
     Attributes:
         setup_config (Dict[str, List[str]]):
             Determines how the implicit setup behaves by defining which
             environment variables / command line flags to look for.
+            Defaults to the ``[tool.line_profiler.setup]`` table of the
+            loaded config file.
 
         output_prefix (str):
             The prefix of any output files written. Should include
-            a part of a filename. Defaults to "profile_output".
+            a part of a filename. Defaults to the ``output_prefix``
+            value in the ``[tool.line_profiler.write]`` table of the
+            loaded config file.
 
         write_config (Dict[str, bool]):
-            Which outputs are enabled. All default to True.
-            Options are lprof, text, timestamped_text, and stdout.
+            Which outputs are enabled;
+            options are lprof, text, timestamped_text, and stdout.
+            Defaults to the rest of the ``[tool.line_profiler.write]``
+            table of the loaded config file.
 
         show_config (Dict[str, bool]):
-            Display configuration options. Some outputs force certain options.
-            (e.g. text always has details and is never rich).
+            Display configuration options;
+            some outputs force certain options (e.g. text always has
+            details and is never rich).
+            Defaults to the rest of the ``[tool.line_profiler.show]``
+            table of the loaded config file, excluding the
+            ``[tool.line_profiler.show.column_widths]`` subtable.
 
         enabled (bool | None):
             True if the profiler is enabled (i.e. if it will wrap a function
@@ -212,12 +236,12 @@ class GlobalProfiler:
         >>> self.write_config['timestamped_text'] = False
         >>> # Demo data: a function to profile
         >>> def collatz(n):
-        >>>     while n != 1:
-        >>>         if n % 2 == 0:
-        >>>             n = n // 2
-        >>>         else:
-        >>>             n = 3 * n + 1
-        >>>     return n
+        ...     while n != 1:
+        ...         if n % 2 == 0:
+        ...             n = n // 2
+        ...         else:
+        ...             n = 3 * n + 1
+        ...     return n
         >>> # Disabled by default, implicitly checks to auto-enable on first wrap
         >>> assert self.enabled is None
         >>> wrapped = self(collatz)
@@ -233,31 +257,26 @@ class GlobalProfiler:
         >>> self.show()
     """
 
-    def __init__(self):
-        self.setup_config = {
-            'environ_flags': ['LINE_PROFILE'],
-            'cli_flags': ['--line-profile', '--line_profile'],
-        }
-        self.output_prefix = 'profile_output'
+    def __init__(self, config=None):
+        # Remember which config file we loaded settings from
+        conf_dict, self._config = get_config(config=config)
+
         self._profile = None
         self.enabled = None
 
-        # Control which outputs will be written on exit
-        self.write_config = {
-            'lprof': True,
-            'text': True,
-            'timestamped_text': True,
-            'stdout': True,
-        }
-
-        # Configuration for how output will be displayed
-        self.show_config = {
-            'sort': 1,
-            'stripzeros': 1,
-            'rich': 1,
-            'details': 0,
-            'summarize': 1,
-        }
+        # Configs:
+        # - How to toggle the profiler
+        self.setup_config = conf_dict['setup']
+        # - Which outputs to write on exit
+        self.write_config = conf_dict['write']
+        # - Whither to write output files
+        self.output_prefix = self.write_config.pop('output_prefix')
+        # - How output will be displayed
+        self.show_config = conf_dict['show']
+        # (This is not stored here nor is accepted by any method, but is
+        # re-parsed by `LineProfiler.print_stats()` etc. from the
+        # supplied `config`)
+        self.show_config.pop('column_widths')
 
     def _kernprof_overwrite(self, profile):
         """
@@ -277,7 +296,7 @@ def _implicit_setup(self):
         """
         environ_flags = self.setup_config['environ_flags']
         cli_flags = self.setup_config['cli_flags']
-        is_profiling = any(os.environ.get(f, '').lower() not in _FALSY_STRINGS
+        is_profiling = any(boolean(os.environ.get(f, ''), fallback=True)
                            for f in environ_flags)
         is_profiling |= any(f in sys.argv for f in cli_flags)
         if is_profiling:
@@ -340,21 +359,19 @@ def show(self):
         import io
         import pathlib
 
-        srite_stdout = self.write_config['stdout']
+        write_stdout = self.write_config['stdout']
         write_text = self.write_config['text']
         write_timestamped_text = self.write_config['timestamped_text']
         write_lprof = self.write_config['lprof']
 
-        if srite_stdout:
-            kwargs = self.show_config.copy()
+        if write_stdout:
+            kwargs = {'config': self._config, **self.show_config}
             self._profile.print_stats(**kwargs)
 
         if write_text or write_timestamped_text:
             stream = io.StringIO()
             # Text output always contains details, and cannot be rich.
-            text_kwargs = self.show_config.copy()
-            text_kwargs['rich'] = 0
-            text_kwargs['details'] = 1
+            text_kwargs = {**kwargs, 'rich': False, 'details': True}
             self._profile.print_stats(stream=stream, **text_kwargs)
             raw_text = stream.getvalue()
 
@@ -367,7 +384,8 @@ def show(self):
                 from datetime import datetime as datetime_cls
                 now = datetime_cls.now()
                 timestamp = now.strftime('%Y-%m-%dT%H%M%S')
-                txt_output_fpath2 = pathlib.Path(f'{self.output_prefix}_{timestamp}.txt')
+                txt_output_fpath2 = pathlib.Path(
+                    f'{self.output_prefix}_{timestamp}.txt')
                 txt_output_fpath2.write_text(raw_text, encoding='utf-8')
                 print('Wrote profile results to %s' % txt_output_fpath2)
 
@@ -377,20 +395,8 @@ def show(self):
             print('Wrote profile results to %s' % lprof_output_fpath)
             print('To view details run:')
             py_exe = _python_command()
-            print(py_exe + ' -m line_profiler -rtmz ' + str(lprof_output_fpath))
-
-
-def _python_command():
-    """
-    Return a command that corresponds to :py:obj:`sys.executable`.
-    """
-    import shutil
-    if shutil.which('python') == sys.executable:
-        return 'python'
-    elif shutil.which('python3') == sys.executable:
-        return 'python3'
-    else:
-        return sys.executable
+            print(py_exe + ' -m line_profiler -rtmz '
+                  + str(lprof_output_fpath))
 
 
 # Construct the global profiler.
diff --git a/line_profiler/explicit_profiler.pyi b/line_profiler/explicit_profiler.pyi
index 00ac48da..f777689b 100644
--- a/line_profiler/explicit_profiler.pyi
+++ b/line_profiler/explicit_profiler.pyi
@@ -1,6 +1,8 @@
+from pathlib import PurePath
 from typing import Dict
 from typing import List
 from typing import Callable
+from typing import Union
 from _typeshed import Incomplete
 
 
@@ -11,7 +13,8 @@ class GlobalProfiler:
     show_config: Dict[str, bool]
     enabled: bool | None
 
-    def __init__(self) -> None:
+    def __init__(self,
+                 config: Union[str, PurePath, bool, None] = None) -> None:
         ...
 
     def enable(self, output_prefix: Incomplete | None = ...) -> None:
diff --git a/line_profiler/line_profiler.py b/line_profiler/line_profiler.py
index 5c7c40ea..bcb8d585 100755
--- a/line_profiler/line_profiler.py
+++ b/line_profiler/line_profiler.py
@@ -12,7 +12,7 @@
 import sys
 import tempfile
 import types
-from argparse import ArgumentError, ArgumentParser
+from argparse import ArgumentParser
 from datetime import datetime
 
 try:
@@ -23,14 +23,23 @@
         f'Has it been compiled? Underlying error is ex={ex!r}'
     )
 from . import _diagnostics as diagnostics
+from .cli_utils import (
+    add_argument, get_cli_config, positive_float, short_string_path)
 from .profiler_mixin import ByCountProfilerMixin, is_c_level_callable
 from .scoping_policy import ScopingPolicy
+from .toml_config import get_config
 
 
 # NOTE: This needs to be in sync with ../kernprof.py and __init__.py
 __version__ = '4.3.0'
 
 
+@functools.lru_cache()
+def get_minimum_column_widths():
+    return types.MappingProxyType(
+        get_config(False)[0]['show']['column_widths'])
+
+
 def load_ipython_extension(ip):
     """ API for IPython to recognize this module as an IPython extension.
     """
@@ -63,10 +72,10 @@ class LineProfiler(CLineProfiler, ByCountProfilerMixin):
         >>> import line_profiler
         >>> profile = line_profiler.LineProfiler()
         >>> @profile
-        >>> def func():
-        >>>     x1 = list(range(10))
-        >>>     x2 = list(range(100))
-        >>>     x3 = list(range(1000))
+        ... def func():
+        ...     x1 = list(range(10))
+        ...     x2 = list(range(100))
+        ...     x3 = list(range(1000))
         >>> func()
         >>> profile.print_stats()
     """
@@ -172,13 +181,15 @@ def dump_stats(self, filename):
             pickle.dump(lstats, f, pickle.HIGHEST_PROTOCOL)
 
     def print_stats(self, stream=None, output_unit=None, stripzeros=False,
-                    details=True, summarize=False, sort=False, rich=False):
+                    details=True, summarize=False, sort=False, rich=False, *,
+                    config=None):
         """ Show the gathered statistics.
         """
         lstats = self.get_stats()
         show_text(lstats.timings, lstats.unit, output_unit=output_unit,
                   stream=stream, stripzeros=stripzeros,
-                  details=details, summarize=summarize, sort=sort, rich=rich)
+                  details=details, summarize=summarize, sort=sort, rich=rich,
+                  config=config)
 
     def _add_namespace(
             self, namespace, *,
@@ -373,21 +384,23 @@ def is_generated_code(filename):
 
 
 def show_func(filename, start_lineno, func_name, timings, unit,
-              output_unit=None, stream=None, stripzeros=False, rich=False):
+              output_unit=None, stream=None, stripzeros=False, rich=False,
+              *,
+              config=None):
     """
     Show results for a single function.
 
     Args:
         filename (str):
-            path to the profiled file
+            Path to the profiled file
 
         start_lineno (int):
-            first line number of profiled function
+            First line number of profiled function
 
         func_name (str): name of profiled function
 
         timings (List[Tuple[int, int, float]]):
-            measurements for each line (lineno, nhits, time).
+            Measurements for each line (lineno, nhits, time).
 
         unit (float):
             The number of seconds used as the cython LineProfiler's unit.
@@ -396,13 +409,22 @@ def show_func(filename, start_lineno, func_name, timings, unit,
             Output unit (in seconds) in which the timing info is displayed.
 
         stream (io.TextIOBase | None):
-            defaults to sys.stdout
+            Defaults to sys.stdout
 
         stripzeros (bool):
-            if True, prints nothing if the function was not run
+            If True, prints nothing if the function was not run
 
         rich (bool):
-            if True, attempt to use rich highlighting.
+            If True, attempt to use rich highlighting.
+
+        config (Union[str, PurePath, bool, None]):
+            Optional filename from which to load configurations (e.g.
+            output column widths);
+            default (= `True` or `None`) is to look for a config file
+            based on the environment variable `${LINE_PROFILER_RC}` and
+            path-based lookup;
+            passing `False` disables all lookup and falls back to the
+            default configuration
 
     Example:
         >>> from line_profiler.line_profiler import show_func
@@ -415,18 +437,18 @@ def show_func(filename, start_lineno, func_name, timings, unit,
         >>> # Build fake timeings for each line in the example function
         >>> import inspect
         >>> num_lines = len(inspect.getsourcelines(func)[0])
-        >>> line_numbers = list(range(start_lineno + 3, start_lineno + num_lines))
-        >>> timings = [
-        >>>     (lineno, idx * 1e13, idx * (2e10 ** (idx % 3)))
-        >>>     for idx, lineno in enumerate(line_numbers, start=1)
-        >>> ]
+        >>> line_numbers = list(range(start_lineno + 3,
+        ...                           start_lineno + num_lines))
+        >>> timings = [(lineno, idx * 1e13, idx * (2e10 ** (idx % 3)))
+        ...            for idx, lineno
+        ...            in enumerate(line_numbers, start=1)]
         >>> unit = 1.0
         >>> output_unit = 1.0
         >>> stream = None
         >>> stripzeros = False
         >>> rich = 1
         >>> show_func(filename, start_lineno, func_name, timings, unit,
-        >>>           output_unit, stream, stripzeros, rich)
+        ...           output_unit, stream, stripzeros, rich)
     """
     if stream is None:
         stream = sys.stdout
@@ -475,13 +497,10 @@ def show_func(filename, start_lineno, func_name, timings, unit,
         sublines = [''] * nlines
 
     # Define minimum column sizes so text fits and usually looks consistent
+    conf_column_sizes = get_config(config)[0]['show']['column_widths']
     default_column_sizes = {
-        'line': 6,
-        'hits': 9,
-        'time': 12,
-        'perhit': 8,
-        'percent': 8,
-    }
+        col: max(width, conf_column_sizes.get(col, width))
+        for col, width in get_minimum_column_widths().items()}
 
     display = {}
 
@@ -554,16 +573,14 @@ def show_func(filename, start_lineno, func_name, timings, unit,
 
         # Use a table to horizontally concatenate the text
         # reference: https://github.com/Textualize/rich/discussions/3076
-        table = Table(
-            box=None,
-            padding=0,
-            collapse_padding=True,
-            show_header=False,
-            show_footer=False,
-            show_edge=False,
-            pad_edge=False,
-            expand=False,
-        )
+        table = Table(box=None,
+                      padding=0,
+                      collapse_padding=True,
+                      show_header=False,
+                      show_footer=False,
+                      show_edge=False,
+                      pad_edge=False,
+                      expand=False)
         table.add_row(lhs, '  ', rhs)
 
         # Use a Console to render to the stream
@@ -591,7 +608,8 @@ def show_func(filename, start_lineno, func_name, timings, unit,
 
 
 def show_text(stats, unit, output_unit=None, stream=None, stripzeros=False,
-              details=True, summarize=False, sort=False, rich=False):
+              details=True, summarize=False, sort=False, rich=False, *,
+              config=None):
     """
     Show text for the given timings.
 
@@ -620,12 +638,15 @@ def show_text(stats, unit, output_unit=None, stream=None, stripzeros=False,
         # Default ordering
         stats_order = sorted(stats.items())
 
+    # Pre-lookup the appropriate config file
+    _, config = get_config(config)
+
     if details:
         # Show detailed per-line information for each function.
         for (fn, lineno, name), timings in stats_order:
             show_func(fn, lineno, name, stats[fn, lineno, name], unit,
                       output_unit=output_unit, stream=stream,
-                      stripzeros=stripzeros, rich=rich)
+                      stripzeros=stripzeros, rich=rich, config=config)
 
     if summarize:
         # Summarize the total time for each function
@@ -667,56 +688,58 @@ def main():
     """
     The line profiler CLI to view output from :command:`kernprof -l`.
     """
-    def positive_float(value):
-        val = float(value)
-        if val <= 0:
-            raise ArgumentError
-        return val
-
-    parser = ArgumentParser()
-    parser.add_argument('-V', '--version', action='version', version=__version__)
-    parser.add_argument(
-        '-u',
-        '--unit',
-        default='1e-6',
-        type=positive_float,
-        help='Output unit (in seconds) in which the timing info is displayed (default: 1e-6)',
-    )
-    parser.add_argument(
-        '-z',
-        '--skip-zero',
-        action='store_true',
-        help='Hide functions which have not been called',
-    )
-    parser.add_argument(
-        '-r',
-        '--rich',
-        action='store_true',
-        help='Use rich formatting',
-    )
-    parser.add_argument(
-        '-t',
-        '--sort',
-        action='store_true',
-        help='Sort by ascending total time',
-    )
-    parser.add_argument(
-        '-m',
-        '--summarize',
-        action='store_true',
-        help='Print a summary of total function time',
-    )
-    parser.add_argument('profile_output', help='*.lprof file created by kernprof')
+    parser = ArgumentParser(
+        description='Read and show line profiling results (`.lprof` files) '
+        'as generated by the CLI application `kernprof` or by '
+        '`LineProfiler.dump_stats()`.')
+    get_main_config = functools.partial(get_cli_config, 'cli')
+    defaults, default_source = get_main_config()
+
+    add_argument(parser, '-V', '--version',
+                 action='version', version=__version__)
+    add_argument(parser, '-c', '--config',
+                 help='Path to the TOML file, from the '
+                 '`tool.line_profiler.cli` table of which to load '
+                 'defaults for the options. '
+                 f'(Default: {short_string_path(default_source)!r})')
+    add_argument(parser, '--no-config',
+                 action='store_const', dest='config', const=False,
+                 help='Disable the loading of configuration files other than '
+                 'the default one')
+    add_argument(parser, '-u', '--unit', type=positive_float,
+                 help='Output unit (in seconds) in which '
+                 'the timing info is displayed. '
+                 f'(Default: {defaults["unit"]} s)')
+    add_argument(parser, '-r', '--rich', action='store_true',
+                 help='Use rich formatting. '
+                 f'(Default: {defaults["rich"]})')
+    add_argument(parser, '-z', '--skip-zero', action='store_true',
+                 help='Hide functions which have not been called. '
+                 f'(Default: {defaults["skip_zero"]})')
+    add_argument(parser, '-t', '--sort', action='store_true',
+                 help='Sort by ascending total time. '
+                 f'(Default: {defaults["rich"]})')
+    add_argument(parser, '-m', '--summarize', action='store_true',
+                 help='Print a summary of total function time. '
+                 f'(Default: {defaults["skip_zero"]})')
+    add_argument(parser, 'profile_output',
+                 help="'*.lprof' file created by `kernprof`")
 
     args = parser.parse_args()
+    if args.config:
+        defaults, args.config = get_main_config(args.config)
+    for key, default in defaults.items():
+        if getattr(args, key, None) is None:
+            setattr(args, key, default)
+
     lstats = load_stats(args.profile_output)
-    show_text(
-        lstats.timings, lstats.unit, output_unit=args.unit,
-        stripzeros=args.skip_zero,
-        rich=args.rich,
-        sort=args.sort,
-        summarize=args.summarize,
-    )
+    show_text(lstats.timings, lstats.unit,
+              output_unit=args.unit,
+              stripzeros=args.skip_zero,
+              rich=args.rich,
+              sort=args.sort,
+              summarize=args.summarize,
+              config=args.config)
 
 
 if __name__ == '__main__':
diff --git a/line_profiler/line_profiler.pyi b/line_profiler/line_profiler.pyi
index 89a0fa3a..89ed421e 100644
--- a/line_profiler/line_profiler.pyi
+++ b/line_profiler/line_profiler.pyi
@@ -1,7 +1,10 @@
 import io
+import pathlib
 from functools import cached_property, partial, partialmethod
 from types import FunctionType, MethodType, ModuleType
-from typing import overload, Callable, List, Literal, Tuple, TypeVar
+from typing import (overload,
+                    Callable, List, Literal, Mapping, Tuple,
+                    TypeVar, Union)
 from _typeshed import Incomplete
 from ._line_profiler import LineProfiler as CLineProfiler
 from .profiler_mixin import ByCountProfilerMixin, CLevelCallable
@@ -14,6 +17,11 @@ CallableLike = TypeVar('CallableLike',
                        type)
 
 
+def get_minimum_column_widths() -> Mapping[
+        Literal['line', 'hits', 'time', 'perhit', 'percent'], int]:
+    ...
+
+
 def load_ipython_extension(ip) -> None:
     ...
 
@@ -51,7 +59,10 @@ class LineProfiler(CLineProfiler, ByCountProfilerMixin):
                     details: bool = ...,
                     summarize: bool = ...,
                     sort: bool = ...,
-                    rich: bool = ...) -> None:
+                    rich: bool = ...,
+                    *,
+                    config: Union[str, pathlib.PurePath,
+                                  bool, None] = None) -> None:
         ...
 
     def add_module(
@@ -81,7 +92,9 @@ def show_func(filename: str,
               output_unit: float | None = None,
               stream: io.TextIOBase | None = None,
               stripzeros: bool = False,
-              rich: bool = False) -> None:
+              rich: bool = False,
+              *,
+              config: Union[str, pathlib.PurePath, bool, None] = None) -> None:
     ...
 
 
@@ -93,7 +106,9 @@ def show_text(stats,
               details: bool = ...,
               summarize: bool = ...,
               sort: bool = ...,
-              rich: bool = ...):
+              rich: bool = ...,
+              *,
+              config: Union[str, pathlib.PurePath, bool, None] = None) -> None:
     ...
 
 
diff --git a/line_profiler/rc/__init__.py b/line_profiler/rc/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/line_profiler/rc/line_profiler.toml b/line_profiler/rc/line_profiler.toml
new file mode 100644
index 00000000..57bf12c5
--- /dev/null
+++ b/line_profiler/rc/line_profiler.toml
@@ -0,0 +1,205 @@
+########################################################################
+#
+# Sample configuration file
+# =========================
+#
+# This file provides defaults for the behaviors of the CLI application
+# `kernprof`, the executable module `line_profiler`, and the class
+# `line_profiler.GlobalProfiler`.
+# Users can customize said behaviors by writing a suitable configuation
+# file in the TOML syntax (https://toml.io/en/latest).
+#
+# Namespacing
+# -----------
+#
+# All options read by `line_profiler` live under the
+# `tool.line_profiler` namespace. The same applies no matter if reading
+# from a `line_profiler.toml`, `pyproject.toml`, or other user-specified
+# file.
+#
+# Naming scheme
+# -------------
+#
+# - `tool.line_profiler.kernprof` (resp. `.cli`) items:
+#   Same as the corresponding `kernprof` (resp.
+#   `python -m line_profiler`) CLI options, minus the leading '--'.
+# - `tool.line_profiler.setup` (resp. `.write`, `.show`) items:
+#   Same as the corresponding `GlobalProfiler.setup_config` (resp.
+#   `.write_config`, `.show_config`) key-value pairs, except for:
+#   - `tool.line_profiler.write.output_prefix`:
+#     Not a part of `GlobalProfiler.write_config`, but rather the
+#     default value for `GlobalProfiler.output_prefix`.
+#   - `tool.line_profiler.show.column_widths`:
+#     Not a part of `GlobalProfiler.show_config`, but rather controls
+#     the column widths in outputs (see below).
+# - `tool.line_profiler.show.column_widths` items:
+#   - `line`: Line number
+#   - `hits`: Number of line hits
+#   - `time`: Total time spent on the line
+#   - `perhit`: Mean time spent per hit
+#   - `percent`: % time spent on the line (relative to the func/method)
+#
+# Resolution order
+# ----------------
+#
+# - Lookup for either of these two files starts from the current
+#   directory: `line_profiler.toml` or `pyproject.toml`. In case when
+#   both are present, the former takes priority.
+# - If the current directory
+#   - Doesn't contain such a file; or if
+#   - None of them is a (1) valid and (2) readable TOML config file,
+#   we look in the parent directory for a config file, and so on.
+# - If we have reached the file-system root without finding a readable
+#   config file, this default file is used.
+#
+# ### Notes
+#
+# - To explicitly specify the config file and skip lookup, the user can:
+#   - Set the `${LINE_PROFILER_RC}` environment variable to be the path
+#     to the appropriate config file.
+#   - For the CLI applications `kernprof` and `python -m line_profiler`,
+#     it is also possible to supply the config file via the
+#     `-c`/`--config` flag.
+# - The first looked-up file that is readable TOML (possibly empty) is
+#   used;
+#   it doesn't matter if it contains the `tool.line_profiler` namespace.
+# - If any option is missing from the specified or looked-up file, its
+#   default value (as defined here) is used.
+#
+########################################################################
+
+# `kernprof` options
+
+[tool.line_profiler.kernprof]
+
+# - Boolean flags
+#   - `line-by-line` (bool):
+#      `-l`/`--line-by-line` (true) or `--no-line-by-line` (false)
+line-by-line = false
+#   - `builtin` (bool):
+#      `-b`/`--builtin` (true) or `--no-builtin` (false)
+builtin = false
+#   - `rich` (bool):
+#     `-r`/`--rich` (true) or `--no-rich` (false)
+rich = false
+#   - `skip-zero` (bool):
+#     `-z`/`--skip-zero` (true) or `--no-skip-zero` (false)
+skip-zero = false
+#   - `preimports` (bool):
+#     `--preimports` (true) or `--no-preimports` (false)
+preimports = true
+#   - `prof-imports` (bool):
+#     `--prof-imports` (true) or `--no-prof-imports` (false)
+prof-imports = false
+
+# - Misc flags
+#   - `verbose` (count):
+#     `-v`/`--verbose`/`--view` (incrementing) or `-q`/`--quiet`
+#     (decrementing): output verbosity of `kernprof`
+verbose = 0
+#   - `outfile` (str):
+#     `--outfile=...`; filename to which to `LineProfiler.dump_stats()`
+#     the profiling results (use an empty string to fall back to the
+#     default, which depends on the script/module profiled)
+outfile = ""
+#   - `setup` (str):
+#     `--setup=...`: filename from which to read setup code (if any)
+#     before running the main script/module
+setup = ""
+#   - `unit` (float):
+#     `--unit=...`: timer unit for the displayed profiling results when
+#     `view` is true
+unit = 1e-6
+#   - `output-interval` (int):
+#     `--output-interval=...`: interval in which partial profiling
+#     results are written to `outfile` (set to 0 to only write when the
+#     code finishes running/errors out)
+output-interval = 0
+#   - `prof-mod` (list[str]):
+#     `--prof-mod`: filenames and dotted import paths (modules,
+#     functions, or classes) to be profiled if imported in the profiled
+#     script/module
+prof-mod = []
+
+# `python -m line_profiler` options
+
+[tool.line_profiler.cli]
+
+# - `unit` (float):
+#   `--unit=...`: timer unit for the displayed profiling results when
+#   `view` is true
+unit = 1e-6
+# - `rich` (bool):
+#   `-r`/`--rich` (true) or `--no-rich` (false)
+rich = false
+# - `skip-zero` (bool):
+#   `-z`/`--skip-zero` (true) or `--no-skip-zero` (false)
+skip-zero = false
+# - `sort` (bool):
+#   `-t`/`--sort` (true) or `--no-sort` (false)
+sort = false
+# - `summarize` (bool):
+#   `-m`/`--summarize` (true) or `--no-summarize` (false)
+summarize = false
+
+# `line_profiler.GlobalProfiler` options
+
+[tool.line_profiler.setup]
+
+# - `GlobalProfiler.setup_config` key-value pairs
+#   - `environ_flags` (list[str]):
+#     If any of these environment variables is set to a "non-falsy"
+#     value, the `GlobalProfiler` is `.enable()`-ed
+environ_flags = ["LINE_PROFILE"]
+#   - `cli_flags` (list[str]):
+#     If any of these strings is present verbatim as a positional
+#     argument, the `GlobalProfiler` is `.enable()`-ed
+cli_flags = ["--line-profile", "--line_profile"]
+
+[tool.line_profiler.write]
+
+# - `GlobalProfiler` attributes
+#   - `output_prefix` (str):
+#     Common base-name prefix to the output files specified in this
+#     subtable
+output_prefix = 'profile_output'
+
+# - `GlobalProfiler.write_config` key-value pairs
+#   - `lprof` (bool):
+#     Whether to `LineProfiler.dump_stats()` to an `.lprof` file
+lprof = true
+#   - `text` (bool):
+#     Whether to `LineProfiler.print_stats()` to a `.txt` file
+text = true
+#   - `timestamped_text` (bool):
+#     Whether to `LineProfiler.print_stats()` to a `.txt` file with a
+#     timestamp in the filename
+timestamped_text = true
+#   - `stdout` (bool):
+#     Whether to `LineProfiler.print_stats()` to the stdout
+stdout = true 
+
+[tool.line_profiler.show]
+
+# - `GlobalProfiler.show_config` key-value pairs
+#   (booleans; refer to the synonymous arguments of
+#   `LineProfiler.print_stats()`)
+#   (Note: doesn't include the `column_widths` subtable below)
+sort = true
+stripzeros = true
+rich = true
+details = false
+summarize = true
+
+# `line_profiler.line_profiler.show_text()` column widths
+# (Note: the values below are also the minima; it is only possible to
+# supply bigger widths, not smaller ones)
+
+[tool.line_profiler.show.column_widths]
+
+# (See the file header for their meanings)
+line = 6
+hits = 9
+time = 12
+perhit = 8
+percent = 8
diff --git a/line_profiler/toml_config.py b/line_profiler/toml_config.py
new file mode 100644
index 00000000..46ebb27e
--- /dev/null
+++ b/line_profiler/toml_config.py
@@ -0,0 +1,280 @@
+"""
+Read and resolve user-supplied TOML files and combine them with the
+default to generate configurations.
+"""
+import copy
+import functools
+import importlib.resources
+import itertools
+import os
+import pathlib
+try:
+    import tomllib
+except ImportError:  # Python < 3.11
+    import tomli as tomllib
+from collections.abc import Mapping
+
+
+__all__ = ['get_config', 'get_default_config']
+
+namespace = 'tool', 'line_profiler'
+targets = 'line_profiler.toml', 'pyproject.toml'
+env_var = 'LINE_PROFILER_RC'
+
+_defaults = None
+
+
+def find_and_read_config_file(
+        *, config=None, env_var=env_var, targets=targets):
+    """
+    Arguments:
+        config (Union[str, PurePath, None]):
+            Optional path to a specific TOML file;
+            if provided, skip lookup and just try to read from that file
+        env_var (Union[str, None]):
+            Name of the of the environment variable containing the path
+            to a TOML file;
+            if true-y and if `config` isn't provided, skip lookup and
+            just try to read from that file
+        targets (Sequence[str | PurePath]):
+            Filenames among which TOML files are looked up (if neither
+            `config` or `env_var` is given)
+
+    Return:
+        If the provided/looked-up file is readable and is valid TOML:
+            content, path (tuple[dict, Path]):
+            - `content`: parsed content of the file as a dictionary
+            - `path`: absolute path to the file
+        Otherwise
+            None
+    """
+    def iter_configs(dir_path):
+        for dpath in itertools.chain((dir_path,), dir_path.parents):
+            for target in targets:
+                cfg = dpath / target
+                try:
+                    if cfg.is_file():
+                        yield cfg
+                except OSError:  # E.g. permission errors
+                    pass
+
+    if config:
+        configs = pathlib.Path(config).absolute(),
+    elif env_var and os.environ.get(env_var):
+        configs = pathlib.Path(os.environ[env_var]).absolute(),
+    else:
+        pwd = pathlib.Path.cwd().absolute()
+        configs = iter_configs(pwd)
+    for config in configs:
+        try:
+            with config.open(mode='rb') as fobj:
+                return tomllib.load(fobj), config
+        except (OSError, tomllib.TOMLDecodeError):
+            pass
+    return None
+
+
+def get_subtable(table, keys, *, allow_absence=True):
+    """
+    Arguments:
+        table (Mapping):
+            (Nested) Mapping.
+        keys (Sequence):
+            Sequence of keys for item access on `table` and its
+            descendant tables.
+        allow_absence (bool):
+            If true, allow for the keys to be absent;
+            otherwise, raise a `KeyError`.
+
+    Return:
+        subtable (Mapping)
+
+    Example:
+
+        >>> table = {'a': 1, 'b': {'c': 2, 'd': 3, 'e': {}}}
+        >>> assert get_subtable(table, []) == table
+        >>> assert get_subtable(table, ['b']) == table['b']
+        >>> assert get_subtable(table, ['b', 'e']) == table['b']['e']
+        >>> assert get_subtable(table, ['c']) == {}
+        >>> get_subtable(table, ['c'], allow_absence=False)
+        Traceback (most recent call last):
+          ...
+        KeyError: 'c'
+        >>> get_subtable(  # doctest: +ELLIPSIS, +NORMALIZE_WHITESPACE
+        ...     table, ['a'])
+        Traceback (most recent call last):
+          ...
+        TypeError: table = ..., keys = ['a']:
+        expected result to be a mapping, got a `int` (1)
+    """
+    subtable = table
+    for key in keys:
+        if allow_absence:
+            subtable = subtable.get(key, {})
+        else:
+            subtable = subtable[key]
+    if not isinstance(subtable, Mapping):
+        raise TypeError(f'table = {table!r}, keys = {list(keys)!r}: '
+                        'expected result to be a mapping, got a '
+                        f'`{type(subtable).__name__}` ({subtable!r})')
+    return subtable
+
+
+def get_headers(table, *, include_implied=False):
+    """
+    Arguments:
+        table (Mapping):
+            (Nested) Mapping.
+        include_implied (bool):
+            if false and if a subtable has other subtables, only the
+            terminal key sequences are returned (that is to say, if
+            `table['a']['b']` is a subtable, then `('a',)` is only in
+            `headers` if `include_implied` is true.
+
+    Return:
+        headers (set[tuple]):
+            Key sequences corresponding to the subtables of `table`.
+
+    Example:
+
+        >>> table = {'a': 1,
+        ...          'b': {'c': 2, 'd': 3, 'e': {}, 'f': {'g': 4}},
+        ...          'h': {'i': 5}}
+        >>> assert get_headers(table) == {
+        ...     ('b', 'e'), ('b', 'f'), ('h',)}
+        >>> assert get_headers(table, include_implied=True) == {
+        ...     ('b',), ('b', 'e'), ('b', 'f'), ('h',)}
+        >>> assert get_headers({}) == set()
+        >>> assert get_headers({'a': 1, 'b': 2}) == set()
+    """
+    results = set()
+    for key, value in table.items():
+        if not isinstance(value, Mapping):
+            continue
+        subheaders = get_headers(value, include_implied=include_implied)
+        if subheaders:
+            results.update((key,) + header for header in subheaders)
+        if include_implied or not subheaders:
+            results.add((key,))
+    return results
+
+
+def get_config(config=None, *, read_env=True):
+    """
+    Arguments:
+        config (Union[str, PurePath, bool, None]):
+            Optional path to a specific TOML file;
+            if a (string) path, skip lookup and just try to read from
+            that file;
+            if `None` or `True`, use lookup to resolve to the correct
+            file;
+            if `False`, skip lookup and just use the default configs
+        read_env (bool):
+            Whether to read the environment variable
+            `${LINE_PROFILER_RC}` for a config file (instead of moving
+            straight onto environment-based lookup) if `config` is not
+            provided.
+
+    Return:
+        conf_dict, path (tuple[dict, Path]):
+            - `conf_dict`: the combination of the `tool.line_profiler`
+              tables of the provided/looked-up config file (if any) and
+              the default as a dictionary
+            - `path`: absolute path to the config file whence the
+              config options are loaded
+
+    Notes:
+        - For the config TOML file, it is required that each of the
+          following keys either is absent or maps to a table:
+          - `tool` and `tool.line_profiler`
+          - `tool.line_profiler.kernprof`, `.cli`, `.setup`, `.write`,
+            and `.show`
+          - `tool.line_profiler.show.column_widths`
+          If this is not the case:
+          - If `config` is provided, a `ValueError` is raised.
+          - Otherwise, the looked-up file is considered invalid and
+            ignored.
+    """
+    def merge(template, supplied):
+        if not (isinstance(template, dict) and isinstance(supplied, dict)):
+            return supplied
+        result = {}
+        for key, default in template.items():
+            if key in supplied:
+                result[key] = merge(default, supplied[key])
+            else:
+                result[key] = default
+        return result
+
+    default_conf, default_source = get_default_config()
+    if config in (True, False):
+        if config:
+            config = None
+        else:
+            return default_conf, default_source
+    if config is not None:
+        # Promote to `Path` (and catch type errors) early
+        config = pathlib.Path(config)
+    if read_env:
+        get_conf = functools.partial(find_and_read_config_file, config=config)
+    else:  # Shield the lookup from the environment
+        get_conf = functools.partial(find_and_read_config_file,
+                                     config=config, env_var=None)
+    try:
+        content, source = get_conf()
+    except TypeError:  # Got `None`
+        if config:
+            if os.path.exists(config):
+                Error = ValueError
+            else:
+                Error = FileNotFoundError
+            raise Error(r'Cannot load configurations from {config!r}') from None
+        return default_conf, default_source
+    conf = {}
+    try:
+        for header in get_headers(default_conf):
+            # Get the top-level subtable
+            key, *subheader = header
+            subtable = get_subtable(content, [*namespace, key])
+            # Check the existence of nested subtables (if any)
+            get_subtable(subtable, subheader)
+            # If it looks OK, remember the top-level subtable
+            conf.setdefault(key, subtable)
+    except (TypeError, AttributeError):
+        if config is None:
+            # No file explicitly provided and the looked-up file is
+            # invalid, just fall back to the default configs
+            return default_conf, default_source
+        else:
+            # The explicitly provided config file is invalid, raise an
+            # error
+            all_headers = {'tool', 'tool.line_profiler'}
+            all_headers.update(
+                '.'.join(('tool.line_profiler', *header))
+                for header in get_headers(default_conf, include_implied=True))
+            raise ValueError(
+                f'config = {config!r}: expected each of these keys to either '
+                'be nonexistent or map to a table: '
+                f'{sorted(all_headers)!r}') from None
+    # Filter the content of `conf` down to just the key-value pairs
+    # pairs present in the default configs
+    return merge(default_conf, conf), source
+
+
+def get_default_config():
+    """
+    Return:
+        conf_dict, path (tuple[dict, Path])
+            - `conf_dict`: the default config file's
+              `tool.line_profiler` table as a dictionary
+            - `path`: absolute path to the default config file
+    """
+    if _defaults is None:
+        package = __spec__.name.rpartition('.')[0]
+        with importlib.resources.path(package + '.rc',
+                                      'line_profiler.toml') as path:
+            conf_dict, source = find_and_read_config_file(config=path)
+        globals()['_defaults'] = (get_subtable(conf_dict, namespace,
+                                               allow_absence=False),
+                                  source)
+    return copy.deepcopy(_defaults[0]), _defaults[1]
diff --git a/line_profiler/toml_config.pyi b/line_profiler/toml_config.pyi
new file mode 100644
index 00000000..2ebd2b10
--- /dev/null
+++ b/line_profiler/toml_config.pyi
@@ -0,0 +1,38 @@
+from pathlib import Path, PurePath
+from typing import Any, Dict, Mapping, Sequence, Set, Tuple, TypeVar, Union
+
+
+targets = 'line_profiler.toml', 'pyproject.toml'
+env_var = 'LINE_PROFILER_RC'
+
+K = TypeVar('K')
+V = TypeVar('V')
+Config = Tuple[Dict[str, Dict[str, Any]], Path]
+NestedTable = Mapping[K, Union['NestedTable[K, V]', V]]
+
+
+def find_and_read_config_file(
+        *,
+        config: Union[str, PurePath, None] = None,
+        env_var: Union[str, None] = env_var,
+        targets: Sequence[Union[str, PurePath]] = targets) -> Config:
+    ...
+
+
+def get_subtable(table: NestedTable[K, V], keys: Sequence[K], *,
+                 allow_absence: bool = True) -> NestedTable[K, V]:
+    ...
+
+
+def get_headers(table: NestedTable[K, Any], *,
+                include_implied: bool = False) -> Set[Tuple[K, ...]]:
+    ...
+
+
+def get_config(config: Union[str, PurePath, bool, None] = None, *,
+               read_env: bool = True) -> Config:
+    ...
+
+
+def get_default_config() -> Config:
+    ...
diff --git a/requirements/runtime.txt b/requirements/runtime.txt
index e69de29b..fe0df55e 100644
--- a/requirements/runtime.txt
+++ b/requirements/runtime.txt
@@ -0,0 +1 @@
+tomli; python_version < '3.11'
diff --git a/setup.py b/setup.py
index cec98395..cde5aa43 100755
--- a/setup.py
+++ b/setup.py
@@ -284,7 +284,10 @@ def run_cythonize(force=False):
     setupkw["py_modules"] = ['kernprof', 'line_profiler']
     setupkw["python_requires"] = ">=3.8"
     setupkw['license_files'] = ['LICENSE.txt', 'LICENSE_Python.txt']
-    setupkw["package_data"] = {"line_profiler": ["py.typed", "*.pyi"]}
+    setupkw["package_data"] = {"line_profiler": ["py.typed", "*.pyi", "*.toml"]}
+    # `include_package_data` is needed to put `rc/line_profiler.toml` in
+    # the wheel
+    setupkw["include_package_data"] = True
     setupkw['keywords'] = ['timing', 'timer', 'profiling', 'profiler', 'line_profiler']
     setupkw["classifiers"] = [
         'Development Status :: 5 - Production/Stable',
diff --git a/tests/test_autoprofile.py b/tests/test_autoprofile.py
index 040ec83d..e283c938 100644
--- a/tests/test_autoprofile.py
+++ b/tests/test_autoprofile.py
@@ -11,181 +11,188 @@
 
 def test_single_function_autoprofile():
     """
-    Test that every function in a file is profiled when autoprofile is enabled.
+    Test that every function in a file is profiled when autoprofile is
+    enabled.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        def func1(a):
-            return a + 1
+        code = ub.codeblock(
+            '''
+            def func1(a):
+                return a + 1
 
-        func1(1)
-        ''')
-    with ub.ChDir(temp_dpath):
+            func1(1)
+            ''')
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
 
-        args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l',
+                    os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-        args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-        proc = ub.cmd(args)
-        raw_output = proc.stdout
-        proc.check_returncode()
+            args = [sys.executable, '-m', 'line_profiler',
+                    os.fspath(script_fpath) + '.lprof']
+            proc = ub.cmd(args)
+            raw_output = proc.stdout
+            proc.check_returncode()
 
-    assert 'func1' in raw_output
-    temp_dpath.delete()
+        assert 'func1' in raw_output
 
 
 def test_multi_function_autoprofile():
     """
-    Test that every function in a file is profiled when autoprofile is enabled.
+    Test that every function in a file is profiled when autoprofile is
+    enabled.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        def func1(a):
-            return a + 1
+        code = ub.codeblock(
+            '''
+            def func1(a):
+                return a + 1
 
-        def func2(a):
-            return a * 2 + 2
+            def func2(a):
+                return a * 2 + 2
 
-        def func3(a):
-            return a / 10 + 3
+            def func3(a):
+                return a / 10 + 3
 
-        def func4(a):
-            return a % 2 + 4
+            def func4(a):
+                return a % 2 + 4
 
-        func1(1)
-        ''')
-    with ub.ChDir(temp_dpath):
-
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
+            func1(1)
+            ''')
+        with ub.ChDir(temp_dpath):
 
-        args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
 
-        args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-        proc = ub.cmd(args)
-        raw_output = proc.stdout
-        proc.check_returncode()
+            args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l',
+                    os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert 'func1' in raw_output
-    assert 'func2' in raw_output
-    assert 'func3' in raw_output
-    assert 'func4' in raw_output
+            args = [sys.executable, '-m', 'line_profiler',
+                    os.fspath(script_fpath) + '.lprof']
+            proc = ub.cmd(args)
+            raw_output = proc.stdout
+            proc.check_returncode()
 
-    temp_dpath.delete()
+        assert 'func1' in raw_output
+        assert 'func2' in raw_output
+        assert 'func3' in raw_output
+        assert 'func4' in raw_output
 
 
 def test_duplicate_function_autoprofile():
     """
-    Test that every function in a file is profiled when autoprofile is enabled.
+    Test that every function in a file is profiled when autoprofile is
+    enabled.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        def func1(a):
-            return a + 1
-
-        def func2(a):
-            return a + 1
+        code = ub.codeblock(
+            '''
+            def func1(a):
+                return a + 1
 
-        def func3(a):
-            return a + 1
+            def func2(a):
+                return a + 1
 
-        def func4(a):
-            return a + 1
+            def func3(a):
+                return a + 1
 
-        func1(1)
-        func2(1)
-        func3(1)
-        ''')
-    with ub.ChDir(temp_dpath):
+            def func4(a):
+                return a + 1
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
+            func1(1)
+            func2(1)
+            func3(1)
+            ''')
+        with ub.ChDir(temp_dpath):
 
-        args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
 
-        args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-        proc = ub.cmd(args)
-        raw_output = proc.stdout
-        print(raw_output)
-        proc.check_returncode()
+            args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l',
+                    os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert 'Function: func1' in raw_output
-    assert 'Function: func2' in raw_output
-    assert 'Function: func3' in raw_output
-    assert 'Function: func4' in raw_output
+            args = [sys.executable, '-m', 'line_profiler',
+                    os.fspath(script_fpath) + '.lprof']
+            proc = ub.cmd(args)
+            raw_output = proc.stdout
+            print(raw_output)
+            proc.check_returncode()
 
-    temp_dpath.delete()
+        assert 'Function: func1' in raw_output
+        assert 'Function: func2' in raw_output
+        assert 'Function: func3' in raw_output
+        assert 'Function: func4' in raw_output
 
 
 def test_async_func_autoprofile():
     """
     Test the profiling of async functions when autoprofile is enabled.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        import asyncio
+        code = ub.codeblock(
+            '''
+            import asyncio
 
 
-        async def foo(l, x, delay=.0625):
-            delay *= x
-            result = (await asyncio.sleep(delay, result=x))
-            l.append(result)
-            return result
+            async def foo(l, x, delay=.0625):
+                delay *= x
+                result = (await asyncio.sleep(delay, result=x))
+                l.append(result)
+                return result
 
 
-        async def bar():
-            l = []
-            coroutines = [foo(l, x) for x in range(5, -1, -1)]
-            return (await asyncio.gather(*coroutines)), l
+            async def bar():
+                l = []
+                coroutines = [foo(l, x) for x in range(5, -1, -1)]
+                return (await asyncio.gather(*coroutines)), l
 
 
-        def main(debug=None):
-            (in_scheduling_order,
-             in_finishing_order) = asyncio.run(bar(), debug=debug)
-            print(in_scheduling_order,  # [5, 4, 3, 2, 1, 0]
-                  in_finishing_order)  # [0, 1, 2, 3, 4, 5]
+            def main(debug=None):
+                (in_scheduling_order,
+                 in_finishing_order) = asyncio.run(bar(), debug=debug)
+                print(in_scheduling_order,  # [5, 4, 3, 2, 1, 0]
+                      in_finishing_order)  # [0, 1, 2, 3, 4, 5]
 
 
-        if __name__ == '__main__':
-            main(debug=True)
-        ''')
-    with ub.ChDir(temp_dpath):
+            if __name__ == '__main__':
+                main(debug=True)
+            ''')
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
 
-        args = [sys.executable, '-m', 'kernprof',
-                '-p', 'script.py', '-v', '-l', os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        raw_output = proc.stdout
-        print(raw_output)
-        print(proc.stderr)
-        proc.check_returncode()
-        assert raw_output.startswith('[5, 4, 3, 2, 1, 0] '
-                                     '[0, 1, 2, 3, 4, 5]')
-    temp_dpath.delete()
+            args = [sys.executable, '-m', 'kernprof',
+                    '-p', 'script.py', '-v', '-l', os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            raw_output = proc.stdout
+            print(raw_output)
+            print(proc.stderr)
+            proc.check_returncode()
+            assert raw_output.startswith('[5, 4, 3, 2, 1, 0] '
+                                         '[0, 1, 2, 3, 4, 5]')
 
     assert 'Function: main' in raw_output
     assert 'Function: foo' in raw_output
@@ -297,51 +304,59 @@ def main():
 
 def test_autoprofile_script_with_module():
     """
-    Test that every function in a file is profiled when autoprofile is enabled.
+    Test that every function in a file is profiled when autoprofile is
+    enabled.
     """
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+        script_fpath = _write_demo_module(temp_dpath)
 
-    script_fpath = _write_demo_module(temp_dpath)
+        # args = [sys.executable, '-m', 'kernprof', '--prof-imports',
+        #         '-p', 'script.py', '-l', os.fspath(script_fpath)]
+        args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l',
+                os.fspath(script_fpath)]
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
 
-    # args = [sys.executable, '-m', 'kernprof', '--prof-imports', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-    args = [sys.executable, '-m', 'kernprof', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
+        args = [sys.executable, '-m', 'line_profiler',
+                os.fspath(script_fpath) + '.lprof']
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
-
-    assert 'Function: add_one' not in raw_output
-    assert 'Function: main' in raw_output
+        assert 'Function: add_one' not in raw_output
+        assert 'Function: main' in raw_output
 
 
 def test_autoprofile_module():
     """
-    Test that every function in a file is profiled when autoprofile is enabled.
+    Test that every function in a file is profiled when autoprofile is
+    enabled.
     """
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-
-    script_fpath = _write_demo_module(temp_dpath)
+        script_fpath = _write_demo_module(temp_dpath)
 
-    # args = [sys.executable, '-m', 'kernprof', '--prof-imports', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-    args = [sys.executable, '-m', 'kernprof', '-p', 'test_mod', '-l', os.fspath(script_fpath)]
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
+        # args = [sys.executable, '-m', 'kernprof', '--prof-imports',
+        #         '-p', 'script.py', '-l', os.fspath(script_fpath)]
+        args = [sys.executable, '-m', 'kernprof', '-p', 'test_mod', '-l',
+                os.fspath(script_fpath)]
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
 
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
+        args = [sys.executable, '-m', 'line_profiler',
+                os.fspath(script_fpath) + '.lprof']
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
     assert 'Function: add_one' in raw_output
     assert 'Function: main' not in raw_output
@@ -349,25 +364,29 @@ def test_autoprofile_module():
 
 def test_autoprofile_module_list():
     """
-    Test only modules specified are autoprofiled
+    Test only modules specified are autoprofiled.
     """
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-
-    script_fpath = _write_demo_module(temp_dpath)
+        script_fpath = _write_demo_module(temp_dpath)
 
-    # args = [sys.executable, '-m', 'kernprof', '--prof-imports', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-    args = [sys.executable, '-m', 'kernprof', '-p', 'test_mod.submod1,test_mod.subpkg.submod3', '-l', os.fspath(script_fpath)]
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
+        # args = [sys.executable, '-m', 'kernprof', '--prof-imports',
+        #         '-p', 'script.py', '-l', os.fspath(script_fpath)]
+        args = [sys.executable, '-m', 'kernprof',
+                '-p', 'test_mod.submod1,test_mod.subpkg.submod3', '-l',
+                os.fspath(script_fpath)]
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
 
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
+        args = [sys.executable, '-m', 'line_profiler',
+                os.fspath(script_fpath) + '.lprof']
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
     assert 'Function: add_one' in raw_output
     assert 'Function: add_two' not in raw_output
@@ -379,20 +398,23 @@ def test_autoprofile_module_with_prof_imports():
     """
     Test the imports of the specified modules are profiled as well.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    script_fpath = _write_demo_module(temp_dpath)
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        script_fpath = _write_demo_module(temp_dpath)
 
-    args = [sys.executable, '-m', 'kernprof', '--prof-imports', '-p', 'test_mod.submod1', '-l', os.fspath(script_fpath)]
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
+        args = [sys.executable, '-m', 'kernprof', '--prof-imports',
+                '-p', 'test_mod.submod1', '-l', os.fspath(script_fpath)]
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
 
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
+        args = [sys.executable, '-m', 'line_profiler',
+                os.fspath(script_fpath) + '.lprof']
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
     assert 'Function: add_one' in raw_output
     assert 'Function: add_operator' in raw_output
@@ -404,32 +426,35 @@ def test_autoprofile_script_with_prof_imports():
     """
     Test the imports of the specified modules are profiled as well.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    script_fpath = _write_demo_module(temp_dpath)
-
-    # import sys
-    # if sys.version_info[0:2] >= (3, 11):
-    #     import pytest
-    #     pytest.skip('Failing due to the noop bug')
-
-    args = [sys.executable, '-m', 'kernprof', '--prof-imports', '-p', 'script.py', '-l', os.fspath(script_fpath)]
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=0)
-    print('Kernprof Stdout:')
-    print(proc.stdout)
-    print('Kernprof Stderr:')
-    print(proc.stderr)
-    print('About to check kernprof return code')
-    proc.check_returncode()
-
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(script_fpath) + '.lprof']
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=0)
-    raw_output = proc.stdout
-    print('Line_profile Stdout:')
-    print(raw_output)
-    print('Line_profile Stderr:')
-    print(proc.stderr)
-    print('About to check line_profiler return code')
-    proc.check_returncode()
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        script_fpath = _write_demo_module(temp_dpath)
+
+        # import sys
+        # if sys.version_info[0:2] >= (3, 11):
+        #     import pytest
+        #     pytest.skip('Failing due to the noop bug')
+
+        args = [sys.executable, '-m', 'kernprof', '--prof-imports',
+                '-p', 'script.py', '-l', os.fspath(script_fpath)]
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=0)
+        print('Kernprof Stdout:')
+        print(proc.stdout)
+        print('Kernprof Stderr:')
+        print(proc.stderr)
+        print('About to check kernprof return code')
+        proc.check_returncode()
+
+        args = [sys.executable, '-m', 'line_profiler',
+                os.fspath(script_fpath) + '.lprof']
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=0)
+        raw_output = proc.stdout
+        print('Line_profile Stdout:')
+        print(raw_output)
+        print('Line_profile Stderr:')
+        print(proc.stderr)
+        print('About to check line_profiler return code')
+        proc.check_returncode()
 
     assert 'Function: add_one' in raw_output
     assert 'Function: harmonic_mean' in raw_output
@@ -457,34 +482,35 @@ def test_autoprofile_exec_package(use_kernprof_exec, prof_mod,
     """
     Test the execution of a package.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    _write_demo_module(temp_dpath)
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
 
-    # Sanity check
-    all_checked_funcs = {'add_one', 'add_two', 'add_operator', '_main'}
-    profiled_funcs = set(profiled_funcs)
-    assert not profiled_funcs - all_checked_funcs
-
-    if use_kernprof_exec:
-        args = ['kernprof']
-    else:
-        args = [sys.executable, '-m', 'kernprof']
-    for pm in prof_mod:
-        args.extend(['-p', pm])
-    args.extend(shlex.split(flags))
-    args.extend(['-l', '-m', 'test_mod', '1', '2', '3'])
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
-
-    prof = temp_dpath / 'test_mod.lprof'
-
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
+        # Sanity check
+        all_checked_funcs = {'add_one', 'add_two', 'add_operator', '_main'}
+        profiled_funcs = set(profiled_funcs)
+        assert profiled_funcs <= all_checked_funcs
+
+        if use_kernprof_exec:
+            args = ['kernprof']
+        else:
+            args = [sys.executable, '-m', 'kernprof']
+        for pm in prof_mod:
+            args.extend(['-p', pm])
+        args.extend(shlex.split(flags))
+        args.extend(['-l', '-m', 'test_mod', '1', '2', '3'])
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
+
+        prof = temp_dpath / 'test_mod.lprof'
+
+        args = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
     for func in all_checked_funcs:
         assert (f'Function: {func}' in raw_output) == (func in profiled_funcs)
@@ -519,35 +545,36 @@ def test_autoprofile_exec_module(use_kernprof_exec, prof_mod,
     """
     Test the execution of a module.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    _write_demo_module(temp_dpath)
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
 
-    # Sanity check
-    all_checked_funcs = {'add_one', 'add_two', 'add_three', 'add_four',
-                         'add_operator', '_main'}
-    profiled_funcs = set(profiled_funcs)
-    assert not profiled_funcs - all_checked_funcs
-
-    if use_kernprof_exec:
-        args = ['kernprof']
-    else:
-        args = [sys.executable, '-m', 'kernprof']
-    if prof_mod is not None:
-        args.extend(['-p', prof_mod])
-    args.extend(shlex.split(flags))
-    args.extend(['-l', '-m', 'test_mod.subpkg.submod4', '1', '2', '3'])
-    proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
-    print(proc.stdout)
-    print(proc.stderr)
-    proc.check_returncode()
-
-    prof = temp_dpath / 'test_mod.subpkg.submod4.lprof'
-
-    args = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
-    proc = ub.cmd(args, cwd=temp_dpath)
-    raw_output = proc.stdout
-    print(raw_output)
-    proc.check_returncode()
+        # Sanity check
+        all_checked_funcs = {'add_one', 'add_two', 'add_three', 'add_four',
+                             'add_operator', '_main'}
+        profiled_funcs = set(profiled_funcs)
+        assert profiled_funcs <= all_checked_funcs
+
+        if use_kernprof_exec:
+            args = ['kernprof']
+        else:
+            args = [sys.executable, '-m', 'kernprof']
+        if prof_mod is not None:
+            args.extend(['-p', prof_mod])
+        args.extend(shlex.split(flags))
+        args.extend(['-l', '-m', 'test_mod.subpkg.submod4', '1', '2', '3'])
+        proc = ub.cmd(args, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
+
+        prof = temp_dpath / 'test_mod.subpkg.submod4.lprof'
+
+        args = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
+        proc = ub.cmd(args, cwd=temp_dpath)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
 
     for func in all_checked_funcs:
         assert (f'Function: {func}' in raw_output) == (func in profiled_funcs)
@@ -651,6 +678,164 @@ def test_autoprofile_from_inlined_script(outfile, expected_outfile) -> None:
     assert 'Function: add_three' in raw_output
 
 
+@pytest.mark.parametrize(
+    ('explicit_config', 'prof_mod', 'prof_imports', 'profiled_funcs'),
+    [(True, 'test_mod.submod2', False, {'add_two', 'add_operator'}),
+     (False, None, False, {'add_one', 'add_operator'}),
+     (True, 'test_mod.subpkg.submod4', None,
+      {'add_one', 'add_two', 'add_four', 'add_operator', '_main'}),
+     (False,
+      '',  # This negates the `prof-mod` configued in the TOML file
+      True, {})])
+def test_autoprofile_with_customized_config(
+        explicit_config, prof_mod, prof_imports, profiled_funcs):
+    """
+    Test autoprofiling a module with a customized TOML config file.
+
+    TOML file
+    ---------
+    > [tool.line_profiler.kernprof]
+    > line-by-line = true
+    > prof-imports = true
+    > prof-mod = ['test_mod.submod1']
+    > outfile = 'my_output.lprof'
+    >
+    > [tool.line_profiler.cli]
+    > summarize = true
+    >
+    > [tool.line_profiler.show.column_widths]
+    > line = 8  # 2 wider than the default
+    """
+    docstring = test_autoprofile_with_customized_config.__doc__
+    toml_content = ub.codeblock('\n'.join(
+        line.lstrip('>')
+        for line in (ub.codeblock(docstring).strip('\n')
+                     .partition('----\n')[-1].splitlines())))
+    lineno_col_width = 8
+
+    # Sanity check
+    all_checked_funcs = {'add_one', 'add_two', 'add_four',
+                         'add_operator', '_main'}
+    profiled_funcs = set(profiled_funcs)
+    assert profiled_funcs <= all_checked_funcs
+
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
+        toml = (temp_dpath / 'config.toml').absolute()
+        toml.write_text(toml_content)
+        prof = temp_dpath / 'my_output.lprof'
+
+        kernprof_cmd = ['kernprof']
+        lp_cmd = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
+        env = os.environ.copy()
+        if explicit_config:
+            kernprof_cmd.append('--config=' + str(toml))
+            lp_cmd.append('--config=' + str(toml))
+        else:
+            env['LINE_PROFILER_RC'] = str(toml)
+        if prof_mod is not None:
+            kernprof_cmd.extend(['-p', prof_mod])
+        if prof_imports in (True, False):
+            kernprof_cmd.append('--{}prof-imports'
+                                .format('' if prof_imports else 'no-'))
+        kernprof_cmd.extend(['-m', 'test_mod.subpkg.submod4', '1', '2', '3'])
+        proc = ub.cmd(kernprof_cmd, cwd=temp_dpath, env=env, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
+
+        # `outfile` is configured by `tool.line_profiler.kernprof`
+        assert prof.is_file()
+
+        proc = ub.cmd(lp_cmd, cwd=temp_dpath, env=env)
+        raw_output = proc.stdout
+        print(raw_output)
+        proc.check_returncode()
+
+    for func in all_checked_funcs:
+        assert (f'Function: {func}' in raw_output) == (func in profiled_funcs)
+        # `summarize` is configured by `tool.line_profiler.cli`
+        assert (f'- {func}' in raw_output) == (func in profiled_funcs)
+
+    # Check the column width of the line numbers. which is configured in
+    # `tool.line_profiler.show.column_widths`
+    for line in raw_output.splitlines():
+        if not line:
+            continue
+        if line.isspace():
+            continue
+        first, *_ = line.split()
+        if not first.isdecimal():
+            continue
+        assert line.index(first) + len(first) == lineno_col_width
+
+
+@pytest.mark.parametrize('view_in_process', [True, False])
+@pytest.mark.parametrize('no_config', [True, False])
+def test_autoprofile_with_no_config(no_config, view_in_process):
+    """
+    Test disabling config lookup with the `--no-config` flag.
+    """
+    toml_content = ub.codeblock('''
+    [tool.line_profiler.show.column_widths]
+    line = 8  # 2 wider than the default
+    ''')
+    lineno_col_width = 6 if no_config else 8
+
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
+        toml = (temp_dpath / 'line_profiler.toml').absolute()
+        toml.write_text(toml_content)
+        prof = temp_dpath / 'my_output.lprof'
+
+        kernprof_cmd = ['kernprof',
+                        '-p', 'test_mod.subpkg.submod4',
+                        '-o', 'my_output.lprof',
+                        '-l']
+        lp_cmd = [sys.executable, '-m', 'line_profiler', os.fspath(prof)]
+        if view_in_process:
+            kernprof_cmd.append('--view')
+        if no_config:
+            if view_in_process:
+                kernprof_cmd.append('--no-config')
+            else:
+                lp_cmd.insert(-1, '--no-config')
+        kernprof_cmd.extend(['-m', 'test_mod.subpkg.submod4', '1', '2', '3'])
+        proc = ub.cmd(kernprof_cmd, cwd=temp_dpath, verbose=2)
+        print(proc.stdout)
+        print(proc.stderr)
+        proc.check_returncode()
+        assert prof.is_file()
+
+        if view_in_process:
+            raw_output = proc.stdout
+        else:
+            proc = ub.cmd(lp_cmd, cwd=temp_dpath)
+            raw_output = proc.stdout
+            print(raw_output)
+            proc.check_returncode()
+
+    assert 'Function: add_one' not in raw_output
+    assert 'Function: add_two' not in raw_output
+    assert 'Function: add_four' in raw_output
+    assert 'Function: add_operator' not in raw_output
+    assert 'Function: _main' in raw_output
+
+    # Check the column width of the line numbers. which is configured in
+    # `tool.line_profiler.show.column_widths`
+    for line in raw_output.splitlines():
+        if not line:
+            continue
+        if line.isspace():
+            continue
+        first, *_ = line.split()
+        if not first.isdecimal():
+            continue
+        assert line.index(first) + len(first) == lineno_col_width
+
+
 @pytest.mark.parametrize(
     ('prof_mod', 'profiled_funcs'),
     [('my_module',
@@ -674,7 +859,7 @@ def test_autoprofile_callable_wrapper_objects(prof_mod, profiled_funcs):
                          'partial_method', 'class_method', 'static_method',
                          'descriptor'}
     profiled_funcs = set(profiled_funcs)
-    assert not profiled_funcs - all_checked_funcs
+    assert profiled_funcs <= all_checked_funcs
     # Note: `partial_method()` not to be included as its own item
     # because it's a wrapper around `function()`
     assert 'partial_method' not in profiled_funcs
diff --git a/tests/test_cli.py b/tests/test_cli.py
index 033ee0b0..39831ecc 100644
--- a/tests/test_cli.py
+++ b/tests/test_cli.py
@@ -1,5 +1,117 @@
+import re
+from argparse import ArgumentParser, HelpFormatter
+from contextlib import nullcontext
+from functools import partial
+from io import StringIO
 from os.path import join
+from shlex import split
 from sys import executable
+import pytest
+from line_profiler.cli_utils import add_argument
+
+
+@pytest.fixture
+def parser():
+    """
+    Argument parser with the following boolean flags:
+
+    -f, -F, --foo -> foo
+    -b, --bar -> bar
+    -B, --baz -> baz
+    --no-spam -> spam (negated)
+    --ham -> ham
+    -c -> c
+    """
+    parser = ArgumentParser(
+        formatter_class=partial(HelpFormatter,
+                                max_help_position=float('inf'),
+                                width=float('inf')))
+    # Normal boolean flag (w/2 short forms)
+    # -> adds 3 actions (long, short, long-negated)
+    add_argument(parser, '-f', '-F', '--foo', action='store_true')
+    # Boolean flag w/o parenthetical remark in help text
+    # -> adds 3 actions (long, short, long-negated)
+    add_argument(parser, '-b', '--bar', action='store_true', help='Set `bar`')
+    # Boolean flag w/parenthetical remark in help text
+    # -> adds 3 actions (long, short, long-negated)
+    add_argument(parser, '-B', '--baz',
+                 action='store_true', help='Set `baz` (BAZ)')
+    # Negative boolean flag
+    # -> adds 1 action (long-negated)
+    add_argument(parser, '--no-spam',
+                 action='store_false', dest='spam', help='Set `spam` to false')
+    # Boolean flag w/o short form
+    # -> adds 2 actions (long, long-negated)
+    add_argument(parser, '--ham', action='store_true', help='Set `ham`')
+    # Short-form-only boolean flag
+    # -> adds 1 action (short)
+    add_argument(parser, '-e',
+                 action='store_true', dest='eggs', help='Set `eggs`')
+    yield parser
+
+
+def test_boolean_argument_help_text(parser):
+    """
+    Test the help texts generated from boolean arguments added by
+    `line_profiler.cli_utils.add_argument(action=...)`.
+    """
+    assert len(parser._actions) == 14  # One extra option from `--help`
+    with StringIO() as sio:
+        parser.print_help(sio)
+        help_text = sio.getvalue()
+    matches = partial(re.search, string=help_text, flags=re.MULTILINE)
+    assert matches(r'^  --foo \[.*\] +'
+                   + re.escape('(Short forms: -f, -F)')
+                   + '$')
+    assert matches(r'^  --bar \[.*\] +'
+                   + re.escape('Set `bar` (Short form: -b)')
+                   + '$')
+    assert matches(r'^  --baz \[.*\] +'
+                   + re.escape('Set `baz` (BAZ; short form: -B)')
+                   + '$')
+    assert matches(r'^  --no-spam \[.*\] +'
+                   + re.escape('Set `spam` to false')
+                   + '$')
+    assert matches(r'^  --ham \[.*\] +'
+                   + re.escape('Set `ham`')
+                   + '$')
+    assert matches(r'^  -e +'
+                   + re.escape('Set `eggs`')
+                   + '$')
+
+
+@pytest.mark.parametrize(
+    ('args', 'foo', 'bar', 'baz', 'spam', 'ham', 'eggs', 'expect_error'),
+    [('--foo q', *((None,) * 6), True),  # Can't parse `q` into boolean
+     ('-fbB'  # Test short-flag concatenation
+      ' --ham=',  # Empty string -> set to false
+      True, True, True, None, False, None, False),
+     ('--foo'  # No-arg -> set to true
+      ' --bar=0'  # Falsy arg -> set to false
+      ' --no-baz'  # No-arg (negated flag) -> set to false
+      ' --no-spam=no'  # Falsy arg (negated flag) -> set to true
+      ' --ham=on'  # Truey arg -> set to true
+      ' -e',  # No-arg -> set to true
+      True, False, False, True, True, True, False)])
+def test_boolean_argument_parsing(
+        parser, capsys, args, foo, bar, baz, spam, ham, eggs, expect_error):
+    """
+    Test the handling of boolean flags.
+    """
+    if expect_error:
+        ctx = pytest.raises(SystemExit)
+        match_stderr = 'usage: .* error: argument'
+    else:
+        ctx = nullcontext()
+        match_stderr = '^$'
+    with ctx:
+        result = vars(parser.parse_args(split(args)))
+    stderr = capsys.readouterr().err
+    assert re.match(match_stderr, stderr, flags=re.DOTALL)
+    if expect_error:
+        return
+    expected = dict(foo=foo, bar=bar, baz=baz, spam=spam, ham=ham, eggs=eggs)
+    assert result == expected
 
 
 def test_cli():
diff --git a/tests/test_explicit_profile.py b/tests/test_explicit_profile.py
index acedc8f1..038e6582 100644
--- a/tests/test_explicit_profile.py
+++ b/tests/test_explicit_profile.py
@@ -99,21 +99,21 @@ def test_explicit_profile_with_nothing():
     """
     Test that no profiling happens when we dont request it.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    with ub.ChDir(temp_dpath):
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(_demo_explicit_profile_script())
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
 
-        args = [sys.executable, os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            args = [sys.executable, os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert not (temp_dpath / 'profile_output.txt').exists()
-    assert not (temp_dpath / 'profile_output.lprof').exists()
-    temp_dpath.delete()
+        assert not (temp_dpath / 'profile_output.txt').exists()
+        assert not (temp_dpath / 'profile_output.lprof').exists()
 
 
 def test_explicit_profile_with_environ_on():
@@ -121,48 +121,48 @@ def test_explicit_profile_with_environ_on():
     Test that explicit profiling is enabled when we specify the LINE_PROFILE
     enviornment variable.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    env = os.environ.copy()
-    env['LINE_PROFILE'] = '1'
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        env = os.environ.copy()
+        env['LINE_PROFILE'] = '1'
 
-    with ub.ChDir(temp_dpath):
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(_demo_explicit_profile_script())
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
 
-        args = [sys.executable, os.fspath(script_fpath)]
-        proc = ub.cmd(args, env=env)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            args = [sys.executable, os.fspath(script_fpath)]
+            proc = ub.cmd(args, env=env)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert (temp_dpath / 'profile_output.txt').exists()
-    assert (temp_dpath / 'profile_output.lprof').exists()
-    temp_dpath.delete()
+        assert (temp_dpath / 'profile_output.txt').exists()
+        assert (temp_dpath / 'profile_output.lprof').exists()
 
 
 def test_explicit_profile_with_environ_off():
     """
     When LINE_PROFILE is falsy, profiling should not run.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    env = os.environ.copy()
-    env['LINE_PROFILE'] = '0'
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        env = os.environ.copy()
+        env['LINE_PROFILE'] = '0'
 
-    with ub.ChDir(temp_dpath):
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(_demo_explicit_profile_script())
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
 
-        args = [sys.executable, os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            args = [sys.executable, os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert not (temp_dpath / 'profile_output.txt').exists()
-    assert not (temp_dpath / 'profile_output.lprof').exists()
-    temp_dpath.delete()
+        assert not (temp_dpath / 'profile_output.txt').exists()
+        assert not (temp_dpath / 'profile_output.lprof').exists()
 
 
 def test_explicit_profile_with_cmdline():
@@ -172,23 +172,22 @@ def test_explicit_profile_with_cmdline():
 
     xdoctest ~/code/line_profiler/tests/test_explicit_profile.py test_explicit_profile_with_environ
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        with ub.ChDir(temp_dpath):
 
-    with ub.ChDir(temp_dpath):
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(_demo_explicit_profile_script())
+            args = [sys.executable, os.fspath(script_fpath), '--line-profile']
+            print(f'args={args}')
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-        args = [sys.executable, os.fspath(script_fpath), '--line-profile']
-        print(f'args={args}')
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
-
-    assert (temp_dpath / 'profile_output.txt').exists()
-    assert (temp_dpath / 'profile_output.lprof').exists()
-    temp_dpath.delete()
+        assert (temp_dpath / 'profile_output.txt').exists()
+        assert (temp_dpath / 'profile_output.lprof').exists()
 
 
 @pytest.mark.parametrize('line_profile', [True, False])
@@ -197,26 +196,26 @@ def test_explicit_profile_with_kernprof(line_profile: bool):
     Test that explicit profiling works when using kernprof. In this case
     we should get as many output files.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    base_cmd = [sys.executable, '-m', 'kernprof']
-    if line_profile:
-        base_cmd.append('-l')
-        outfile = 'script.py.lprof'
-    else:
-        outfile = 'script.py.prof'
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        base_cmd = [sys.executable, '-m', 'kernprof']
+        if line_profile:
+            base_cmd.append('-l')
+            outfile = 'script.py.lprof'
+        else:
+            outfile = 'script.py.prof'
 
-    with ub.ChDir(temp_dpath):
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(_demo_explicit_profile_script())
-        args = base_cmd + [os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+        with ub.ChDir(temp_dpath):
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
+            args = base_cmd + [os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    assert not (temp_dpath / 'profile_output.txt').exists()
-    assert (temp_dpath / outfile).exists()
-    temp_dpath.delete()
+        assert not (temp_dpath / 'profile_output.txt').exists()
+        assert (temp_dpath / outfile).exists()
 
 
 @pytest.mark.parametrize('package', [True, False])
@@ -239,79 +238,80 @@ def test_explicit_profile_with_kernprof_m(builtin: bool, package: bool):
             submodule and `kernprof -m {<package>}.{<submodule>}`
             (false)
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-
-    lib_code = ub.codeblock(
-        '''
-        @profile
-        def func1(a):
-            return a + 1
-
-        @profile
-        def func2(a):
-            return a + 1
-
-        def func3(a):
-            return a + 1
-
-        def func4(a):
-            return a + 1
-        ''').strip()
-    if not builtin:
-        lib_code = 'from line_profiler import profile\n' + lib_code
-    target_code = ub.codeblock(
-        '''
-        from ._lib import func1, func2, func3, func4
-
-        if __name__ == '__main__':
-            func1(1)
-            func2(1)
-            func3(1)
-            func4(1)
-        ''').strip()
-
-    if package:
-        target_module = 'package'
-        target_fname = '__main__.py'
-    else:
-        target_module = 'package.api'
-        target_fname = 'api.py'
-
-    args = ['kernprof', '-v', '-m', target_module]
-    if builtin:
-        args.insert(2, '--builtin')  # Insert before the `-m` flag
-
-    if 'PYTHONPATH' in os.environ:
-        python_path = '{}:{}'.format(os.environ['PYTHONPATH'], os.curdir)
-    else:
-        python_path = os.curdir
-    env = {**os.environ, 'PYTHONPATH': python_path}
-
-    with ub.ChDir(temp_dpath):
-        package_dir = ub.Path('package').mkdir()
-
-        lib_fpath = package_dir / '_lib.py'
-        lib_fpath.write_text(lib_code)
-
-        target_fpath = package_dir / target_fname
-        target_fpath.write_text(target_code)
-
-        (package_dir / '__init__.py').touch()
-
-        proc = ub.cmd(args, env=env)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
-
-    # Note: in non-builtin mode, the entire script is profiled
-    for func, profiled in [('func1', True), ('func2', True),
-                           ('func3', not builtin), ('func4', not builtin)]:
-        result = re.search(r'lib\.py:[0-9]+\({}\)'.format(func), proc.stdout)
-        assert bool(result) == profiled
-
-    assert not (temp_dpath / 'profile_output.txt').exists()
-    assert (temp_dpath / (target_module + '.prof')).exists()
-    temp_dpath.delete()
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+
+        lib_code = ub.codeblock(
+            '''
+            @profile
+            def func1(a):
+                return a + 1
+
+            @profile
+            def func2(a):
+                return a + 1
+
+            def func3(a):
+                return a + 1
+
+            def func4(a):
+                return a + 1
+            ''').strip()
+        if not builtin:
+            lib_code = 'from line_profiler import profile\n' + lib_code
+        target_code = ub.codeblock(
+            '''
+            from ._lib import func1, func2, func3, func4
+
+            if __name__ == '__main__':
+                func1(1)
+                func2(1)
+                func3(1)
+                func4(1)
+            ''').strip()
+
+        if package:
+            target_module = 'package'
+            target_fname = '__main__.py'
+        else:
+            target_module = 'package.api'
+            target_fname = 'api.py'
+
+        args = ['kernprof', '-v', '-m', target_module]
+        if builtin:
+            args.insert(2, '--builtin')  # Insert before the `-m` flag
+
+        if 'PYTHONPATH' in os.environ:
+            python_path = '{}:{}'.format(os.environ['PYTHONPATH'], os.curdir)
+        else:
+            python_path = os.curdir
+        env = {**os.environ, 'PYTHONPATH': python_path}
+
+        with ub.ChDir(temp_dpath):
+            package_dir = ub.Path('package').mkdir()
+
+            lib_fpath = package_dir / '_lib.py'
+            lib_fpath.write_text(lib_code)
+
+            target_fpath = package_dir / target_fname
+            target_fpath.write_text(target_code)
+
+            (package_dir / '__init__.py').touch()
+
+            proc = ub.cmd(args, env=env)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
+
+        # Note: in non-builtin mode, the entire script is profiled
+        for func, profiled in [('func1', True), ('func2', True),
+                               ('func3', not builtin), ('func4', not builtin)]:
+            result = re.search(r'lib\.py:[0-9]+\({}\)'.format(func),
+                               proc.stdout)
+            assert bool(result) == profiled
+
+        assert not (temp_dpath / 'profile_output.txt').exists()
+        assert (temp_dpath / (target_module + '.prof')).exists()
 
 
 def test_explicit_profile_with_in_code_enable():
@@ -322,81 +322,81 @@ def test_explicit_profile_with_in_code_enable():
     CommandLine:
         pytest tests/test_explicit_profile.py -s -k test_explicit_profile_with_in_code_enable
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        from line_profiler import profile
-        import ubelt as ub
-        print('')
-        print('')
-        print('start test')
+        code = ub.codeblock(
+            '''
+            from line_profiler import profile
+            import ubelt as ub
+            print('')
+            print('')
+            print('start test')
 
-        print('profile = {}'.format(ub.urepr(profile, nl=1)))
-        print(f'profile._profile={profile._profile}')
-        print(f'profile.enabled={profile.enabled}')
+            print('profile = {}'.format(ub.urepr(profile, nl=1)))
+            print(f'profile._profile={profile._profile}')
+            print(f'profile.enabled={profile.enabled}')
 
-        @profile
-        def func1(a):
-            return a + 1
+            @profile
+            def func1(a):
+                return a + 1
 
-        profile.enable(output_prefix='custom_output')
+            profile.enable(output_prefix='custom_output')
 
-        print('profile = {}'.format(ub.urepr(profile, nl=1)))
-        print(f'profile._profile={profile._profile}')
-        print(f'profile.enabled={profile.enabled}')
+            print('profile = {}'.format(ub.urepr(profile, nl=1)))
+            print(f'profile._profile={profile._profile}')
+            print(f'profile.enabled={profile.enabled}')
 
-        @profile
-        def func2(a):
-            return a + 1
+            @profile
+            def func2(a):
+                return a + 1
 
-        print('func2 = {}'.format(ub.urepr(func2, nl=1)))
+            print('func2 = {}'.format(ub.urepr(func2, nl=1)))
 
-        profile.disable()
+            profile.disable()
 
-        @profile
-        def func3(a):
-            return a + 1
+            @profile
+            def func3(a):
+                return a + 1
 
-        profile.enable()
+            profile.enable()
 
-        @profile
-        def func4(a):
-            return a + 1
+            @profile
+            def func4(a):
+                return a + 1
 
-        func1(1)
-        func2(1)
-        func3(1)
-        func4(1)
+            func1(1)
+            func2(1)
+            func3(1)
+            func4(1)
 
-        profile._profile
-        ''')
-    with ub.ChDir(temp_dpath):
+            profile._profile
+            ''')
+        with ub.ChDir(temp_dpath):
 
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
 
-        args = [sys.executable, os.fspath(script_fpath)]
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
+            args = [sys.executable, os.fspath(script_fpath)]
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
 
-    print('Finished running script')
+        print('Finished running script')
 
-    output_fpath = (temp_dpath / 'custom_output.txt')
-    raw_output = output_fpath.read_text()
-    print(f'Contents of {output_fpath}')
-    print(raw_output)
+        output_fpath = (temp_dpath / 'custom_output.txt')
+        raw_output = output_fpath.read_text()
+        print(f'Contents of {output_fpath}')
+        print(raw_output)
 
-    assert 'Function: func1' not in raw_output
-    assert 'Function: func2' in raw_output
-    assert 'Function: func3' not in raw_output
-    assert 'Function: func4' in raw_output
+        assert 'Function: func1' not in raw_output
+        assert 'Function: func2' in raw_output
+        assert 'Function: func3' not in raw_output
+        assert 'Function: func4' in raw_output
 
-    assert output_fpath.exists()
-    assert (temp_dpath / 'custom_output.lprof').exists()
-    temp_dpath.delete()
+        assert output_fpath.exists()
+        assert (temp_dpath / 'custom_output.lprof').exists()
 
 
 def test_explicit_profile_with_duplicate_functions():
@@ -406,56 +406,101 @@ def test_explicit_profile_with_duplicate_functions():
     CommandLine:
         pytest -sv tests/test_explicit_profile.py -k test_explicit_profile_with_duplicate_functions
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
 
-    code = ub.codeblock(
-        '''
-        from line_profiler import profile
-
-        @profile
-        def func1(a):
-            return a + 1
+        code = ub.codeblock(
+            '''
+            from line_profiler import profile
 
-        @profile
-        def func2(a):
-            return a + 1
+            @profile
+            def func1(a):
+                return a + 1
 
-        @profile
-        def func3(a):
-            return a + 1
+            @profile
+            def func2(a):
+                return a + 1
 
-        @profile
-        def func4(a):
-            return a + 1
-
-        func1(1)
-        func2(1)
-        func3(1)
-        func4(1)
-        ''').strip()
-    with ub.ChDir(temp_dpath):
-
-        script_fpath = ub.Path('script.py')
-        script_fpath.write_text(code)
-
-        args = [sys.executable, os.fspath(script_fpath), '--line-profile']
-        proc = ub.cmd(args)
-        print(proc.stdout)
-        print(proc.stderr)
-        proc.check_returncode()
-
-    output_fpath = (temp_dpath / 'profile_output.txt')
-    raw_output = output_fpath.read_text()
-    print(raw_output)
+            @profile
+            def func3(a):
+                return a + 1
 
-    assert 'Function: func1' in raw_output
-    assert 'Function: func2' in raw_output
-    assert 'Function: func3' in raw_output
-    assert 'Function: func4' in raw_output
+            @profile
+            def func4(a):
+                return a + 1
 
-    assert output_fpath.exists()
-    assert (temp_dpath / 'profile_output.lprof').exists()
-    temp_dpath.delete()
+            func1(1)
+            func2(1)
+            func3(1)
+            func4(1)
+            ''').strip()
+        with ub.ChDir(temp_dpath):
+
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(code)
+
+            args = [sys.executable, os.fspath(script_fpath), '--line-profile']
+            proc = ub.cmd(args)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
+
+        output_fpath = (temp_dpath / 'profile_output.txt')
+        raw_output = output_fpath.read_text()
+        print(raw_output)
+
+        assert 'Function: func1' in raw_output
+        assert 'Function: func2' in raw_output
+        assert 'Function: func3' in raw_output
+        assert 'Function: func4' in raw_output
+
+        assert output_fpath.exists()
+        assert (temp_dpath / 'profile_output.lprof').exists()
+
+
+def test_explicit_profile_with_customized_config():
+    """
+    Test that explicit profiling can be configured with the appropriate
+    TOML file.
+    """
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+
+        env = os.environ.copy()
+        env['PROFILE'] = '1'
+
+        with ub.ChDir(temp_dpath):
+            script_fpath = ub.Path('script.py')
+            script_fpath.write_text(_demo_explicit_profile_script())
+            toml = ub.Path('my_config.toml')
+            toml.write_text(ub.codeblock('''
+        [tool.line_profiler.setup]
+        environ_flags = ['PROFILE']
+
+        [tool.line_profiler.write]
+        output_prefix = 'my_profiling_results'
+        timestamped_text = false
+
+        [tool.line_profiler.show]
+        details = true
+        summarize = false
+            '''))
+
+            env['LINE_PROFILER_RC'] = str(toml)
+            args = [sys.executable, os.fspath(script_fpath)]
+            proc = ub.cmd(args, env=env)
+            print(proc.stdout)
+            print(proc.stderr)
+            proc.check_returncode()
+
+        # Check the `write` config
+        assert set(os.listdir(temp_dpath)) == {'script.py',
+                                               'my_config.toml',
+                                               'my_profiling_results.lprof',
+                                               'my_profiling_results.txt'}
+        # Check the `show` config
+        assert '- fib' not in proc.stdout  # No summary
+        assert 'Function: fib' in proc.stdout  # With details
 
 
 @pytest.mark.parametrize('reset_enable_count', [True, False])
diff --git a/tests/test_toml_config.py b/tests/test_toml_config.py
new file mode 100644
index 00000000..f6c775dc
--- /dev/null
+++ b/tests/test_toml_config.py
@@ -0,0 +1,145 @@
+"""
+Test the handling of TOML configs.
+"""
+import os
+import pathlib
+import pytest
+import textwrap
+from line_profiler.toml_config import get_config, get_default_config
+
+
+def write_text(path: pathlib.Path, text: str, /, *args, **kwargs) -> int:
+    text = textwrap.dedent(text).strip('\n')
+    return path.write_text(text, *args, **kwargs)
+
+
+@pytest.fixture(autouse=True)
+def fresh_curdir(monkeypatch: pytest.MonkeyPatch,
+                 tmp_path_factory: pytest.TempPathFactory) -> pathlib.Path:
+    """
+    Ensure that the tests start on a clean slate: they shouldn't see
+    the environment variable `${LINE_PROFILER_RC}`, nor should the
+    `get_config()` lookup find any config file.
+
+    Yields:
+        curdir (pathlib.Path):
+            The temporary directory we `chdir()`-ed into for the test.
+    """
+    monkeypatch.delenv('LINE_PROFILER_RC', raising=False)
+    path = tmp_path_factory.mktemp('clean').absolute()
+    monkeypatch.chdir(path)
+    yield path
+
+
+def test_environment_isolation() -> None:
+    """
+    Test that we have isolated the tests from the environment with the
+    `fresh_curdir()` fixture.
+    """
+    assert 'LINE_PROFILER_RC' not in os.environ
+    assert get_config() == get_default_config()
+
+
+def test_default_config_deep_copy() -> None:
+    """
+    Test that `line_profiler.toml_config.get_default_config()` always
+    return a fresh copy of the default config.
+    """
+    (default_1, _), (default_2, _) = (get_default_config() for _ in (1, 2))
+    assert default_1 == default_2
+    assert default_1 is not default_2
+    # Sublist
+    environ_flags = default_1['setup']['environ_flags']
+    assert isinstance(environ_flags, list)
+    assert environ_flags == default_2['setup']['environ_flags']
+    assert environ_flags is not default_2['setup']['environ_flags']
+    # Subtable
+    column_widths = default_1['show']['column_widths']
+    assert isinstance(column_widths, dict)
+    assert column_widths == default_2['show']['column_widths']
+    assert column_widths is not default_2['show']['column_widths']
+
+
+def test_table_normalization(fresh_curdir: pathlib.Path) -> None:
+    """
+    Test that even if a config file misses some items (and has so extra
+    ones), it is properly normalized to contain the same keys as the
+    default table.
+    """
+    default_config, default_source = get_default_config()
+    toml = fresh_curdir / 'foo.toml'
+    write_text(toml, """
+    [unrelated.table]
+    foo = 'foo'  # This should be ignored
+
+    [tool.line_profiler.write]
+    output_prefix = 'my_prefix'  # This is parsed and retained
+    nonexistent_key = 'nonexistent_value'  # This should be ignored
+    """)
+    loaded_config, loaded_source = get_config(toml)
+    assert loaded_source.samefile(toml)
+    assert loaded_config['write']['output_prefix'] == 'my_prefix'
+    assert 'nonexistent_key' not in loaded_config['write']
+    del loaded_config['write']['output_prefix']
+    del default_config['write']['output_prefix']
+    assert loaded_config == default_config
+
+
+def test_malformed_table(fresh_curdir: pathlib.Path) -> None:
+    """
+    Test that we get a `ValueError` when loading a malformed table with a
+    non-subtable value taking the place of a supposed subtable.
+    """
+    toml = fresh_curdir / 'foo.toml'
+    write_text(toml, """
+    [tool.line_profiler]
+    write = [{lprof = true}]  # This shouldn't be a list
+    """)
+    with pytest.raises(ValueError,
+                       match=r"config = .*: expected .* keys.*:"
+                       r".*'tool\.line_profiler\.write'"):
+        get_config(toml)
+
+
+def test_config_lookup_hierarchy(monkeypatch: pytest.MonkeyPatch,
+                                 fresh_curdir: pathlib.Path) -> None:
+    """
+    Test the hierarchy according to which we load config files.
+    """
+    _, default = get_default_config()
+    # Lowest priority: `pyproject.toml` or `line_profiler.toml` in an
+    # ancestral directory
+    curdir = fresh_curdir
+    lowest_priority = curdir / 'line_profiler.toml'
+    lowest_priority.touch()
+    curdir = curdir / 'child'
+    curdir.mkdir()
+    monkeypatch.chdir(curdir)
+    assert get_config()[1].samefile(lowest_priority)
+    # Higher priority: the same in the current directory
+    # (`line_profiler.toml` preferred over `pyproject.toml`)
+    lower_priority = curdir / 'pyproject.toml'
+    lower_priority.touch()
+    assert get_config()[1].samefile(lower_priority)
+    low_priority = curdir / 'line_profiler.toml'
+    low_priority.touch()
+    assert get_config()[1].samefile(low_priority)
+    # Higher priority: a file specified by the `${LINE_PROFILER_RC}`
+    # environment variable (but we fall back to the default if that
+    # fails)
+    monkeypatch.setenv('LINE_PROFILER_RC', 'foo.toml')
+    assert get_config()[1].samefile(default)
+    high_priority = curdir / 'foo.toml'
+    high_priority.touch()
+    assert get_config()[1].samefile(high_priority)
+    # Highest priority: a file passed explicitly to the `config`
+    # parameter
+    highest_priority = curdir.parent / 'bar.toml'
+    with pytest.raises(FileNotFoundError):
+        get_config(highest_priority)
+    highest_priority.touch()
+    assert get_config(highest_priority)[1].samefile(highest_priority)
+    # Also test that `True` is equivalent to the default behavior
+    # (`None`), and `False` to disabling all lookup
+    assert get_config(True)[1].samefile(high_priority)
+    assert get_config(False)[1].samefile(default)