diff --git a/CHANGELOG.md b/CHANGELOG.md
index fcc74d93..2470c2e6 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,93 @@ All notable changes to this project will be documented in this file.
  
 This project adheres to [Semantic Versioning](http://semver.org/).
 
+## [3.1.0] - 2023-07-01
+
+### [What's new](https://github.com/solidiquis/erdtree/pull/202)
+- [Multiple configs with .erdtree.toml](https://github.com/solidiquis/erdtree/pull/201)
+- [Increased performance with --suppress-size](https://github.com/solidiquis/erdtree/pull/203)
+- [-x, --one-file-system](https://github.com/solidiquis/erdtree/pull/204)
+- [Support for NO_COLOR](https://github.com/solidiquis/erdtree/pull/205)
+- [Inverted flat layout](https://github.com/solidiquis/erdtree/pull/206)
+- [Aliases: atime, ctime, and mtime](https://github.com/solidiquis/erdtree/pull/207)
+- [ctrlc handler to restore cursor if progress indicator is enabled](https://github.com/solidiquis/erdtree/pull/210)
+
+
+### [.erdtree.toml](https://github.com/solidiquis/erdtree/pull/201)
+
+First and foremost:
+
+**`.erdtreerc` is planned for deprecation by v3.3 so please migrate to `.erdtree.toml` by then.**
+
+There is now support for multiple configs:
+
+```
+-c, --config <CONFIG>  Use configuration of named table rather than the top-level table in .erdtree.toml
+```
+
+So given the following example `.erdtree.toml`:
+
+```toml
+icons = true
+human = true
+
+# Compute file sizes like `du`
+[du]
+disk_usage = "block"
+icons = true
+layout = "flat"
+no-ignore = true
+no-git = true
+hidden = true
+level = 1
+
+# Do as `ls -l`
+[ls]
+icons = true
+human = true
+level = 1
+suppress-size = true
+long = true
+no-ignore = true
+hidden = true
+
+# How many lines of Rust are in this code base?
+[rs]
+disk-usage = "line"
+level = 1
+pattern = "\\.rs$"
+```
+
+```
+$ erd
+
+# equivalant to 
+
+$ erd --human --icons
+```
+
+...
+
+```
+$ erd -c ls
+
+# equivalent to
+
+$ erd --icons --human --level 1 --suppress-size --long --no-ignore --hidden
+```
+
+etc.
+
+For further information on how to get started with the new `.erdtree.toml` please refer to the [README.md](README.md#toml-file).
+
+**NOTE**:
+- Multiple configs are only supported via `.erdtree.toml`.
+- If you have both a `.erdtree.toml` and `.erdtreerc` then the latter will take precedent. Attempts to use `--config` in said case will result in an error and a warning asking to migrate from `.erdtreerc` to `.erdtree.toml`.
+- Again: **`.erdtreerc` will be deprecated in favor of `.erdtree.toml` by v3.3**
+
+
 ## [3.0.2] - 2023-06-12
+- Added support for `.erdtree.toml`
 
 ### Bug fixes
 - [Fixed segmentation fault that occurs with `--long` when file has an invalid user or group](https://github.com/solidiquis/erdtree/pull/193)
diff --git a/Cargo.lock b/Cargo.lock
index efe10645..0a6947e5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,17 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "ahash"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fcb51a0695d8f838b1ee009b3fbf66bda078cd64590202a864a8f3e8c4315c47"
+dependencies = [
+ "getrandom",
+ "once_cell",
+ "version_check",
+]
+
 [[package]]
 name = "aho-corasick"
 version = "0.7.20"
@@ -35,18 +46,44 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
 
+[[package]]
+name = "async-trait"
+version = "0.1.68"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.10",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
+[[package]]
+name = "base64"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
+
 [[package]]
 name = "bitflags"
 version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
 [[package]]
 name = "bstr"
 version = "1.3.0"
@@ -146,12 +183,40 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "config"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d379af7f68bfc21714c6c7dea883544201741d2ce8274bb12fa54f89507f52a7"
+dependencies = [
+ "async-trait",
+ "json5",
+ "lazy_static",
+ "nom",
+ "pathdiff",
+ "ron",
+ "rust-ini",
+ "serde",
+ "serde_json",
+ "toml",
+ "yaml-rust",
+]
+
 [[package]]
 name = "core-foundation-sys"
 version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03e69e28e9f7f77debdedbaafa2866e1de9ba56df55a8bd7cfc724c25a09987c"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "crossterm"
 version = "0.26.1"
@@ -177,6 +242,26 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "ctrlc"
+version = "3.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a011bbe2c35ce9c1f143b7af6f94f29a167beb4cd1d29e6740ce836f723120e"
+dependencies = [
+ "nix",
+ "windows-sys 0.48.0",
+]
+
 [[package]]
 name = "cxx"
 version = "1.0.94"
@@ -221,6 +306,16 @@ dependencies = [
  "syn 2.0.10",
 ]
 
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
 [[package]]
 name = "dirs"
 version = "5.0.0"
@@ -241,15 +336,23 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "dlv-list"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
+
 [[package]]
 name = "erdtree"
-version = "3.0.2"
+version = "3.1.0"
 dependencies = [
  "ansi_term",
  "chrono",
  "clap",
  "clap_complete",
+ "config",
  "crossterm",
+ "ctrlc",
  "dirs",
  "errno 0.3.1",
  "filesize",
@@ -322,6 +425,16 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "getrandom"
 version = "0.2.9"
@@ -346,6 +459,15 @@ dependencies = [
  "regex",
 ]
 
+[[package]]
+name = "hashbrown"
+version = "0.12.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
+dependencies = [
+ "ahash",
+]
+
 [[package]]
 name = "heck"
 version = "0.4.1"
@@ -443,6 +565,12 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "itoa"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
+
 [[package]]
 name = "js-sys"
 version = "0.3.61"
@@ -452,6 +580,17 @@ dependencies = [
  "wasm-bindgen",
 ]
 
+[[package]]
+name = "json5"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
+dependencies = [
+ "pest",
+ "pest_derive",
+ "serde",
+]
+
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -473,6 +612,12 @@ dependencies = [
  "cc",
 ]
 
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
 [[package]]
 name = "linux-raw-sys"
 version = "0.1.4"
@@ -520,6 +665,12 @@ version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 
+[[package]]
+name = "minimal-lexical"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
+
 [[package]]
 name = "mio"
 version = "0.8.6"
@@ -532,6 +683,28 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "nix"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfdda3d196821d6af13126e40375cdf7da646a96114af134d5f417a9a1dc8e1a"
+dependencies = [
+ "bitflags",
+ "cfg-if",
+ "libc",
+ "static_assertions",
+]
+
+[[package]]
+name = "nom"
+version = "7.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
+dependencies = [
+ "memchr",
+ "minimal-lexical",
+]
+
 [[package]]
 name = "nu-ansi-term"
 version = "0.46.0"
@@ -567,6 +740,16 @@ version = "1.17.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
 
+[[package]]
+name = "ordered-multimap"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccd746e37177e1711c20dd619a1620f34f5c8b569c53590a72dedd5344d8924a"
+dependencies = [
+ "dlv-list",
+ "hashbrown",
+]
+
 [[package]]
 name = "os_str_bytes"
 version = "6.4.1"
@@ -602,6 +785,56 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "pathdiff"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
+
+[[package]]
+name = "pest"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16833386b02953ca926d19f64af613b9bf742c48dcd5e09b32fbfc9740bf84e2"
+dependencies = [
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7763190f9406839f99e5197afee8c9e759969f7dbfa40ad3b8dbee8757b745b5"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "249061b22e99973da1f5f5f1410284419e283bb60b79255bf5f42a94b66a2e00"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn 2.0.10",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "457c310cfc9cf3f22bc58901cc7f0d3410ac5d6298e432a4f9a6138565cb6df6"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
+
 [[package]]
 name = "proc-macro-error"
 version = "1.0.4"
@@ -681,6 +914,27 @@ version = "0.6.29"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
 
+[[package]]
+name = "ron"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88073939a61e5b7680558e6be56b419e208420c2adb92be54921fa6b72283f1a"
+dependencies = [
+ "base64",
+ "bitflags",
+ "serde",
+]
+
+[[package]]
+name = "rust-ini"
+version = "0.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6d5f2436026b4f6e79dc829837d467cc7e9a55ee40e750d716713540715a2df"
+dependencies = [
+ "cfg-if",
+ "ordered-multimap",
+]
+
 [[package]]
 name = "rustix"
 version = "0.36.9"
@@ -709,6 +963,12 @@ dependencies = [
  "windows-sys 0.45.0",
 ]
 
+[[package]]
+name = "ryu"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
+
 [[package]]
 name = "same-file"
 version = "1.0.6"
@@ -735,6 +995,42 @@ name = "serde"
 version = "1.0.156"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "314b5b092c0ade17c00142951e50ced110ec27cea304b1037c6969246c2469a4"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.156"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d7e29c4601e36bcec74a223228dce795f4cd3616341a4af93520ca1a837c087d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 1.0.109",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.97"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bdf3bf93142acad5821c99197022e170842cdbc1c30482b98750c688c640842a"
+dependencies = [
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "479fb9d862239e610720565ca91403019f2f00410f1864c5aa7479b950a76ed8"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
 
 [[package]]
 name = "signal-hook"
@@ -772,6 +1068,12 @@ version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strip-ansi-escapes"
 version = "0.1.1"
@@ -872,6 +1174,27 @@ dependencies = [
  "winapi",
 ]
 
+[[package]]
+name = "toml"
+version = "0.5.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "typenum"
+version = "1.16.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "497961ef93d974e23eb6f433eb5fe1b7930b659f06d12dec6fc44a8f554c0bba"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e79c4d996edb816c91e4308506774452e55e95c3c9de07b6729e17e15a5ef81"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.8"
@@ -1179,3 +1502,12 @@ name = "windows_x86_64_msvc"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "yaml-rust"
+version = "0.4.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
+dependencies = [
+ "linked-hash-map",
+]
diff --git a/Cargo.toml b/Cargo.toml
index c6eb1e4d..8f4d2878 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "erdtree"
-version = "3.0.2"
+version = "3.1.0"
 edition = "2021"
 authors = ["Benjamin Nguyen <benjamin.van.nguyen@gmail.com>"]
 description = """
@@ -12,7 +12,7 @@ documentation = "https://github.com/solidiquis/erdtree"
 homepage = "https://github.com/solidiquis/erdtree"
 repository = "https://github.com/solidiquis/erdtree"
 keywords = ["tree", "find", "ls", "du", "commandline"]
-exclude = ["assets/*", "scripts/*"]
+exclude = ["assets/*", "scripts/*", "example/*"]
 readme = "README.md"
 license = "MIT"
 rust-version = "1.70.0"
@@ -28,7 +28,9 @@ ansi_term = "0.12.1"
 chrono = "0.4.24"
 clap = { version = "4.1.1", features = ["derive"] }
 clap_complete = "4.1.1"
+config = { version = "0.13.3", features = ["toml"] }
 crossterm = "0.26.1"
+ctrlc = "3.4.0"
 dirs = "5.0"
 errno = "0.3.1"
 filesize = "0.2.0"
diff --git a/README.md b/README.md
index a37e6fba..48d4d300 100644
--- a/README.md
+++ b/README.md
@@ -28,6 +28,8 @@ You can think of `erdtree` as a little bit of `du`, `tree`, `find`, `wc` and `ls
 * [Installation](#installation)
 * [Documentation](#documentation)
   - [Configuration file](#configuration-file)
+      - [Toml file](#toml-file)
+      - [.erdtreerc](#erdtreerc)
   - [Hardlinks](#hardlinks)
   - [Symlinks](#symlinks)
   - [Disk usage](#disk-usage)
@@ -48,6 +50,7 @@ You can think of `erdtree` as a little bit of `du`, `tree`, `find`, `wc` and `ls
   - [Redirecting output and colorization](#redirecting-output-and-colorization)
   - [Parallelism](#parallelism)
   - [Completions](#completions)
+  - [Same filesystem](#same-filesystem)
 * [Comparisons against similar programs](#comparisons-against-similar-programs)
   - [exa](#exa)
   - [dua](#dua)
@@ -70,6 +73,9 @@ Arguments:
           Directory to traverse; defaults to current working directory
 
 Options:
+  -c, --config <CONFIG>
+          Use configuration of named table rather than the top-level table in .erdtree.toml
+
   -C, --color <COLOR>
           Mode of coloring output
           
@@ -128,9 +134,9 @@ Options:
           Which kind of timestamp to use; modified by default
 
           Possible values:
-          - create: Timestamp showing when the file was created
-          - access: Timestamp showing when the file was last accessed
-          - mod:    Timestamp showing when the file was last modified
+          - create: Time created (alias: ctime)
+          - access: Time last accessed (alias: atime)
+          - mod:    Time last modified (alias: mtime)
 
       --time-format <TIME_FORMAT>
           Which format to use for the timestamp; default by default
@@ -198,7 +204,7 @@ Options:
   -T, --threads <THREADS>
           Number of threads to use
           
-          [default: 3]
+          [default: 10]
 
   -u, --unit <UNIT>
           Report disk usage in binary or SI units
@@ -209,6 +215,9 @@ Options:
           - bin: Displays disk usage using binary prefixes
           - si:  Displays disk usage using SI prefixes
 
+  -x, --one-file-system
+          Prevent traversal into directories that are on different filesystems
+
   -y, --layout <LAYOUT>
           Which kind of layout to use when rendering the output
           
@@ -218,6 +227,7 @@ Options:
           - regular:  Outputs the tree with the root node at the bottom of the output
           - inverted: Outputs the tree with the root node at the top of the output
           - flat:     Outputs a flat layout using paths rather than an ASCII tree
+          - iflat:    Outputs an inverted flat layout with the root at the top of the output
 
   -., --hidden
           Show hidden files
@@ -316,6 +326,82 @@ Other means of installation to come.
 
 If `erdtree`'s out-of-the-box defaults don't meet your specific requirements, you can set your own defaults using a configuration file.
 
+The configuration file currently comes in two flavors: `.erdtreerc` (to be deprecated) and `.erdtree.toml`. If you have both,
+`.erdtreerc` will take precedent and `.erdtree.toml` will be disregarded, but please **note that `.erdtreerc` will be deprecated in the near future.** There is
+no reason to have both.
+
+#### TOML file
+
+`erdtree` will look for `.erdtree.toml in any of the following locations:
+
+On Unix-systems:
+
+```
+$ERDTREE_TOML_PATH
+$XDG_CONFIG_HOME/erdtree/.erdtree.toml
+$XDG_CONFIG_HOME/.erdtree.toml
+$HOME/.config/erdtree/.erdtree.toml
+$HOME/.erdtree.toml
+```
+
+On Windows:
+
+```
+%APPDATA%\erdtree\.erdtree.toml
+```
+
+[Here](example/.erdtree.toml) and below is an example of a valid `.erdtree.toml`:
+
+```toml
+icons = true
+human = true
+
+# Compute file sizes like `du`
+# e.g. `erd --config du`
+[du]
+disk_usage = "block"
+icons = true
+layout = "flat"
+no-ignore = true
+no-git = true
+hidden = true
+level = 1
+
+# Do as `ls -l`
+# e.g. `erd --config ls`
+[ls]
+icons = true
+human = true
+level = 1
+suppress-size = true
+long = true
+
+# How many lines of Rust are in this code base?
+# e.g. `erd --config rs`
+[rs]
+disk-usage = "line"
+level = 1
+pattern = "\\.rs$"
+```
+
+`.erdtree.toml` supports multiple configurations. The top-level table is the main config that will be applied without additional arguments.
+If you wish to use a separate configuration, create a named table like `du` above, set your arguments, and invoke it like so:
+
+```
+$ erd --config du
+
+# equivalent to
+
+$ erd --disk-usage block --icons --layout flat --no-ignore --no-git --hidden --level 1
+```
+
+As far as the arguments go there are only three rules you need to be aware of:
+1. `.erdtree.toml` only accepts long-named arguments without the preceding "--".
+2. Types are enforced, so numbers are expected to be numbers, booleans are expected to be booleans, strings are expected to be strings, and so on and so forth.
+3. `snake_case` and `kebap-case` works.
+
+#### .erdtreerc
+
 `erdtree` will look for a configuration file in any of the following locations:
 
 On Linux/Mac/Unix-like:
@@ -333,24 +419,11 @@ The format of a config file is as follows:
 - Every line is an `erdtree` option/argument.
 - Lines starting with `#` are considered comments and are thus ignored.
 
-Arguments passed to `erdtree` take precedence. If you have a config that you would like to ignore without deleting you can use `--no-config`.
+Arguments passed to `erdtree` on the command-line will override those found in `.erdtreerc`.
 
-Here is an example of a valid configuration file:
-
-```
-# Long argument
---icons
---human
+[Click here](example/.erdtreerc) for an example `.erdtreerc`.
 
-# or short argument
--l
-
-# args can be passed like this
--d logical
-
-# or like this
---unit=si
-```
+**If you have a config that you would like to ignore without deleting you can use `--no-config`.**
 
 ### Hardlinks
 
@@ -453,7 +526,7 @@ Additionally, the word and line-count of directories are the summation of all of
 
 ### Layouts
 
-`erdtree` comes with three layouts:
+`erdtree` comes with four layouts:
 
 ```
 -y, --layout <LAYOUT>
@@ -465,6 +538,7 @@ Additionally, the word and line-count of directories are the summation of all of
       - regular:  Outputs the tree with the root node at the bottom of the output
       - inverted: Outputs the tree with the root node at the top of the output
       - flat:     Outputs a flat layout using paths rather than an ASCII tree
+      - iflat:    Outputs an inverted flat layout with the root at the top of the output
 ```
 
 * The `inverted` layout a more traditional `tree`-like layout where the root node is at the very top of the output.
@@ -602,13 +676,13 @@ Currently only available on Unix-like platforms. Support for Windows is planned.
     --octal
       Show permissions in numeric octal format instead of symbolic
 
-    --time <TIME>
+  --time <TIME>
       Which kind of timestamp to use; modified by default
 
       Possible values:
-      - create: Timestamp showing when the file was created
-      - access: Timestamp showing when the file was last accessed
-      - mod:    Timestamp showing when the file was last modified
+      - create: Time created (alias: ctime)
+      - access: Time last accessed (alias: atime)
+      - mod:    Time last modified (alias: mtime)
 
     --time-format <TIME_FORMAT>
       Which format to use for the timestamp; default by default
@@ -701,6 +775,8 @@ If, however, the default behavior doesn't suit your needs you have control over
       - force: Turn on colorization always
 ```
 
+`erdtree` also supports [NO_COLOR](https://no-color.org/).
+
 <p align="center">
   <img src="https://github.com/solidiquis/erdtree/blob/master/assets/colorization.png?raw=true" alt="failed to load picture" />
 </p>
@@ -735,6 +811,15 @@ $ et --completions zsh > ~/.oh-my-zsh/completions/_erd
 $ source ~/.zshrc
 ```
 
+### Same filesystem
+
+If you are traversing a directory that contains mount points to other filesystems that you do not wish to traverse, use the following:
+
+```
+-x, --one-file-system
+      Prevent traversal into directories that are on different filesystems
+```
+
 ## Rules for contributing
 
 For rules on how to contribute please refer to [CONTRIBUTING.md](CONTRIBUTING.md).
diff --git a/example/.erdtree.toml b/example/.erdtree.toml
new file mode 100644
index 00000000..006cb2ac
--- /dev/null
+++ b/example/.erdtree.toml
@@ -0,0 +1,28 @@
+icons = true
+human = true
+
+# Compute file sizes like `du`
+[du]
+disk_usage = "block"
+icons = true
+layout = "flat"
+no-ignore = true
+no-git = true
+hidden = true
+level = 1
+
+# Do as `ls -l`
+[ls]
+icons = true
+human = true
+level = 1
+suppress-size = true
+long = true
+no-ignore = true
+hidden = true
+
+# How many lines of Rust are in this code base?
+[rs]
+disk-usage = "line"
+level = 1
+pattern = "\\.rs$"
diff --git a/example/.erdtreerc b/example/.erdtreerc
new file mode 100644
index 00000000..184b15ef
--- /dev/null
+++ b/example/.erdtreerc
@@ -0,0 +1,9 @@
+# Long argument
+--icons
+--human
+
+# or short argument
+-l
+
+# args can be passed like this
+-d logical
diff --git a/rustfmt.toml b/rustfmt.toml
new file mode 100644
index 00000000..8c795ae5
--- /dev/null
+++ b/rustfmt.toml
@@ -0,0 +1 @@
+match_block_trailing_comma = true
diff --git a/src/context/args.rs b/src/context/args.rs
new file mode 100644
index 00000000..17027ccb
--- /dev/null
+++ b/src/context/args.rs
@@ -0,0 +1,136 @@
+use super::{config, error::Error, Context};
+use clap::{
+    builder::ArgAction, parser::ValueSource, ArgMatches, Command, CommandFactory, FromArgMatches,
+};
+use std::{
+    ffi::{OsStr, OsString},
+    path::PathBuf,
+};
+
+/// Allows the implementor to compute [`ArgMatches`] that reconciles arguments from both the
+/// command-line as well as the config file that gets loaded.
+pub trait Reconciler: CommandFactory + FromArgMatches {
+    /// Loads in arguments from both the command-line as well as the config file and reconciles
+    /// identical arguments between the two using these rules:
+    ///
+    /// 1. If no config file is present, use arguments strictly from the command-line.
+    /// 2. If an argument was provided via the CLI then override the argument from the config.
+    /// 3. If an argument is sourced from its default value because a user didn't provide it via
+    ///    the CLI, then select the argument from the config if it exists.
+    fn compute_args() -> Result<ArgMatches, Error> {
+        let cmd = Self::command().args_override_self(true);
+
+        let user_args = Command::clone(&cmd).get_matches();
+
+        if user_args.get_one::<bool>("no_config").is_some_and(|b| *b) {
+            return Ok(user_args);
+        }
+
+        let maybe_config_args = {
+            let named_table = user_args.get_one::<String>("config");
+
+            if let Some(rc) = load_rc_config_args() {
+                if named_table.is_some() {
+                    return Err(Error::Rc);
+                }
+
+                Some(rc)
+            } else {
+                let toml = load_toml_config_args(named_table.map(String::as_str))?;
+
+                if named_table.is_some() && toml.is_none() {
+                    return Err(Error::NoToml);
+                }
+
+                toml
+            }
+        };
+
+        let Some(config_args) = maybe_config_args else {
+            return Ok(user_args);
+        };
+
+        let mut final_args = init_empty_args();
+
+        for arg in cmd.get_arguments() {
+            let arg_id = arg.get_id();
+            let id_str = arg_id.as_str();
+
+            if id_str == "dir" {
+                if let Some(dir) = user_args.try_get_one::<PathBuf>(id_str)? {
+                    final_args.push(OsString::from(dir));
+                }
+                continue;
+            }
+
+            let argument_source = user_args
+                .value_source(id_str)
+                .map_or(&config_args, |source| {
+                    if matches!(source, ValueSource::CommandLine) {
+                        &user_args
+                    } else {
+                        &config_args
+                    }
+                });
+
+            let Some(key) = arg.get_long().map(|l| format!("--{l}")).map(OsString::from) else {
+                continue
+            };
+
+            match arg.get_action() {
+                ArgAction::SetTrue => {
+                    if argument_source
+                        .try_get_one::<bool>(id_str)?
+                        .is_some_and(|b| *b)
+                    {
+                        final_args.push(key);
+                    };
+                },
+                ArgAction::SetFalse => continue,
+                _ => {
+                    let Ok(Some(raw)) = argument_source.try_get_raw(id_str) else {
+                        continue;
+                    };
+                    final_args.push(key);
+                    final_args.extend(raw.map(OsStr::to_os_string));
+                },
+            }
+        }
+
+        Ok(cmd.get_matches_from(final_args))
+    }
+}
+
+impl Reconciler for Context {}
+
+/// Creates a properly formatted `Vec<OsString>` that [`clap::Command`] would understand.
+#[inline]
+fn init_empty_args() -> Vec<OsString> {
+    vec![OsString::from("--")]
+}
+
+/// Loads an [`ArgMatches`] from `.erdtreerc`.
+#[inline]
+fn load_rc_config_args() -> Option<ArgMatches> {
+    if let Some(rc_config) = config::rc::read_config_to_string() {
+        let parsed_args = config::rc::parse(&rc_config);
+        let config_args = Context::command().get_matches_from(parsed_args);
+
+        return Some(config_args);
+    }
+
+    None
+}
+
+/// Loads an [`ArgMatches`] from `.erdtree.toml`.
+#[inline]
+fn load_toml_config_args(named_table: Option<&str>) -> Result<Option<ArgMatches>, Error> {
+    if let Ok(toml_config) = config::toml::load() {
+        let parsed_args = config::toml::parse(toml_config, named_table)?;
+        let config_args = Context::command().get_matches_from(parsed_args);
+
+        return Ok(Some(config_args));
+    }
+
+    Ok(None)
+}
diff --git a/src/context/color.rs b/src/context/color.rs
index e9447beb..caf39c73 100644
--- a/src/context/color.rs
+++ b/src/context/color.rs
@@ -1,4 +1,14 @@
 use clap::ValueEnum;
+use once_cell::sync::OnceCell;
+use std::{env, ffi::OsString};
+
+pub static NO_COLOR: OnceCell<Option<OsString>> = OnceCell::new();
+
+/// Reads in the `NO_COLOR` environment variable to determine whether or not to display color in
+/// the output.
+pub fn no_color_env() {
+    let _ = NO_COLOR.set(env::var_os("NO_COLOR"));
+}
 
 /// Enum to determine how the output should be colorized.
 #[derive(Clone, Copy, Debug, ValueEnum, PartialEq, Eq, Default)]
diff --git a/src/context/config/mod.rs b/src/context/config/mod.rs
new file mode 100644
index 00000000..c28c3a7a
--- /dev/null
+++ b/src/context/config/mod.rs
@@ -0,0 +1,22 @@
+const ERDTREE_CONFIG_TOML: &str = ".erdtree.toml";
+const ERDTREE_TOML_PATH: &str = "ERDTREE_TOML_PATH";
+
+const ERDTREE_CONFIG_NAME: &str = ".erdtreerc";
+const ERDTREE_CONFIG_PATH: &str = "ERDTREE_CONFIG_PATH";
+
+const ERDTREE_DIR: &str = "erdtree";
+
+#[cfg(unix)]
+const CONFIG_DIR: &str = ".config";
+
+#[cfg(unix)]
+const HOME: &str = "HOME";
+
+#[cfg(unix)]
+const XDG_CONFIG_HOME: &str = "XDG_CONFIG_HOME";
+
+/// Concerned with loading `.erdtreerc`.
+pub mod rc;
+
+/// Concerned with loading `.erdtree.toml`.
+pub mod toml;
diff --git a/src/context/config.rs b/src/context/config/rc.rs
similarity index 61%
rename from src/context/config.rs
rename to src/context/config/rc.rs
index 377d48bf..27192b75 100644
--- a/src/context/config.rs
+++ b/src/context/config/rc.rs
@@ -1,22 +1,6 @@
-use std::{
-    env, fs,
-    path::{Path, PathBuf},
-};
+use std::{env, fs, path::PathBuf};
 
-const ERDTREE_CONFIG_NAME: &str = ".erdtreerc";
-const ERDTREE_CONFIG_PATH: &str = "ERDTREE_CONFIG_PATH";
-const ERDTREE_DIR: &str = "erdtree";
-
-#[cfg(unix)]
-const CONFIG_DIR: &str = ".config";
-
-#[cfg(unix)]
-const HOME: &str = "HOME";
-
-#[cfg(unix)]
-const XDG_CONFIG_HOME: &str = "XDG_CONFIG_HOME";
-
-/// Reads the config file into a `String` if there is one. When `None` is provided then the config
+/// Reads the config file into a `String` if there is one, otherwise returns `None`.
 /// is looked for in the following locations in order:
 ///
 /// - `$ERDTREE_CONFIG_PATH`
@@ -25,25 +9,19 @@ const XDG_CONFIG_HOME: &str = "XDG_CONFIG_HOME";
 /// - `$HOME/.config/erdtree/.erdtreerc`
 /// - `$HOME/.erdtreerc`
 #[cfg(unix)]
-pub fn read_config_to_string<T: AsRef<Path>>(path: Option<T>) -> Option<String> {
-    path.map(fs::read_to_string)
-        .and_then(Result::ok)
-        .or_else(config_from_config_path)
+pub fn read_config_to_string() -> Option<String> {
+    config_from_config_path()
         .or_else(config_from_xdg_path)
         .or_else(config_from_home)
         .map(|e| prepend_arg_prefix(&e))
 }
-
-/// Reads the config file into a `String` if there is one. When `None` is provided then the config
 /// is looked for in the following locations in order (Windows specific):
 ///
 /// - `$ERDTREE_CONFIG_PATH`
 /// - `%APPDATA%/erdtree/.erdtreerc`
 #[cfg(windows)]
-pub fn read_config_to_string<T: AsRef<Path>>(path: Option<T>) -> Option<String> {
-    path.map(fs::read_to_string)
-        .and_then(Result::ok)
-        .or_else(config_from_config_path)
+pub fn read_config_to_string() -> Option<String> {
+    config_from_config_path()
         .or_else(config_from_appdata)
         .map(|e| prepend_arg_prefix(&e))
 }
@@ -61,13 +39,13 @@ pub fn parse<'a>(config: &'a str) -> Vec<&'a str> {
                 .next()
                 .map_or(true, |ch| ch != '#')
         })
-        .flat_map(str::split_ascii_whitespace)
+        .flat_map(str::split_whitespace)
         .collect::<Vec<&'a str>>()
 }
 
 /// Try to read in config from `ERDTREE_CONFIG_PATH`.
 fn config_from_config_path() -> Option<String> {
-    env::var_os(ERDTREE_CONFIG_PATH)
+    env::var_os(super::ERDTREE_CONFIG_PATH)
         .map(PathBuf::from)
         .map(fs::read_to_string)
         .and_then(Result::ok)
@@ -78,15 +56,15 @@ fn config_from_config_path() -> Option<String> {
 /// - `$HOME/.erdtreerc`
 #[cfg(not(windows))]
 fn config_from_home() -> Option<String> {
-    let home = env::var_os(HOME).map(PathBuf::from)?;
+    let home = env::var_os(super::HOME).map(PathBuf::from)?;
 
     let config_path = home
-        .join(CONFIG_DIR)
-        .join(ERDTREE_DIR)
-        .join(ERDTREE_CONFIG_NAME);
+        .join(super::CONFIG_DIR)
+        .join(super::ERDTREE_DIR)
+        .join(super::ERDTREE_CONFIG_NAME);
 
     fs::read_to_string(config_path).ok().or_else(|| {
-        let config_path = home.join(ERDTREE_CONFIG_NAME);
+        let config_path = home.join(super::ERDTREE_CONFIG_NAME);
         fs::read_to_string(config_path).ok()
     })
 }
@@ -97,7 +75,9 @@ fn config_from_home() -> Option<String> {
 fn config_from_appdata() -> Option<String> {
     let app_data = dirs::config_dir()?;
 
-    let config_path = app_data.join(ERDTREE_DIR).join(ERDTREE_CONFIG_NAME);
+    let config_path = app_data
+        .join(super::ERDTREE_DIR)
+        .join(super::ERDTREE_CONFIG_NAME);
 
     fs::read_to_string(config_path).ok()
 }
@@ -107,12 +87,14 @@ fn config_from_appdata() -> Option<String> {
 /// - `$XDG_CONFIG_HOME/.erdtreerc`
 #[cfg(unix)]
 fn config_from_xdg_path() -> Option<String> {
-    let xdg_config = env::var_os(XDG_CONFIG_HOME).map(PathBuf::from)?;
+    let xdg_config = env::var_os(super::XDG_CONFIG_HOME).map(PathBuf::from)?;
 
-    let config_path = xdg_config.join(ERDTREE_DIR).join(ERDTREE_CONFIG_NAME);
+    let config_path = xdg_config
+        .join(super::ERDTREE_DIR)
+        .join(super::ERDTREE_CONFIG_NAME);
 
     fs::read_to_string(config_path).ok().or_else(|| {
-        let config_path = xdg_config.join(ERDTREE_CONFIG_NAME);
+        let config_path = xdg_config.join(super::ERDTREE_CONFIG_NAME);
         fs::read_to_string(config_path).ok()
     })
 }
diff --git a/src/context/config/toml/error.rs b/src/context/config/toml/error.rs
new file mode 100644
index 00000000..3d2e782d
--- /dev/null
+++ b/src/context/config/toml/error.rs
@@ -0,0 +1,19 @@
+use config::ConfigError;
+
+#[derive(Debug, thiserror::Error)]
+pub enum Error {
+    #[error("Failed to load .erdtree.toml")]
+    LoadConfig,
+
+    #[error("The configuration file is improperly formatted")]
+    InvalidFormat(#[from] ConfigError),
+
+    #[error("Named table '{0}' was not found in '.erdtree.toml'")]
+    MissingAltConfig(String),
+
+    #[error("'#{0}' is required to be a pointer-sized unsigned integer type")]
+    InvalidInteger(String),
+
+    #[error("'#{0}' has a type that is invalid")]
+    InvalidArgument(String),
+}
diff --git a/src/context/config/toml/mod.rs b/src/context/config/toml/mod.rs
new file mode 100644
index 00000000..002580b2
--- /dev/null
+++ b/src/context/config/toml/mod.rs
@@ -0,0 +1,223 @@
+use config::{Config, File, Value, ValueKind};
+use error::Error;
+use std::{env, ffi::OsString};
+
+/// Errors associated with loading and parsing the toml config file.
+pub mod error;
+
+/// Testing related to `.erdtree.toml`.
+pub mod test;
+
+/// Represents an instruction on how to handle a single key-value pair, which makes up a single
+/// command-line argument, when constructing the arguments vector.
+enum ArgInstructions {
+    /// Used for bool arguments such as `--icons`. When `icons = true` is set in `.erdtree.toml`,
+    /// we only want `--icons` to be pushed into the ultimate arguments vector.
+    PushKeyOnly,
+
+    /// Used for arguments such as `--threads 10`.
+    PushKeyValue { parsed_value: OsString },
+
+    /// If a bool field is set to false in `.erdtree.toml` (e.g. `icons = false`) then we want to
+    /// completely omit the key-value pair from the arguments that we ultimately use.
+    Pass,
+}
+
+/// Takes in a `Config` that is generated from [`load`] returning a `Vec<OsString>` which
+/// represents command-line arguments from `.erdtree.toml`. If a `named_table` is provided then
+/// the top-level table in `.erdtree.toml` is ignored and the configurations specified in the
+/// `named_table` will be used instead.
+pub fn parse(config: Config, named_table: Option<&str>) -> Result<Vec<OsString>, Error> {
+    let mut args_map = config.cache.into_table()?;
+
+    if let Some(table) = named_table {
+        let new_conf = args_map
+            .get(table)
+            .and_then(|conf| conf.clone().into_table().ok())
+            .ok_or_else(|| Error::MissingAltConfig(table.to_owned()))?;
+
+        args_map = new_conf;
+    } else {
+        args_map.retain(|_k, v| !matches!(v.kind, ValueKind::Table(_)));
+    }
+
+    let mut parsed_args = vec![OsString::from("--")];
+
+    let process_key = |s| OsString::from(format!("--{s}").replace('_', "-"));
+
+    for (k, v) in &args_map {
+        match parse_argument(k, v)? {
+            ArgInstructions::PushKeyValue { parsed_value } => {
+                let fmt_key = process_key(k);
+                parsed_args.push(fmt_key);
+                parsed_args.push(parsed_value);
+            },
+
+            ArgInstructions::PushKeyOnly => {
+                let fmt_key = process_key(k);
+                parsed_args.push(fmt_key);
+            },
+
+            ArgInstructions::Pass => continue,
+        }
+    }
+
+    Ok(parsed_args)
+}
+
+/// Reads in `.erdtree.toml` file.
+pub fn load() -> Result<Config, Error> {
+    #[cfg(windows)]
+    return windows::load_toml().ok_or(Error::LoadConfig);
+
+    #[cfg(unix)]
+    unix::load_toml().ok_or(Error::LoadConfig)
+}
+
+/// Attempts to load in `.erdtree.toml` from `$ERDTREE_TOML_PATH`. Will return `None` for whatever
+/// reason.
+fn toml_from_env() -> Option<Config> {
+    let config = env::var_os(super::ERDTREE_TOML_PATH)
+        .map(OsString::into_string)
+        .and_then(Result::ok)?;
+
+    let file = config.strip_suffix(".toml").map(File::with_name)?;
+
+    Config::builder().add_source(file).build().ok()
+}
+
+/// Simple utility used to extract the underlying value from the [`Value`] enum that we get when
+/// loading in the values from `.erdtree.toml`, returning instructions on how the argument should
+/// be processed into the ultimate arguments vector.
+fn parse_argument(keyword: &str, arg: &Value) -> Result<ArgInstructions, Error> {
+    macro_rules! try_parse_num {
+        ($n:expr) => {
+            usize::try_from($n)
+                .map_err(|_e| Error::InvalidInteger(keyword.to_owned()))
+                .map(|num| {
+                    let parsed = OsString::from(format!("{num}"));
+                    ArgInstructions::PushKeyValue {
+                        parsed_value: parsed,
+                    }
+                })
+        };
+    }
+
+    match &arg.kind {
+        ValueKind::Boolean(val) => {
+            if *val {
+                Ok(ArgInstructions::PushKeyOnly)
+            } else {
+                Ok(ArgInstructions::Pass)
+            }
+        },
+        ValueKind::String(val) => Ok(ArgInstructions::PushKeyValue {
+            parsed_value: OsString::from(val),
+        }),
+        ValueKind::I64(val) => try_parse_num!(*val),
+        ValueKind::I128(val) => try_parse_num!(*val),
+        ValueKind::U64(val) => try_parse_num!(*val),
+        ValueKind::U128(val) => try_parse_num!(*val),
+        _ => Err(Error::InvalidArgument(keyword.to_owned())),
+    }
+}
+
+/// Concerned with how to load `.erdtree.toml` on Unix systems.
+#[cfg(unix)]
+mod unix {
+    use super::super::{CONFIG_DIR, ERDTREE_CONFIG_TOML, ERDTREE_DIR, HOME, XDG_CONFIG_HOME};
+    use config::{Config, File};
+    use std::{env, path::PathBuf};
+
+    /// Looks for `.erdtree.toml` in the following locations in order:
+    ///
+    /// - `$ERDTREE_TOML_PATH`
+    /// - `$XDG_CONFIG_HOME/erdtree/.erdtree.toml`
+    /// - `$XDG_CONFIG_HOME/.erdtree.toml`
+    /// - `$HOME/.config/erdtree/.erdtree.toml`
+    /// - `$HOME/.erdtree.toml`
+    pub(super) fn load_toml() -> Option<Config> {
+        super::toml_from_env()
+            .or_else(toml_from_xdg_path)
+            .or_else(toml_from_home)
+    }
+
+    /// Looks for `.erdtree.toml` in the following locations in order:
+    ///
+    /// - `$XDG_CONFIG_HOME/erdtree/.erdtree.toml`
+    /// - `$XDG_CONFIG_HOME/.erdtree.toml`
+    fn toml_from_xdg_path() -> Option<Config> {
+        let config = env::var_os(XDG_CONFIG_HOME).map(PathBuf::from)?;
+
+        let mut file = config
+            .join(ERDTREE_DIR)
+            .join(ERDTREE_CONFIG_TOML)
+            .to_str()
+            .and_then(|s| s.strip_suffix(".toml"))
+            .map(File::with_name);
+
+        if file.is_none() {
+            file = config
+                .join(ERDTREE_CONFIG_TOML)
+                .to_str()
+                .and_then(|s| s.strip_suffix(".toml"))
+                .map(File::with_name);
+        }
+
+        Config::builder().add_source(file?).build().ok()
+    }
+
+    /// Looks for `.erdtree.toml` in the following locations in order:
+    ///
+    /// - `$HOME/.config/erdtree/.erdtree.toml`
+    /// - `$HOME/.erdtree.toml`
+    fn toml_from_home() -> Option<Config> {
+        let home = env::var_os(HOME).map(PathBuf::from)?;
+
+        let mut file = home
+            .join(CONFIG_DIR)
+            .join(ERDTREE_DIR)
+            .join(ERDTREE_CONFIG_TOML)
+            .to_str()
+            .and_then(|s| s.strip_suffix(".toml"))
+            .map(File::with_name);
+
+        if file.is_none() {
+            file = home
+                .join(ERDTREE_CONFIG_TOML)
+                .to_str()
+                .and_then(|s| s.strip_suffix(".toml"))
+                .map(File::with_name);
+        }
+
+        Config::builder().add_source(file?).build().ok()
+    }
+}
+
+/// Concerned with how to load `.erdtree.toml` on Windows.
+#[cfg(windows)]
+mod windows {
+    use super::super::{ERDTREE_CONFIG_TOML, ERDTREE_DIR};
+    use config::{Config, File};
+
+    /// Try to read in config from the following location:
+    /// - `%APPDATA%\erdtree\.erdtree.toml`
+    pub(super) fn load_toml() -> Option<Config> {
+        super::toml_from_env().or_else(toml_from_appdata)
+    }
+
+    /// Try to read in config from the following location:
+    /// - `%APPDATA%\erdtree\.erdtree.toml`
+    fn toml_from_appdata() -> Option<Config> {
+        let app_data = dirs::config_dir()?;
+
+        let file = app_data
+            .join(ERDTREE_DIR)
+            .join(ERDTREE_CONFIG_TOML)
+            .to_str()
+            .and_then(|s| s.strip_prefix(".toml"))
+            .map(File::with_name)?;
+
+        Config::builder().add_source(file).build().ok()
+    }
+}
diff --git a/src/context/config/toml/test.rs b/src/context/config/toml/test.rs
new file mode 100644
index 00000000..adba50d2
--- /dev/null
+++ b/src/context/config/toml/test.rs
@@ -0,0 +1,91 @@
+#[test]
+fn parse_toml() -> Result<(), Box<dyn std::error::Error>> {
+    use config::{Config, File};
+    use std::{ffi::OsString, io::Write};
+    use tempfile::Builder;
+
+    let mut config_file = Builder::new()
+        .prefix(".erdtree")
+        .suffix(".toml")
+        .tempfile()?;
+
+    let toml_contents = r#"
+        icons = true
+        human = true
+        threads = 10
+
+        [grogoroth]
+        disk_usage = "block"
+        icons = true
+        human = false
+        threads = 10
+    "#;
+
+    config_file.write(toml_contents.as_bytes())?;
+
+    let file = config_file
+        .path()
+        .to_str()
+        .and_then(|s| s.strip_suffix(".toml"))
+        .map(File::with_name)
+        .unwrap();
+
+    let config = Config::builder().add_source(file).build()?;
+
+    // TOP-LEVEL TABLE
+    let mut toml = super::parse(config.clone(), None)?;
+
+    let expected = vec![
+        OsString::from("--"),
+        OsString::from("--icons"),
+        OsString::from("--human"),
+        OsString::from("--threads"),
+        OsString::from("10"),
+    ];
+
+    for (i, outer_item) in expected.iter().enumerate() {
+        for j in 0..toml.len() {
+            let inner_item = &toml[j];
+
+            if outer_item == inner_item {
+                toml.swap(i, j);
+            }
+        }
+    }
+
+    assert_eq!(toml.len(), expected.len());
+
+    for (lhs, rhs) in toml.iter().zip(expected.iter()) {
+        assert_eq!(lhs, rhs);
+    }
+
+    // NAMED-TABLE
+    let mut toml = super::parse(config, Some("grogoroth"))?;
+
+    let expected = vec![
+        OsString::from("--"),
+        OsString::from("--disk-usage"),
+        OsString::from("block"),
+        OsString::from("--icons"),
+        OsString::from("--threads"),
+        OsString::from("10"),
+    ];
+
+    for (i, outer_item) in expected.iter().enumerate() {
+        for j in 0..toml.len() {
+            let inner_item = &toml[j];
+
+            if outer_item == inner_item {
+                toml.swap(i, j);
+            }
+        }
+    }
+
+    assert_eq!(toml.len(), expected.len());
+
+    for (lhs, rhs) in toml.iter().zip(expected.iter()) {
+        assert_eq!(lhs, rhs);
+    }
+
+    Ok(())
+}
diff --git a/src/context/error.rs b/src/context/error.rs
index 518133fd..6b2e82b8 100644
--- a/src/context/error.rs
+++ b/src/context/error.rs
@@ -1,14 +1,16 @@
-use clap::Error as ClapError;
+use super::config::toml::error::Error as TomlError;
+use clap::{parser::MatchesError, Error as ClapError};
 use ignore::Error as IgnoreError;
 use regex::Error as RegexError;
+use std::convert::From;
 
 #[derive(Debug, thiserror::Error)]
 pub enum Error {
     #[error("{0}")]
-    ArgParse(#[source] ClapError),
+    ArgParse(ClapError),
 
     #[error("A configuration file was found but failed to parse: {0}")]
-    Config(#[source] ClapError),
+    Config(ClapError),
 
     #[error("No glob was provided")]
     EmptyGlob,
@@ -21,4 +23,22 @@ pub enum Error {
 
     #[error("Missing '--pattern' argument")]
     PatternNotProvided,
+
+    #[error("{0}")]
+    ConfigError(TomlError),
+
+    #[error("{0}")]
+    MatchError(#[from] MatchesError),
+
+    #[error("'--config' was specified but a `.erdtree.toml` file could not be found")]
+    NoToml,
+
+    #[error("Please migrate from `erdtreerc` to `.erdtree.toml` to make use of `--config`")]
+    Rc,
+}
+
+impl From<TomlError> for Error {
+    fn from(value: TomlError) -> Self {
+        Self::ConfigError(value)
+    }
 }
diff --git a/src/context/layout.rs b/src/context/layout.rs
index 4c7557b0..7e88bcc2 100644
--- a/src/context/layout.rs
+++ b/src/context/layout.rs
@@ -10,6 +10,9 @@ pub enum Type {
     /// Outputs the tree with the root node at the top of the output
     Inverted,
 
-    /// Outputs a flat layout using paths rather than an ASCII tree.
+    /// Outputs a flat layout using paths rather than an ASCII tree
     Flat,
+
+    /// Outputs an inverted flat layout with the root at the top of the output
+    Iflat,
 }
diff --git a/src/context/mod.rs b/src/context/mod.rs
index 72765879..829b9ca7 100644
--- a/src/context/mod.rs
+++ b/src/context/mod.rs
@@ -1,6 +1,7 @@
 use super::disk_usage::{file_size::DiskUsage, units::PrefixKind};
 use crate::tty;
-use clap::{parser::ValueSource, ArgMatches, CommandFactory, FromArgMatches, Id, Parser};
+use args::Reconciler;
+use clap::{FromArgMatches, Parser};
 use color::Coloring;
 use error::Error;
 use ignore::{
@@ -11,10 +12,15 @@ use regex::Regex;
 use std::{
     borrow::Borrow,
     convert::From,
-    ffi::{OsStr, OsString},
+    num::NonZeroUsize,
     path::{Path, PathBuf},
+    thread::available_parallelism,
 };
 
+/// Concerned with figuring out how to reconcile arguments provided via the command-line with
+/// arguments that come from a config file.
+pub mod args;
+
 /// Operations to load in defaults from configuration file.
 pub mod config;
 
@@ -43,20 +49,20 @@ pub mod sort;
 #[cfg(unix)]
 pub mod time;
 
-/// Unit tests for [Context]
-#[cfg(test)]
-mod test;
-
 /// Defines the CLI.
 #[derive(Parser, Debug)]
 #[command(name = "erdtree")]
 #[command(author = "Benjamin Nguyen. <benjamin.van.nguyen@gmail.com>")]
-#[command(version = "3.0.2")]
+#[command(version = "3.1.0")]
 #[command(about = "erdtree (erd) is a cross-platform, multi-threaded, and general purpose filesystem and disk usage utility.", long_about = None)]
 pub struct Context {
     /// Directory to traverse; defaults to current working directory
     dir: Option<PathBuf>,
 
+    /// Use configuration of named table rather than the top-level table in .erdtree.toml
+    #[arg(short = 'c', long)]
+    pub config: Option<String>,
+
     /// Mode of coloring output
     #[arg(short = 'C', long, value_enum, default_value_t)]
     pub color: Coloring,
@@ -156,6 +162,10 @@ pub struct Context {
     #[arg(short, long, value_enum, default_value_t)]
     pub unit: PrefixKind,
 
+    /// Prevent traversal into directories that are on different filesystems
+    #[arg(short = 'x', long = "one-file-system")]
+    pub same_fs: bool,
+
     /// Which kind of layout to use when rendering the output
     #[arg(short = 'y', long, value_enum, default_value_t)]
     pub layout: layout::Type,
@@ -241,91 +251,25 @@ pub struct Context {
     pub window_width: Option<usize>,
 }
 
-trait AsVecOfStr {
-    fn as_vec_of_str(&self) -> Vec<&str>;
-}
-impl AsVecOfStr for ArgMatches {
-    fn as_vec_of_str(&self) -> Vec<&str> {
-        self.ids().map(Id::as_str).collect()
-    }
-}
-
 type Predicate = Result<Box<dyn Fn(&DirEntry) -> bool + Send + Sync + 'static>, Error>;
 
 impl Context {
     /// Initializes [Context], optionally reading in the configuration file to override defaults.
     /// Arguments provided will take precedence over config.
-    pub fn init() -> Result<Self, Error> {
-        let user_args = Self::command().args_override_self(true).get_matches();
-
-        let no_config = user_args
-            .get_one::<bool>("no_config")
-            .copied()
-            .unwrap_or(false);
-
-        if no_config {
-            return Self::from_arg_matches(&user_args).map_err(Error::ArgParse);
-        }
-
-        if let Some(ref config) = config::read_config_to_string::<&str>(None) {
-            let raw_config_args = config::parse(config);
-            let config_args = Self::command().get_matches_from(raw_config_args);
-
-            // If the user did not provide any arguments just read from config.
-            if !user_args.args_present() {
-                return Self::from_arg_matches(&config_args).map_err(Error::Config);
-            }
-
-            // If the user did provide arguments we need to reconcile between config and
-            // user arguments.
-            let mut args = vec![OsString::from("--")];
-
-            let mut ids = user_args.as_vec_of_str();
-
-            ids.extend(config_args.as_vec_of_str());
-
-            ids = crate::utils::uniq(ids);
-
-            // HACK:
-            // Going to need to figure out how to handle this better.
-            for id in ids
-                .into_iter()
-                .filter(|&id| id != "Context" && id != "group" && id != "searching")
-            {
-                if id == "dir" {
-                    if let Ok(Some(raw)) = user_args.try_get_raw(id) {
-                        let raw_args = raw.map(OsStr::to_owned).collect::<Vec<OsString>>();
-
-                        args.extend(raw_args);
-                        continue;
-                    }
-                }
-
-                if let Some(user_arg) = user_args.value_source(id) {
-                    match user_arg {
-                        // prioritize the user arg if user provided a command line argument
-                        ValueSource::CommandLine => Self::pick_args_from(id, &user_args, &mut args),
-
-                        // otherwise prioritize argument from the config
-                        _ => Self::pick_args_from(id, &config_args, &mut args),
-                    }
-                } else {
-                    Self::pick_args_from(id, &config_args, &mut args);
-                }
-            }
-
-            let clargs = Self::command().get_matches_from(args);
-            return Self::from_arg_matches(&clargs).map_err(Error::Config);
-        }
-
-        Self::from_arg_matches(&user_args).map_err(Error::ArgParse)
+    pub fn try_init() -> Result<Self, Error> {
+        let args = Self::compute_args()?;
+        Self::from_arg_matches(&args).map_err(Error::Config)
     }
 
     /// Determines whether or not it's appropriate to display color in output based on
     /// the Coloring, and whether or not stdout is connected to a tty.
     ///
     /// If Coloring is Force then this will always evaluate to `false`.
-    pub const fn no_color(&self) -> bool {
+    pub fn no_color(&self) -> bool {
+        if let Some(Some(var)) = color::NO_COLOR.get() {
+            return !var.is_empty();
+        }
+
         match self.color {
             Coloring::Auto if !self.stdout_is_tty => true,
             Coloring::None => true,
@@ -368,23 +312,6 @@ impl Context {
         self.file_type.unwrap_or_default()
     }
 
-    /// Used to pick either from config or user args when constructing [Context].
-    fn pick_args_from(id: &str, matches: &ArgMatches, args: &mut Vec<OsString>) {
-        if let Ok(Some(raw)) = matches.try_get_raw(id) {
-            let kebap = id.replace('_', "-");
-
-            let raw_args = raw
-                .map(OsStr::to_owned)
-                .map(|s| vec![OsString::from(format!("--{kebap}")), s])
-                .filter(|pair| pair[1] != "false")
-                .flatten()
-                .filter(|s| s != "true")
-                .collect::<Vec<_>>();
-
-            args.extend(raw_args);
-        }
-    }
-
     /// Predicate used for filtering via regular expressions and file-type. When matching regular
     /// files, directories will always be included since matched files will need to be bridged back
     /// to the root node somehow. Empty sets not producing an output is handled by [`Tree`].
@@ -420,11 +347,11 @@ impl Context {
                 match file_type {
                     file::Type::File if entry_type.map_or(true, |ft| !ft.is_file()) => {
                         return false
-                    }
+                    },
                     file::Type::Link if entry_type.map_or(true, |ft| !ft.is_symlink()) => {
                         return false
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 }
                 let file_name = dir_entry.file_name().to_string_lossy();
                 re.is_match(&file_name)
@@ -489,11 +416,11 @@ impl Context {
                 match file_type {
                     file::Type::File if entry_type.map_or(true, |ft| !ft.is_file()) => {
                         return false
-                    }
+                    },
                     file::Type::Link if entry_type.map_or(true, |ft| !ft.is_symlink()) => {
                         return false
-                    }
-                    _ => {}
+                    },
+                    _ => {},
                 }
 
                 let matched = overrides.matched(dir_entry.path(), false);
@@ -564,7 +491,7 @@ impl Context {
     }
 
     /// The default number of threads to use for disk-reads and parallel processing.
-    const fn num_threads() -> usize {
-        3
+    fn num_threads() -> usize {
+        available_parallelism().map(NonZeroUsize::get).unwrap_or(3)
     }
 }
diff --git a/src/context/test.rs b/src/context/test.rs
deleted file mode 100644
index 7aa792ca..00000000
--- a/src/context/test.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-use crate::context::sort;
-use clap::{CommandFactory, FromArgMatches};
-
-use super::{config, Context};
-
-const TEST_CONFIG: &str = "./tests/data/.erdtreerc";
-
-#[test]
-fn config() {
-    let context = context_from_config().expect("Failed to build Context from config path");
-
-    let level = context.level();
-
-    assert_eq!(level, 1, "Failed to properly read 'level' from config");
-
-    let sort = context.sort;
-
-    assert_eq!(
-        sort,
-        sort::Type::Size,
-        "Failed to properly read 'sort' from config"
-    );
-
-    let icons = context.icons;
-
-    assert!(icons, "Failed to properly read 'icons' from config");
-}
-
-fn context_from_config() -> Option<Context> {
-    config::read_config_to_string(Some(TEST_CONFIG))
-        .as_ref()
-        .and_then(|config| {
-            let raw_config_args = config::parse(config);
-            let config_args = Context::command().get_matches_from(raw_config_args);
-            Context::from_arg_matches(&config_args).ok()
-        })
-}
diff --git a/src/context/time.rs b/src/context/time.rs
index b1e03b4e..88f9657c 100644
--- a/src/context/time.rs
+++ b/src/context/time.rs
@@ -3,14 +3,17 @@ use clap::ValueEnum;
 /// Different types of timestamps available in long-view.
 #[derive(Copy, Clone, Debug, ValueEnum, PartialEq, Eq, PartialOrd, Ord, Default)]
 pub enum Stamp {
-    /// Timestamp showing when the file was created.
+    /// Time created (alias: ctime)
+    #[value(alias("ctime"))]
     Create,
 
-    /// Timestamp showing when the file was last accessed.
+    /// Time last accessed (alias: atime)
+    #[value(alias("atime"))]
     Access,
 
-    /// Timestamp showing when the file was last modified.
+    /// Time last modified (alias: mtime)
     #[default]
+    #[value(alias("mtime"))]
     Mod,
 }
 
diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
index 37049b32..3301a890 100644
--- a/src/disk_usage/file_size/byte.rs
+++ b/src/disk_usage/file_size/byte.rs
@@ -123,7 +123,7 @@ impl Display for Metric {
                 } else {
                     format!("{} {}", self.value, SiPrefix::Base)
                 }
-            }
+            },
             PrefixKind::Bin => {
                 if self.human_readable {
                     let unit = BinPrefix::from(self.value);
@@ -138,7 +138,7 @@ impl Display for Metric {
                 } else {
                     format!("{} {}", self.value, BinPrefix::Base)
                 }
-            }
+            },
         };
 
         write!(f, "{display}")?;
diff --git a/src/icons/fs.rs b/src/icons/fs.rs
index b19f08f8..aa56ac70 100644
--- a/src/icons/fs.rs
+++ b/src/icons/fs.rs
@@ -61,7 +61,7 @@ pub fn compute_with_color(
             let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
             let styled_icon = ansi_string.to_string();
             Cow::from(styled_icon)
-        }
+        },
         _ => icon,
     };
 
diff --git a/src/main.rs b/src/main.rs
index 8daf7b27..5c29e858 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -22,8 +22,8 @@
 use clap::CommandFactory;
 use context::{layout, Context};
 use progress::Message;
-use render::{Engine, Flat, Inverted, Regular};
-use std::{error::Error, io::stdout, process::ExitCode};
+use render::{Engine, Flat, FlatInverted, Inverted, Regular};
+use std::{error::Error, io::stdout, process::ExitCode, sync::Arc};
 use tree::Tree;
 
 /// Operations to wrangle ANSI escaped strings.
@@ -64,7 +64,11 @@ mod tty;
 mod utils;
 
 fn main() -> ExitCode {
-    if let Err(e) = run() {
+    let result = run();
+
+    tty::restore_tty();
+
+    if let Err(e) = result {
         eprintln!("{e}");
         return ExitCode::FAILURE;
     }
@@ -72,45 +76,74 @@ fn main() -> ExitCode {
 }
 
 fn run() -> Result<(), Box<dyn Error>> {
-    let ctx = Context::init()?;
+    let ctx = Context::try_init()?;
 
     if let Some(shell) = ctx.completions {
         clap_complete::generate(shell, &mut Context::command(), "erd", &mut stdout());
         return Ok(());
     }
 
+    context::color::no_color_env();
+
     styles::init(ctx.no_color());
 
-    let indicator = (ctx.stdout_is_tty && !ctx.no_progress).then(progress::Indicator::measure);
+    let indicator = (ctx.stdout_is_tty && !ctx.no_progress)
+        .then(progress::Indicator::measure)
+        .map(Arc::new);
 
-    let (tree, ctx) = Tree::try_init_and_update_context(ctx, indicator.as_ref()).map_err(|err| {
-        if let Some(progress) = &indicator {
-            progress.mailbox().send(Message::RenderReady).unwrap()
-        }
-        err
-    })?;
+    if indicator.is_some() {
+        let indicator = indicator.clone();
 
-    let output = match ctx.layout {
-        layout::Type::Flat => {
-            let render = Engine::<Flat>::new(tree, ctx);
-            format!("{render}")
-        }
-        layout::Type::Inverted => {
-            let render = Engine::<Inverted>::new(tree, ctx);
-            format!("{render}")
-        }
-        layout::Type::Regular => {
-            let render = Engine::<Regular>::new(tree, ctx);
+        ctrlc::set_handler(move || {
+            let _ = progress::IndicatorHandle::terminate(indicator.clone());
+            tty::restore_tty();
+        })?;
+    }
+
+    let (tree, ctx) = match Tree::try_init(ctx, indicator.clone()) {
+        Ok(res) => res,
+        Err(err) => {
+            let _ = progress::IndicatorHandle::terminate(indicator);
+            return Err(Box::new(err));
+        },
+    };
+
+    macro_rules! compute_output {
+        ($t:ty) => {{
+            let render = Engine::<$t>::new(tree, ctx);
             format!("{render}")
-        }
+        }};
+    }
+
+    let output = match ctx.layout {
+        layout::Type::Flat => compute_output!(Flat),
+        layout::Type::Iflat => compute_output!(FlatInverted),
+        layout::Type::Inverted => compute_output!(Inverted),
+        layout::Type::Regular => compute_output!(Regular),
     };
 
-    if let Some(progress) = indicator {
+    if let Some(mut progress) = indicator {
         progress.mailbox().send(Message::RenderReady)?;
-        progress.join_handle.join().unwrap()?;
+
+        if let Some(hand) = Arc::get_mut(&mut progress) {
+            hand.join_handle
+                .take()
+                .map(|h| h.join().unwrap())
+                .transpose()?;
+        }
     }
 
-    println!("{output}");
+    #[cfg(debug_assertions)]
+    {
+        if std::env::var_os("ERDTREE_DEBUG").is_none() {
+            println!("{output}");
+        }
+    }
+
+    #[cfg(not(debug_assertions))]
+    {
+        println!("{output}");
+    }
 
     Ok(())
 }
diff --git a/src/progress.rs b/src/progress.rs
index 4d7bc21e..87395f94 100644
--- a/src/progress.rs
+++ b/src/progress.rs
@@ -5,10 +5,17 @@ use crossterm::{
 };
 use std::{
     io::{self, Write},
-    sync::mpsc::{self, Sender},
-    thread,
+    sync::{
+        mpsc::{self, SendError, SyncSender},
+        Arc,
+    },
+    thread::{self, JoinHandle},
+    time::Duration,
 };
 
+/// Timeout used for [`IndicatorHandle`]'s `priority_mailbox`.
+const PRIORITY_MAIL_TIMEOUT: Duration = Duration::from_nanos(1);
+
 /// Responsible for displying the progress indicator. This struct will be owned by a separate
 /// thread that is responsible for displaying the progress text whereas the [`IndicatorHandle`]
 /// is how the outside world will interact with it.
@@ -20,10 +27,14 @@ pub struct Indicator<'a> {
 
 /// This struct is how the outside world will inform the [`Indicator`] about the progress of the
 /// program. The `join_handle` returns the handle to the thread that owns the [`Indicator`] and the
-/// `mailbox` is the [`Sender`] channel that allows [`Message`]s to be sent to [`Indicator`].
+/// `mailbox` is the [`SyncSender`] channel that allows [`Message`]s to be sent to [`Indicator`].
+///
+/// The `priority_mailbox` is used to prematurely terminate the [`Indicator`] in the case of say a
+/// `SIGINT` signal.
 pub struct IndicatorHandle {
-    pub join_handle: thread::JoinHandle<Result<(), Error>>,
-    mailbox: Sender<Message>,
+    pub join_handle: Option<JoinHandle<Result<(), Error>>>,
+    mailbox: SyncSender<Message>,
+    priority_mailbox: SyncSender<()>,
 }
 
 /// The different messages that could be sent to the thread that owns the [`Indicator`].
@@ -41,7 +52,7 @@ pub enum Message {
 }
 
 /// All of the different states the [`Indicator`] can be in during its life cycle.
-#[derive(Default, PartialEq)]
+#[derive(Debug, Default, PartialEq)]
 enum IndicatorState {
     /// We are currently reading from disk.
     #[default]
@@ -57,7 +68,13 @@ enum IndicatorState {
 /// Errors associated with [`crossterm`];
 #[derive(Debug, thiserror::Error)]
 #[error(transparent)]
-pub struct Error(#[from] io::Error);
+pub enum Error {
+    #[error("#{0}")]
+    Io(#[from] io::Error),
+
+    #[error("#{0}")]
+    Send(#[from] SendError<()>),
+}
 
 impl Default for Indicator<'_> {
     /// Default constructor for [`Indicator`].
@@ -73,19 +90,41 @@ impl Default for Indicator<'_> {
 impl IndicatorHandle {
     /// The constructor for an [`IndicatorHandle`].
     pub fn new(
-        join_handle: thread::JoinHandle<Result<(), Error>>,
-        mailbox: Sender<Message>,
+        join_handle: Option<JoinHandle<Result<(), Error>>>,
+        mailbox: SyncSender<Message>,
+        priority_mailbox: SyncSender<()>,
     ) -> Self {
         Self {
             join_handle,
             mailbox,
+            priority_mailbox,
         }
     }
 
     /// Getter for a cloned `mailbox` wherewith to send [`Message`]s to the [`Indicator`].
-    pub fn mailbox(&self) -> Sender<Message> {
+    pub fn mailbox(&self) -> SyncSender<Message> {
         self.mailbox.clone()
     }
+
+    /// Getter for a cloned `priority_mailbox` wherewith to send [`Message`]s to the [`Indicator`].
+    pub fn priority_mailbox(&self) -> SyncSender<()> {
+        self.priority_mailbox.clone()
+    }
+
+    /// Send a message through to the `priority_mailbox` tear down the [`Indicator`].
+    pub fn terminate(this: Option<Arc<Self>>) -> Result<(), Error> {
+        if let Some(mut handle) = this {
+            handle.priority_mailbox().send(())?;
+
+            if let Some(hand) = Arc::get_mut(&mut handle) {
+                hand.join_handle
+                    .take()
+                    .map(|h| h.join().unwrap())
+                    .transpose()?;
+            }
+        }
+        Ok(())
+    }
 }
 
 impl<'a> Indicator<'a> {
@@ -93,7 +132,8 @@ impl<'a> Indicator<'a> {
     /// through its internal states. An [`IndicatorHandle`] is returned as a mechanism to allow the
     /// outside world to send messages to the worker thread and ultimately to the [`Indicator`].
     pub fn measure() -> IndicatorHandle {
-        let (tx, rx) = mpsc::channel();
+        let (tx, rx) = mpsc::sync_channel(1024);
+        let (ptx, prx) = mpsc::sync_channel(1);
 
         let join_handle = thread::spawn(move || {
             let mut indicator = Self::default();
@@ -102,27 +142,29 @@ impl<'a> Indicator<'a> {
             indicator.stdout.execute(cursor::Hide)?;
 
             while let Ok(msg) = rx.recv() {
-                if indicator.state == IndicatorState::Indexing {
-                    match msg {
-                        Message::Index => indicator.index()?,
-                        Message::DoneIndexing => {
-                            indicator.update_state(IndicatorState::Rendering)?;
-                        }
-                        Message::RenderReady => {}
-                    }
-                }
-
-                if indicator.state == IndicatorState::Rendering && msg == Message::RenderReady {
+                if prx.recv_timeout(PRIORITY_MAIL_TIMEOUT).is_ok() {
                     indicator.update_state(IndicatorState::Done)?;
                     break;
                 }
+
+                match msg {
+                    Message::Index => indicator.index()?,
+                    Message::DoneIndexing => {
+                        indicator.update_state(IndicatorState::Rendering)?;
+                    },
+                    Message::RenderReady => {
+                        indicator.update_state(IndicatorState::Done)?;
+                        return Ok(());
+                    },
+                }
+
                 indicator.stdout.execute(cursor::RestorePosition)?;
             }
 
             Ok(())
         });
 
-        IndicatorHandle::new(join_handle, tx)
+        IndicatorHandle::new(Some(join_handle), tx, ptx)
     }
 
     /// Updates the `state` of the [`Indicator`] to `new_state`, immediately running an associated
@@ -137,14 +179,13 @@ impl<'a> Indicator<'a> {
                 stdout.execute(terminal::Clear(ClearType::CurrentLine))?;
                 stdout.execute(cursor::RestorePosition)?;
                 self.rendering();
-            }
+            },
 
-            (Rendering, Done) => {
+            (Rendering | Indexing, Done) => {
                 let stdout = &mut self.stdout;
                 stdout.execute(terminal::Clear(ClearType::CurrentLine))?;
                 stdout.execute(cursor::RestorePosition)?;
-                stdout.execute(cursor::Show)?;
-            }
+            },
             _ => (),
         }
 
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 7798374f..c24172e1 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -79,7 +79,7 @@ impl<'a> Cell<'a> {
                 let icon = node.compute_icon(ctx.no_color());
 
                 write!(f, "{pre}{icon} {name}")
-            }
+            },
 
             _ => unreachable!(),
         }
@@ -278,17 +278,17 @@ impl<'a> Cell<'a> {
             return write!(f, "");
         }
 
-        let padding = ctx.max_size_width
-            + 1
-            + match ctx.disk_usage {
-                DiskUsage::Logical | DiskUsage::Physical => match ctx.unit {
-                    PrefixKind::Si if ctx.human => 2,
-                    PrefixKind::Bin if ctx.human => 3,
-                    PrefixKind::Si => 0,
-                    PrefixKind::Bin => 1,
-                },
-                _ => 0,
-            };
+        let mut padding = ctx.max_size_width + 1;
+
+        match ctx.disk_usage {
+            DiskUsage::Logical | DiskUsage::Physical => match ctx.unit {
+                PrefixKind::Si if ctx.human => padding += 2,
+                PrefixKind::Bin if ctx.human => padding += 3,
+                PrefixKind::Si => padding += 0,
+                PrefixKind::Bin => padding += 1,
+            },
+            _ => padding -= 1,
+        }
 
         let formatted_placeholder = format!("{:>padding$}", styles::PLACEHOLDER);
 
@@ -319,11 +319,11 @@ impl<'a> Cell<'a> {
                 PrefixKind::Si => {
                     let pre = SiPrefix::from(metric.value);
                     styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
-                }
+                },
                 PrefixKind::Bin => {
                     let pre = BinPrefix::from(metric.value);
                     styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
-                }
+                },
             }
         };
 
@@ -351,11 +351,11 @@ impl<'a> Cell<'a> {
             PrefixKind::Si => {
                 let pre = SiPrefix::from(bytes);
                 styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
-            }
+            },
             PrefixKind::Bin => {
                 let pre = BinPrefix::from(bytes);
                 styles::get_du_theme().unwrap().get(pre.as_str()).unwrap()
-            }
+            },
         };
 
         let out = color.paint(format!("{metric:>max_size_width$}"));
diff --git a/src/render/layout/flat_inverted.rs b/src/render/layout/flat_inverted.rs
new file mode 100644
index 00000000..4cff0754
--- /dev/null
+++ b/src/render/layout/flat_inverted.rs
@@ -0,0 +1,44 @@
+use crate::{
+    render::{
+        grid::{self, Row},
+        Engine, FlatInverted,
+    },
+    tree::{count::FileCount, Tree},
+};
+use indextree::NodeEdge;
+use std::fmt::{self, Display};
+
+impl Display for Engine<FlatInverted> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ctx = self.context();
+        let tree = self.tree();
+        let arena = tree.arena();
+        let root_id = tree.root_id();
+        let max_depth = ctx.level();
+        let mut file_count_data = vec![];
+
+        for edge in root_id.traverse(arena) {
+            let node_id = match edge {
+                NodeEdge::Start(id) => id,
+                NodeEdge::End(_) => continue,
+            };
+            file_count_data.push(Tree::compute_file_count(node_id, arena));
+
+            let node = arena[node_id].get();
+
+            if node.depth() > max_depth {
+                continue;
+            }
+
+            let row = Row::<grid::Flat>::new(node, ctx, None);
+
+            writeln!(f, "{row}")?;
+        }
+
+        if !file_count_data.is_empty() {
+            write!(f, "\n{}", FileCount::from(file_count_data))?;
+        }
+
+        Ok(())
+    }
+}
diff --git a/src/render/layout/mod.rs b/src/render/layout/mod.rs
index 29b727f8..4ef0adc4 100644
--- a/src/render/layout/mod.rs
+++ b/src/render/layout/mod.rs
@@ -4,5 +4,8 @@ pub mod regular;
 /// See [`super::Flat`]
 pub mod flat;
 
+/// See [`super::FlatInverted`]
+pub mod flat_inverted;
+
 /// See [`super::Inverted`]
 pub mod inverted;
diff --git a/src/render/layout/regular.rs b/src/render/layout/regular.rs
index 7ba14b48..09ed9f4c 100644
--- a/src/render/layout/regular.rs
+++ b/src/render/layout/regular.rs
@@ -50,7 +50,7 @@ impl Display for Engine<Regular> {
                     }
 
                     continue;
-                }
+                },
             };
 
             file_count_data.push(Tree::compute_file_count(current_node_id, arena));
diff --git a/src/render/long/mod.rs b/src/render/long/mod.rs
index cd38cff2..2a01c94e 100644
--- a/src/render/long/mod.rs
+++ b/src/render/long/mod.rs
@@ -67,7 +67,7 @@ impl fmt::Display for Display<'_> {
         match (group, ino, nlink) {
             (false, false, false) => {
                 write!(f, "{perms} {owner} {time}")
-            }
+            },
 
             (true, true, true) => {
                 let group_out = Cell::new(node, ctx, cell::Kind::Group);
@@ -78,46 +78,46 @@ impl fmt::Display for Display<'_> {
                     f,
                     "{ino_out} {perms} {nlink_out} {owner} {group_out} {time}"
                 )
-            }
+            },
 
             (true, false, false) => {
                 let group_out = Cell::new(node, ctx, cell::Kind::Group);
 
                 write!(f, "{perms} {owner} {group_out} {time}")
-            }
+            },
 
             (true, true, false) => {
                 let group_out = Cell::new(node, ctx, cell::Kind::Group);
                 let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
 
                 write!(f, "{ino_out} {perms} {owner} {group_out} {time}")
-            }
+            },
 
             (false, false, true) => {
                 let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
 
                 write!(f, "{perms} {nlink_out} {owner} {time}")
-            }
+            },
 
             (true, false, true) => {
                 let group_out = Cell::new(node, ctx, cell::Kind::Group);
                 let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
 
                 write!(f, "{perms} {nlink_out} {owner} {group_out} {time}")
-            }
+            },
 
             (false, true, false) => {
                 let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
 
                 write!(f, "{ino_out} {perms} {owner} {time}")
-            }
+            },
 
             (false, true, true) => {
                 let ino_out = Cell::new(node, ctx, cell::Kind::Ino);
                 let nlink_out = Cell::new(node, ctx, cell::Kind::Nlink);
 
                 write!(f, "{ino_out} {perms} {nlink_out} {owner} {time}")
-            }
+            },
         }
     }
 }
diff --git a/src/render/mod.rs b/src/render/mod.rs
index d70a5ad5..b06440ee 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -26,6 +26,9 @@ pub struct Engine<T> {
 /// The flat output that is similar to `du`, without the ASCII tree.
 pub struct Flat;
 
+/// Same as [`Flat`] but the root is at the top of the output.
+pub struct FlatInverted;
+
 /// The tree output with the root directory at the bottom of the output.
 pub struct Regular;
 
diff --git a/src/tree/error.rs b/src/tree/error.rs
index f95e40d5..570ee792 100644
--- a/src/tree/error.rs
+++ b/src/tree/error.rs
@@ -33,8 +33,11 @@ pub enum Error {
 
     #[cfg(unix)]
     #[error("{0}")]
-    Persmissions(#[from] PermissionsError),
+    Permissions(#[from] PermissionsError),
 
     #[error("{0}")]
     UninitializedTheme(#[from] StyleError<'static>),
+
+    #[error("Terminated erdtree...")]
+    Terminated,
 }
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index da18aab7..fff08152 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -2,7 +2,7 @@ use crate::{
     context::{column, Context},
     disk_usage::file_size::FileSize,
     fs::inode::Inode,
-    progress::{self, IndicatorHandle, Message},
+    progress::{IndicatorHandle, Message},
     utils,
 };
 use count::FileCount;
@@ -16,7 +16,10 @@ use std::{
     fs,
     path::PathBuf,
     result::Result as StdResult,
-    sync::mpsc::{self, Sender},
+    sync::{
+        mpsc::{self, Sender},
+        Arc,
+    },
     thread,
 };
 use visitor::{BranchVisitorBuilder, TraversalState};
@@ -52,9 +55,9 @@ impl Tree {
 
     /// Initiates file-system traversal and [Tree] as well as updates the [Context] object with
     /// various properties necessary to render output.
-    pub fn try_init_and_update_context(
+    pub fn try_init(
         mut ctx: Context,
-        indicator: Option<&IndicatorHandle>,
+        indicator: Option<Arc<IndicatorHandle>>,
     ) -> Result<(Self, Context)> {
         let mut column_properties = column::Properties::from(&ctx);
 
@@ -102,12 +105,12 @@ impl Tree {
     fn traverse(
         ctx: &Context,
         column_properties: &mut column::Properties,
-        indicator: Option<&IndicatorHandle>,
+        indicator: Option<Arc<IndicatorHandle>>,
     ) -> Result<(Arena<Node>, NodeId)> {
         let walker = WalkParallel::try_from(ctx)?;
         let (tx, rx) = mpsc::channel();
 
-        let progress_indicator_mailbox = indicator.map(progress::IndicatorHandle::mailbox);
+        let progress_indicator_mailbox = indicator.map(|arc| arc.mailbox());
 
         thread::scope(|s| {
             let res = s.spawn(move || {
@@ -117,7 +120,9 @@ impl Tree {
 
                 while let Ok(TraversalState::Ongoing(node)) = rx.recv() {
                     if let Some(ref mailbox) = progress_indicator_mailbox {
-                        let _ = mailbox.send(Message::Index);
+                        if mailbox.send(Message::Index).is_err() {
+                            return Err(Error::Terminated);
+                        }
                     }
 
                     if node.is_dir() {
@@ -147,7 +152,9 @@ impl Tree {
                 }
 
                 if let Some(ref mailbox) = progress_indicator_mailbox {
-                    let _ = mailbox.send(Message::DoneIndexing);
+                    if mailbox.send(Message::DoneIndexing).is_err() {
+                        return Err(Error::Terminated);
+                    }
                 }
 
                 let root_id = root_id.ok_or(Error::MissingRoot)?;
@@ -179,7 +186,7 @@ impl Tree {
 
             walker.visit(&mut visitor_builder);
 
-            tx.send(TraversalState::Done).unwrap();
+            let _ = tx.send(TraversalState::Done);
 
             res.join().unwrap()
         })
@@ -436,8 +443,13 @@ impl TryFrom<&Context> for WalkParallel {
             .git_ignore(!ctx.no_ignore)
             .hidden(!ctx.hidden)
             .overrides(ctx.no_git_override()?)
+            .same_file_system(ctx.same_fs)
             .threads(ctx.threads);
 
+        if ctx.suppress_size && ctx.level() == 1 {
+            builder.max_depth(Some(1)).threads(1);
+        }
+
         if ctx.pattern.is_some() {
             if ctx.glob || ctx.iglob {
                 builder.filter_entry(ctx.glob_predicate()?);
diff --git a/src/tree/node/cmp.rs b/src/tree/node/cmp.rs
index d5301c96..cac2bda1 100644
--- a/src/tree/node/cmp.rs
+++ b/src/tree/node/cmp.rs
@@ -12,10 +12,10 @@ pub fn comparator(ctx: &Context) -> Box<NodeComparator> {
     match ctx.dir_order {
         dir::Order::First => {
             Box::new(move |a, b| dir_first_comparator(a, b, base_comparator(sort_type)))
-        }
+        },
         dir::Order::Last => {
             Box::new(move |a, b| dir_last_comparator(a, b, base_comparator(sort_type)))
-        }
+        },
         dir::Order::None => base_comparator(sort_type),
     }
 }
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 4d09b039..cca2e9e5 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -256,28 +256,28 @@ impl TryFrom<(DirEntry, &Context)> for Node {
                     DiskUsage::Logical => {
                         let metric = byte::Metric::init_logical(&metadata, ctx.unit, ctx.human);
                         Some(FileSize::Byte(metric))
-                    }
+                    },
                     DiskUsage::Physical => {
                         let metric =
                             byte::Metric::init_physical(path, &metadata, ctx.unit, ctx.human);
                         Some(FileSize::Byte(metric))
-                    }
+                    },
                     DiskUsage::Line => {
                         let metric = line_count::Metric::init(path);
                         metric.map(FileSize::Line)
-                    }
+                    },
                     DiskUsage::Word => {
                         let metric = word_count::Metric::init(path);
                         metric.map(FileSize::Word)
-                    }
+                    },
 
                     #[cfg(unix)]
                     DiskUsage::Block => {
                         let metric = block::Metric::init(&metadata);
                         Some(FileSize::Block(metric))
-                    }
+                    },
                 }
-            }
+            },
             _ => None,
         };
 
diff --git a/src/tree/visitor.rs b/src/tree/visitor.rs
index 1900b4f3..add11a97 100644
--- a/src/tree/visitor.rs
+++ b/src/tree/visitor.rs
@@ -44,9 +44,11 @@ impl ParallelVisitor for Branch<'_> {
 
         match Node::try_from((dir_entry, self.ctx)) {
             Ok(node) => {
-                self.tx.send(TraversalState::from(node)).unwrap();
+                if self.tx.send(TraversalState::from(node)).is_err() {
+                    return WalkState::Quit;
+                }
                 WalkState::Continue
-            }
+            },
             _ => WalkState::Skip,
         }
     }
diff --git a/src/tty/mod.rs b/src/tty/mod.rs
index 502c3d8a..f5cd922b 100644
--- a/src/tty/mod.rs
+++ b/src/tty/mod.rs
@@ -1,4 +1,5 @@
 #![allow(clippy::module_name_repetitions)]
+use crossterm::{cursor, ExecutableCommand};
 use std::io::{stdin, stdout, IsTerminal};
 
 #[cfg(windows)]
@@ -18,6 +19,13 @@ pub fn stdout_is_tty() -> bool {
     stdout().is_terminal()
 }
 
+/// Restore terminal settings.
+pub fn restore_tty() {
+    stdout()
+        .execute(cursor::Show)
+        .expect("Failed to restore cursor");
+}
+
 /// Attempts to get the current size of the tty's window. Returns `None` if stdout isn't tty or if
 /// failed to get width.
 pub fn get_window_width(stdout_is_tty: bool) -> Option<usize> {
diff --git a/src/utils.rs b/src/utils.rs
index 13786a7e..f84e8038 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -1,5 +1,3 @@
-use std::{cmp::Eq, collections::HashSet, hash::Hash};
-
 #[macro_export]
 /// Ruby-like way to crate a hashmap.
 macro_rules! hash {
@@ -21,19 +19,6 @@ macro_rules! hash {
     };
 }
 
-/// Ensure every item in a `Vec` is unique.
-#[inline]
-pub fn uniq<T>(items: Vec<T>) -> Vec<T>
-where
-    T: Eq + Hash,
-{
-    items
-        .into_iter()
-        .collect::<HashSet<_>>()
-        .into_iter()
-        .collect()
-}
-
 /// How many integral digits are there?
 #[inline]
 pub const fn num_integral(value: u64) -> usize {
diff --git a/tests/data/.erdtreerc b/tests/data/.erdtreerc
deleted file mode 100644
index dc8d7f41..00000000
--- a/tests/data/.erdtreerc
+++ /dev/null
@@ -1,3 +0,0 @@
---level 1
---sort size
---icons