diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index 7d2f1809..2a824d14 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -12,6 +12,7 @@ Changes
 * 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 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: 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 39bbfde5..d1860226 100755
--- a/kernprof.py
+++ b/kernprof.py
@@ -63,10 +63,20 @@ def main():
 
 .. code::
 
-    usage: kernprof [-h] [-V] [-l] [-b] [-o OUTFILE] [-s SETUP] [-v] [-r] [-u UNIT] [-z] [-i [OUTPUT_INTERVAL]] [-p PROF_MOD] [--prof-imports]
-                    {path/to/script | -m path.to.module | -c "literal code"} ...
-
-    Run and profile a python script.
+    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 PROF_MOD]
+                    [--prof-imports [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [-o OUTFILE]
+                    [--view [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]]
+                    [--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]]
+                    {script | -m module} ...
+
+    Run and profile a python script or module.
 
     positional arguments:
       {path/to/script | -m path.to.module | -c "literal code"}
@@ -76,23 +86,59 @@ 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. List is comma separated, adding the
+                            current script path profiles the full script. Multiple copies
+                            of this flag can be supplied and the list is extended (e.g.
+                            `-p this.module,another.module -p some.func`). Only works with
+                            line profiling (`-l`/`--line-by-line`). (Default: N/A)
+      --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
-      -v, --view            View the results of the profile in addition to saving it
-      -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
+                            Save stats to OUTFILE. (Default:
+                            '<script_or_module_name>.lprof' in line-profiling mode
+                            (`-l`/`--line-by-line`); '<script_or_module_name>.prof'
+                            otherwise)
+      --view [Y[es] | N[o] | T[rue] | F[alse] | on | off | 1 | 0]
+                            View the results of the profile in addition to saving it.
+                            (Default: False; short form: -v)
+      --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 PROF_MOD
-                            List of modules, functions and/or classes to profile specified by their name or path. List is comma separated, adding the current script path profiles
-                            the full script. Multiple copies of this flag can be supplied and the.list is extended. 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))
+"""  # noqa: E501
+import argparse
 import builtins
 import functools
 import os
@@ -102,7 +148,6 @@ def main():
 import concurrent.futures  # NOQA
 import tempfile
 import time
-from argparse import ArgumentError, ArgumentParser
 from runpy import run_module
 
 # NOTE: This version needs to be manually maintained in
@@ -116,6 +161,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
 
 
@@ -166,7 +216,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
@@ -184,7 +234,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
 
@@ -193,7 +244,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
 
@@ -202,11 +253,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):
+def find_script(script_name, *, exit_on_error=True):
     """ Find the script.
 
     If the input is not a file, then $PATH will be searched.
@@ -221,19 +276,12 @@ def find_script(script_name):
         if os.path.isfile(fn):
             return fn
 
-    sys.stderr.write('Could not find script %s\n' % script_name)
-    raise SystemExit(1)
-
-
-def _python_command():
-    """
-    Return a command that corresponds to :py:obj:`sys.executable`.
-    """
-    import shutil
-    for abbr in 'python', 'python3':
-        if os.path.samefile(shutil.which(abbr), sys.executable):
-            return abbr
-    return sys.executable
+    msg = f'Could not find script {script_name!r}'
+    if exit_on_error:
+        print(msg, file=sys.stderr)
+        raise SystemExit(1)
+    else:
+        raise FileNotFoundError(msg)
 
 
 class _restore_list:
@@ -341,19 +389,15 @@ def pre_parse_single_arg_directive(args, flag, sep='--'):
 
 @_restore_list(sys.argv)
 @_restore_list(sys.path)
-def main(args=None):
+def main(args=None, exit_on_error=True):
     """
     Runs the command line interface
     """
-    def positive_float(value):
-        val = float(value)
-        if val <= 0:
-            raise ArgumentError
-        return val
-
     create_parser = functools.partial(
-        ArgumentParser,
-        description='Run and profile a python script.')
+        argparse.ArgumentParser,
+        description='Run and profile a python script or module.')
+    get_kernprof_config = functools.partial(get_cli_config, 'kernprof')
+    defaults, default_source = get_kernprof_config()
 
     if args is None:
         args = sys.argv[1:]
@@ -387,57 +431,136 @@ def positive_float(value):
         help_parser = create_parser()
         parsers = [real_parser, help_parser]
     for parser in parsers:
-        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', '--view', action='store_true',
-                            help='View the results of the profile in addition to saving it')
-        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', type=str,
-                            help="List of modules, functions and/or classes to profile specified by their name or path. "
-                            "List is comma separated, adding the current script path profiles the full script. "
-                            "Multiple copies of this flag can be supplied and the.list is extended. "
-                            "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")
+        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. "
+                     "List is comma separated, adding the current script path "
+                     "profiles the full script. "
+                     "Multiple copies of this flag can be supplied and "
+                     "the list is extended "
+                     "(e.g. `-p this.module,another.module -p some.func`). "
+                     "Only works with line profiling (`-l`/`--line-by-line`). "
+                     f"(Default: {def_prof_mod})")
+        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', '--view', action='store_true',
+                     help='View the results of the profile '
+                     'in addition to saving it. '
+                     f'(Default: {defaults["view"]})')
+        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})")
 
         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')
 
     # Hand off to the dummy parser if necessary to generate the help
     # text
-    options = real_parser.parse_args(args)
+    try:
+        options = 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
     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
+    if options.config:
+        defaults, options.config = get_kernprof_config(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
@@ -453,9 +576,9 @@ def positive_float(value):
     if tempfile_source_and_content:
         with tempfile.TemporaryDirectory() as tmpdir:
             _write_tempfile(*tempfile_source_and_content, options, tmpdir)
-            return _main(options, module)
+            return _main(options, module, exit_on_error)
     else:
-        return _main(options, module)
+        return _main(options, module, exit_on_error)
 
 
 def _write_tempfile(source, content, options, tmpdir):
@@ -487,14 +610,14 @@ def _write_tempfile(source, content, options, tmpdir):
                                               suffix='.' + extension)
 
 
-def _main(options, module=False):
+def _main(options, module=False, exit_on_error=True):
     """
     Called by ``main()`` for the actual execution and profiling of code;
     not to be invoked on its own.
     """
     if not options.outfile:
         extension = 'lprof' if options.line_by_line else 'prof'
-        options.outfile = '%s.%s' % (os.path.basename(options.script), extension)
+        options.outfile = f'{os.path.basename(options.script)}.{extension}'
 
     sys.argv = [options.script] + options.args
     if module:
@@ -503,10 +626,10 @@ def _main(options, module=False):
         # 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:
-        # Run some setup code outside of the profiler. This is good for large
-        # imports.
-        setup_file = find_script(options.setup)
+    if options.setup:
+        # Run some setup code outside of the profiler. This is good for
+        # large imports.
+        setup_file = find_script(options.setup, exit_on_error=exit_on_error)
         __file__ = setup_file
         __name__ = '__main__'
         # Make sure the script's directory is on sys.path instead of just
@@ -516,7 +639,6 @@ def _main(options, module=False):
         execfile(setup_file, ns, ns)
 
     if options.line_by_line:
-        import line_profiler
         prof = line_profiler.LineProfiler()
         options.builtin = True
     elif Profile.__module__ == 'profile':
@@ -525,36 +647,29 @@ def _main(options, module=False):
     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))
     __file__ = script_file
     __name__ = '__main__'
 
-    if options.output_interval:
-        rt = RepeatedTimer(max(options.output_interval, 1), prof.dump_stats, options.outfile)
     original_stdout = sys.stdout
     if options.output_interval:
-        rt = RepeatedTimer(max(options.output_interval, 1), prof.dump_stats, options.outfile)
+        rt = RepeatedTimer(max(options.output_interval, 1), prof.dump_stats,
+                           options.outfile)
     try:
         try:
             execfile_ = execfile
@@ -575,21 +690,24 @@ def _main(options, module=False):
                                 prof_mod=prof_mod,
                                 profile_imports=options.prof_imports,
                                 as_module=module is not None)
-            elif module and options.builtin:
-                rmod_(options.script, ns)
-            elif options.builtin:
-                execfile(script_file, ns, ns)
-            elif module:
-                prof.runctx(f'rmod_({options.script!r}, globals())', ns, ns)
             else:
-                prof.runctx('execfile_(%r, globals())' % (script_file,), ns, ns)
+                if module:
+                    runner, target = 'rmod_', options.script
+                else:
+                    runner, target = 'execfile_', script_file
+                assert runner in ns
+                if options.builtin:
+                    ns[runner](target, ns)
+                else:
+                    prof.runctx(f'{runner}({target!r}, globals())', ns, ns)
         except (KeyboardInterrupt, SystemExit):
             pass
     finally:
         if options.output_interval:
             rt.stop()
         prof.dump_stats(options.outfile)
-        print('Wrote profile results to %s' % options.outfile)
+        short_outfile = short_string_path(options.outfile)
+        print(f'Wrote profile results to {short_outfile!r}')
         if options.view:
             if isinstance(prof, ContextualProfile):
                 prof.print_stats()
@@ -597,18 +715,18 @@ def _main(options, module=False):
                 prof.print_stats(output_unit=options.unit,
                                  stripzeros=options.skip_zero,
                                  rich=options.rich,
-                                 stream=original_stdout)
+                                 stream=original_stdout,
+                                 config=options.config)
         else:
             print('Inspect results with:')
             py_exe = _python_command()
             if isinstance(prof, ContextualProfile):
-                print(f'{py_exe} -m pstats "{options.outfile}"')
+                print(f'{py_exe} -m pstats {short_outfile!r}')
             else:
-                print(f'{py_exe} -m line_profiler -rmt "{options.outfile}"')
+                print(f'{py_exe} -m line_profiler -rmt {short_outfile!r}')
         # Restore the state of the global `@line_profiler.profile`
-        if global_profiler:
-            install_profiler(None)
+        install_profiler(None)
 
 
 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 5c3e6f9d..1e9f0d4e 100755
--- a/line_profiler/line_profiler.py
+++ b/line_profiler/line_profiler.py
@@ -4,25 +4,29 @@
 inspect its output. This depends on the :py:mod:`line_profiler._line_profiler`
 Cython backend.
 """
+import functools
 import pickle
 import inspect
 import linecache
 import tempfile
+import types
 import os
 import sys
-from argparse import ArgumentError, ArgumentParser
+from argparse import ArgumentParser
 
 try:
     from ._line_profiler import LineProfiler as CLineProfiler
 except ImportError as ex:
-    raise ImportError(
-        'The line_profiler._line_profiler c-extension is not importable. '
-        f'Has it been compiled? Underlying error is ex={ex!r}'
-    )
+    raise ImportError('The line_profiler._line_profiler c-extension '
+                      'is not importable. '
+                      f'Has it been compiled? Underlying error is ex={ex!r}')
 from .profiler_mixin import (ByCountProfilerMixin,
                              is_property, is_cached_property,
                              is_boundmethod, is_classmethod, is_staticmethod,
                              is_partial, is_partialmethod)
+from .toml_config import get_config
+from .cli_utils import (
+    add_argument, get_cli_config, positive_float, short_string_path)
 
 
 # NOTE: This needs to be in sync with ../kernprof.py and __init__.py
@@ -31,6 +35,12 @@
 is_function = inspect.isfunction
 
 
+@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.
     """
@@ -76,10 +86,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()
     """
@@ -124,13 +134,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_module(self, mod):
         """ Add all the functions in a module and its classes.
@@ -168,21 +180,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.
@@ -191,13 +205,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
@@ -210,18 +233,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
@@ -270,13 +293,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 = {}
 
@@ -349,16 +369,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
@@ -386,7 +404,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.
     """
     if stream is None:
@@ -404,12 +423,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
@@ -432,56 +454,58 @@ def main():
     """
     The line profiler CLI to view output from ``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 1d476f95..1e17e993 100644
--- a/line_profiler/line_profiler.pyi
+++ b/line_profiler/line_profiler.pyi
@@ -1,11 +1,16 @@
-from typing import List
-from typing import Tuple
 import io
+import pathlib
+from typing import Literal, List, Mapping, Tuple, Union
 from ._line_profiler import LineProfiler as CLineProfiler
 from .profiler_mixin import ByCountProfilerMixin
 from _typeshed import Incomplete
 
 
+def get_minimum_column_widths() -> Mapping[
+        Literal['line', 'hits', 'time', 'perhit', 'percent'], int]:
+    ...
+
+
 def load_ipython_extension(ip) -> None:
     ...
 
@@ -25,7 +30,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(self, mod):
@@ -44,7 +52,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:
     ...
 
 
@@ -56,7 +66,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..c6cb25ed
--- /dev/null
+++ b/line_profiler/rc/line_profiler.toml
@@ -0,0 +1,201 @@
+########################################################################
+#
+# 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
+#   - `view` (bool):
+#     `-v`/`--view` (true) or `--no-view` (false)
+view = 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
+#   - `prof-imports` (bool):
+#     `--prof-imports` (true) or `--no-prof-imports` (false)
+prof-imports = false
+
+# - Misc flags
+#   - `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..464f6b09
--- /dev/null
+++ b/line_profiler/toml_config.pyi
@@ -0,0 +1,42 @@
+import pathlib
+try:
+    import tomllib
+except ImportError:  # Python < 3.11
+    import tomli as tomllib  # type: ignore[no-redef]
+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]], pathlib.Path]
+NestedTable = Mapping[K, Union['NestedTable[K, V]', V]]
+
+
+def find_and_read_config_file(
+        *,
+        config: Union[str, pathlib.PurePath, None] = None,
+        env_var: Union[str, None] = env_var,
+        targets: Sequence[Union[str, pathlib.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, pathlib.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 839038a8..84f216ba 100644
--- a/tests/test_autoprofile.py
+++ b/tests/test_autoprofile.py
@@ -9,181 +9,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):
+            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', '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
+        code = ub.codeblock(
+            '''
+            def func1(a):
+                return a + 1
 
-        def func2(a):
-            return a + 1
+            def func2(a):
+                return a + 1
 
-        def func3(a):
-            return a + 1
+            def func3(a):
+                return a + 1
 
-        def func4(a):
-            return a + 1
+            def func4(a):
+                return a + 1
 
-        func1(1)
-        func2(1)
-        func3(1)
-        ''')
-    with ub.ChDir(temp_dpath):
+            func1(1)
+            func2(1)
+            func3(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', '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
@@ -292,51 +299,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
@@ -344,25 +359,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
@@ -374,20 +393,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
@@ -399,32 +421,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
@@ -449,33 +474,34 @@ def test_autoprofile_exec_package(
     """
     Test the execution of a package.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    _write_demo_module(temp_dpath)
-
-    if use_kernprof_exec:
-        args = ['kernprof']
-    else:
-        args = [sys.executable, '-m', 'kernprof']
-    if prof_mod is not None:
-        if isinstance(prof_mod, str):
-            prof_mod = [prof_mod]
-        for pm in prof_mod:
-            args.extend(['-p', pm])
-    if prof_imports:
-        args.append('--prof-imports')
-    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()
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
+
+        if use_kernprof_exec:
+            args = ['kernprof']
+        else:
+            args = [sys.executable, '-m', 'kernprof']
+        if prof_mod is not None:
+            if isinstance(prof_mod, str):
+                prof_mod = [prof_mod]
+            for pm in prof_mod:
+                args.extend(['-p', pm])
+        if prof_imports:
+            args.append('--prof-imports')
+        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()
 
     assert ('Function: add_one' in raw_output) == add_one
     assert ('Function: add_two' in raw_output) == add_two
@@ -497,30 +523,31 @@ def test_autoprofile_exec_module(
     """
     Test the execution of a module.
     """
-    temp_dpath = ub.Path(tempfile.mkdtemp())
-    _write_demo_module(temp_dpath)
-
-    if use_kernprof_exec:
-        args = ['kernprof']
-    else:
-        args = [sys.executable, '-m', 'kernprof']
-    if prof_mod is not None:
-        args.extend(['-p', prof_mod])
-    if prof_imports:
-        args.append('--prof-imports')
-    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()
+    with tempfile.TemporaryDirectory() as tmp:
+        temp_dpath = ub.Path(tmp)
+        _write_demo_module(temp_dpath)
+
+        if use_kernprof_exec:
+            args = ['kernprof']
+        else:
+            args = [sys.executable, '-m', 'kernprof']
+        if prof_mod is not None:
+            args.extend(['-p', prof_mod])
+        if prof_imports:
+            args.append('--prof-imports')
+        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()
 
     assert ('Function: add_one' in raw_output) == add_one
     assert ('Function: add_two' in raw_output) == add_two
@@ -623,3 +650,164 @@ def test_autoprofile_from_inlined_script(outfile, expected_outfile) -> None:
     assert 'Function: add_one' in raw_output
     assert 'Function: add_two' not in raw_output
     assert 'Function: add_three' in raw_output
+
+
+@pytest.mark.parametrize(
+    ['explicit_config', 'prof_mod', 'prof_imports',
+     'add_one', 'add_two', 'add_four', 'add_operator', 'main'],
+    [(True, 'test_mod.submod2', False, False, True, False, False, False),
+     (False, None, False, True, False, False, True, False),
+     (True, 'test_mod.subpkg.submod4', None, True, True, True, True, True),
+     (False,
+      '',  # This negates the `prof-mod` configued in the TOML file
+      True, False, False, False, False, False)])
+def test_autoprofile_with_customized_config(
+        explicit_config, prof_mod, prof_imports,
+        add_one, add_two, add_four, add_operator, main):
+    """
+    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
+
+    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()
+
+    assert ('Function: add_one' in raw_output) == add_one
+    assert ('Function: add_two' in raw_output) == add_two
+    assert ('Function: add_four' in raw_output) == add_four
+    assert ('Function: add_operator' in raw_output) == add_operator
+    assert ('Function: _main' in raw_output) == main
+
+    # `summarize` is configured by `tool.line_profiler.cli`
+    assert ('- add_one' in raw_output) == add_one
+    assert ('- add_two' in raw_output) == add_two
+    assert ('- add_four' in raw_output) == add_four
+    assert ('- add_operator' in raw_output) == add_operator
+    assert ('- _main' in raw_output) == main
+
+    # 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
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 7108a5d6..f24c27fd 100644
--- a/tests/test_explicit_profile.py
+++ b/tests/test_explicit_profile.py
@@ -48,21 +48,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():
@@ -70,48 +70,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():
@@ -121,23 +121,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])
@@ -146,26 +145,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 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()
+    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()
+
+        assert not (temp_dpath / 'profile_output.txt').exists()
+        assert (temp_dpath / outfile).exists()
 
 
 @pytest.mark.parametrize('package', [True, False])
@@ -188,79 +187,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():
@@ -271,81 +271,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():
@@ -355,56 +355,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
+        code = ub.codeblock(
+            '''
+            from line_profiler import profile
 
-        @profile
-        def func1(a):
-            return a + 1
+            @profile
+            def func1(a):
+                return a + 1
 
-        @profile
-        def func2(a):
-            return a + 1
+            @profile
+            def func2(a):
+                return a + 1
 
-        @profile
-        def func3(a):
-            return a + 1
+            @profile
+            def func3(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)
-
-    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()
-    temp_dpath.delete()
+            @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)
+
+        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
 
 
 if __name__ == '__main__':
diff --git a/tests/test_toml_config.py b/tests/test_toml_config.py
new file mode 100644
index 00000000..1d0cded3
--- /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)