diff --git a/src/context/output.rs b/src/context/output.rs
index 8b7582b2..79f6c680 100644
--- a/src/context/output.rs
+++ b/src/context/output.rs
@@ -20,8 +20,9 @@ pub struct ColumnProperties {
 impl From<&Context> for ColumnProperties {
     fn from(ctx: &Context) -> Self {
         let unit_width = match ctx.unit {
-            PrefixKind::Si => 2,
-            PrefixKind::Bin => 3,
+            PrefixKind::Bin if ctx.human => 3,
+            PrefixKind::Si if ctx.human => 2,
+            _ => 1,
         };
 
         Self {
diff --git a/src/disk_usage/file_size.rs b/src/disk_usage/file_size.rs
deleted file mode 100644
index 7305e8ed..00000000
--- a/src/disk_usage/file_size.rs
+++ /dev/null
@@ -1,191 +0,0 @@
-use super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
-use crate::{
-    styles::{self, get_du_theme, get_placeholder_style},
-    utils, Context,
-};
-use ansi_term::Style;
-use clap::ValueEnum;
-use filesize::PathExt;
-use std::{borrow::Cow, fs::Metadata, ops::AddAssign, path::Path};
-
-/// Represents either logical or physical size and handles presentation.
-#[derive(Clone, Debug)]
-pub struct FileSize {
-    pub bytes: u64,
-    #[allow(dead_code)]
-    disk_usage: DiskUsage,
-    prefix_kind: PrefixKind,
-    human_readable: bool,
-    unpadded_display: Option<String>,
-
-    // Precomputed style to use
-    style: Option<&'static Style>,
-
-    // Does this file size use `B` without a prefix?
-    uses_base_unit: Option<()>,
-
-    // How many columns are required for the size (without prefix).
-    pub size_columns: usize,
-}
-
-/// Determines between logical or physical size for display
-#[derive(Copy, Clone, Debug, ValueEnum, Default)]
-pub enum DiskUsage {
-    /// How many bytes does a file contain
-    Logical,
-
-    /// How much actual space on disk, taking into account sparse files and compression.
-    #[default]
-    Physical,
-}
-
-impl FileSize {
-    /// Initializes a [`FileSize`].
-    pub const fn new(
-        bytes: u64,
-        disk_usage: DiskUsage,
-        human_readable: bool,
-        prefix_kind: PrefixKind,
-    ) -> Self {
-        Self {
-            bytes,
-            disk_usage,
-            human_readable,
-            prefix_kind,
-            unpadded_display: None,
-            style: None,
-            uses_base_unit: None,
-            size_columns: 0,
-        }
-    }
-
-    /// Computes the logical size of a file given its [Metadata].
-    pub fn logical(md: &Metadata, prefix_kind: PrefixKind, human_readable: bool) -> Self {
-        let bytes = md.len();
-        Self::new(bytes, DiskUsage::Logical, human_readable, prefix_kind)
-    }
-
-    /// Computes the physical size of a file given its [Path] and [Metadata].
-    pub fn physical(
-        path: &Path,
-        md: &Metadata,
-        prefix_kind: PrefixKind,
-        human_readable: bool,
-    ) -> Option<Self> {
-        path.size_on_disk_fast(md)
-            .ok()
-            .map(|bytes| Self::new(bytes, DiskUsage::Physical, human_readable, prefix_kind))
-    }
-
-    pub fn unpadded_display(&self) -> Option<&str> {
-        self.unpadded_display.as_deref()
-    }
-
-    /// Precompute the raw (unpadded) display and sets the number of columns the size (without
-    /// the prefix) will occupy. Also sets the [Style] to use in advance to style the size output.
-    pub fn precompute_unpadded_display(&mut self) {
-        let fbytes = self.bytes as f64;
-
-        match self.prefix_kind {
-            PrefixKind::Si => {
-                let unit = SiPrefix::from(fbytes);
-                let base_value = unit.base_value();
-
-                if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
-                } else if matches!(unit, SiPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
-                    self.uses_base_unit = Some(());
-                } else {
-                    let size = fbytes / (base_value as f64);
-                    self.unpadded_display = Some(format!("{size:.2} {unit}"));
-                    self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
-                }
-
-                if let Ok(theme) = get_du_theme() {
-                    let style = theme.get(format!("{unit}").as_str());
-                    self.style = style;
-                }
-            }
-            PrefixKind::Bin => {
-                let unit = BinPrefix::from(fbytes);
-                let base_value = unit.base_value();
-
-                if !self.human_readable {
-                    self.unpadded_display = Some(format!("{} B", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
-                } else if matches!(unit, BinPrefix::Base) {
-                    self.unpadded_display = Some(format!("{} {unit}", self.bytes));
-                    self.size_columns = utils::num_integral(self.bytes);
-                    self.uses_base_unit = Some(());
-                } else {
-                    let size = fbytes / (base_value as f64);
-                    self.unpadded_display = Some(format!("{size:.2} {unit}"));
-                    self.size_columns = utils::num_integral((size * 100.0).floor() as u64) + 1;
-                }
-
-                if let Ok(theme) = get_du_theme() {
-                    let style = theme.get(format!("{unit}").as_str());
-                    self.style = style;
-                }
-            }
-        }
-    }
-
-    /// Formats [`FileSize`] for presentation.
-    pub fn format(&self, max_size_width: usize, max_size_unit_width: usize) -> String {
-        let out = if self.human_readable {
-            let mut precomputed = self.unpadded_display().unwrap().split(' ');
-            let size = precomputed.next().unwrap();
-            let unit = precomputed.next().unwrap();
-
-            if self.uses_base_unit.is_some() {
-                format!(
-                    "{:>max_size_width$} {unit:>max_size_unit_width$}",
-                    self.bytes
-                )
-            } else {
-                format!("{size:>max_size_width$} {unit:>max_size_unit_width$}")
-            }
-        } else {
-            format!("{:<max_size_width$} B", self.bytes)
-        };
-
-        if let Some(style) = self.style {
-            style.paint(out).to_string()
-        } else {
-            out
-        }
-    }
-
-    /// Returns a placeholder or empty string.
-    pub fn placeholder(ctx: &Context) -> String {
-        if ctx.suppress_size || ctx.max_size_width == 0 {
-            return String::new();
-        }
-
-        let placeholder = get_placeholder_style().map_or_else(
-            |_| Cow::from(styles::PLACEHOLDER),
-            |style| Cow::from(style.paint(styles::PLACEHOLDER).to_string()),
-        );
-
-        let placeholder_padding = placeholder.len()
-            + ctx.max_size_width
-            + match ctx.unit {
-                PrefixKind::Si if ctx.human => 2,
-                PrefixKind::Bin if ctx.human => 3,
-                PrefixKind::Si => 0,
-                PrefixKind::Bin => 1,
-            };
-
-        format!("{placeholder:>placeholder_padding$}")
-    }
-}
-
-impl AddAssign<&Self> for FileSize {
-    fn add_assign(&mut self, rhs: &Self) {
-        self.bytes += rhs.bytes;
-    }
-}
diff --git a/src/disk_usage/file_size/block.rs b/src/disk_usage/file_size/block.rs
new file mode 100644
index 00000000..bcb982ec
--- /dev/null
+++ b/src/disk_usage/file_size/block.rs
@@ -0,0 +1,22 @@
+use std::{
+    fmt::{self, Display},
+    fs::Metadata,
+    os::unix::fs::MetadataExt,
+};
+
+#[derive(Default)]
+pub struct Metric {
+    pub value: u64,
+}
+
+impl Metric {
+    pub fn init(md: &Metadata) -> Self {
+        Self { value: md.blocks() }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
+}
diff --git a/src/disk_usage/file_size/byte.rs b/src/disk_usage/file_size/byte.rs
new file mode 100644
index 00000000..4ecfef78
--- /dev/null
+++ b/src/disk_usage/file_size/byte.rs
@@ -0,0 +1,172 @@
+use super::super::units::{BinPrefix, PrefixKind, SiPrefix, UnitPrefix};
+use filesize::PathExt;
+use std::{
+    fmt::{self, Display},
+    fs::Metadata,
+    path::Path,
+};
+
+/// Concerned with measuring file size in bytes, whether logical or physical determined by `kind`.
+/// Binary or SI units used for reporting determined by `prefix_kind`.
+pub struct Metric {
+    pub value: u64,
+    pub human_readable: bool,
+    #[allow(dead_code)]
+    kind: MetricKind,
+    prefix_kind: PrefixKind,
+}
+
+/// Represents the appropriate method in which to compute bytes. `Logical` represent the total amount
+/// of bytes in a file; `Physical` represents how many bytes are actually used to store the file on
+/// disk.
+pub enum MetricKind {
+    Logical,
+    Physical,
+}
+
+impl Metric {
+    /// Initializes a [Metric] that stores the total amount of bytes in a file.
+    pub fn init_logical(
+        metadata: &Metadata,
+        prefix_kind: PrefixKind,
+        human_readable: bool,
+    ) -> Self {
+        let value = metadata.len();
+        let kind = MetricKind::Logical;
+
+        Self {
+            value,
+            human_readable,
+            kind,
+            prefix_kind,
+        }
+    }
+
+    /// Initializes an empty [Metric] used to represent the total amount of bytes of a file.
+    pub const fn init_empty_logical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+        Self {
+            value: 0,
+            human_readable,
+            kind: MetricKind::Logical,
+            prefix_kind,
+        }
+    }
+
+    /// Initializes an empty [Metric] used to represent the total disk space of a file in bytes.
+    pub const fn init_empty_physical(human_readable: bool, prefix_kind: PrefixKind) -> Self {
+        Self {
+            value: 0,
+            human_readable,
+            kind: MetricKind::Physical,
+            prefix_kind,
+        }
+    }
+
+    /// Initializes a [Metric] that stores the total amount of bytes used to store a file on disk.
+    pub fn init_physical(
+        path: &Path,
+        metadata: &Metadata,
+        prefix_kind: PrefixKind,
+        human_readable: bool,
+    ) -> Self {
+        let value = path.size_on_disk_fast(metadata).unwrap_or(metadata.len());
+        let kind = MetricKind::Physical;
+
+        Self {
+            value,
+            human_readable,
+            kind,
+            prefix_kind,
+        }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let value = self.value as f64;
+
+        match self.prefix_kind {
+            PrefixKind::Si => {
+                if !self.human_readable {
+                    return write!(f, "{} {}", self.value, SiPrefix::Base);
+                }
+
+                let unit = SiPrefix::from(self.value);
+
+                if matches!(unit, SiPrefix::Base) {
+                    write!(f, "{} {unit}", self.value)
+                } else {
+                    let base_value = unit.base_value();
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+            PrefixKind::Bin => {
+                if !self.human_readable {
+                    return write!(f, "{} {}", self.value, BinPrefix::Base);
+                }
+
+                let unit = BinPrefix::from(self.value);
+
+                if matches!(unit, BinPrefix::Base) {
+                    write!(f, "{} {unit}", self.value)
+                } else {
+                    let base_value = unit.base_value();
+                    let size = value / (base_value as f64);
+                    write!(f, "{size:.2} {unit}")
+                }
+            }
+        }
+    }
+}
+
+#[test]
+fn test_metric() {
+    let metric = Metric {
+        value: 100,
+        kind: MetricKind::Logical,
+        human_readable: false,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "100 B");
+
+    let metric = Metric {
+        value: 1000,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Si,
+    };
+    assert_eq!(format!("{}", metric), "1.00 KB");
+
+    let metric = Metric {
+        value: 1000,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1000 B");
+
+    let metric = Metric {
+        value: 1024,
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1.00 KiB");
+
+    let metric = Metric {
+        value: 2_u64.pow(20),
+        kind: MetricKind::Logical,
+        human_readable: true,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "1.00 MiB");
+
+    let metric = Metric {
+        value: 123454,
+        kind: MetricKind::Logical,
+        human_readable: false,
+        prefix_kind: PrefixKind::Bin,
+    };
+    assert_eq!(format!("{}", metric), "123454 B");
+}
diff --git a/src/disk_usage/file_size/line_count.rs b/src/disk_usage/file_size/line_count.rs
new file mode 100644
index 00000000..1c145315
--- /dev/null
+++ b/src/disk_usage/file_size/line_count.rs
@@ -0,0 +1,45 @@
+use std::{
+    convert::{AsRef, From},
+    fmt::{self, Display},
+    fs,
+    path::Path,
+};
+
+/// Concerned with measuring file size using line count as a metric.
+#[derive(Default)]
+pub struct Metric {
+    pub value: u64,
+}
+
+impl Metric {
+    /// Reads in contents of a file given by `path` and attempts to compute the total number of
+    /// lines in that file. If a file is not UTF-8 encoded as in the case of a binary jpeg file
+    /// then `None` will be returned.
+    pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
+        let data = fs::read_to_string(path.as_ref()).ok()?;
+
+        let lines = data.lines().count();
+
+        u64::try_from(lines).map(|value| Self { value }).ok()
+    }
+}
+
+impl From<u64> for Metric {
+    fn from(value: u64) -> Self {
+        Self { value }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
+}
+
+#[test]
+fn test_line_count() {
+    let metric =
+        Metric::init("tests/data/nemesis.txt").expect("Expected 'tests/data/nemesis.txt' to exist");
+
+    assert_eq!(metric.value, 4);
+}
diff --git a/src/disk_usage/file_size/mod.rs b/src/disk_usage/file_size/mod.rs
new file mode 100644
index 00000000..fd210412
--- /dev/null
+++ b/src/disk_usage/file_size/mod.rs
@@ -0,0 +1,89 @@
+use crate::context::Context;
+use clap::ValueEnum;
+use std::{convert::From, ops::AddAssign};
+
+/// Concerned with measuring file size in blocks.
+#[cfg(unix)]
+pub mod block;
+
+/// Concerned with measuring file size in bytes, logical or physical.
+pub mod byte;
+
+/// Concerned with measuring file size by line count.
+pub mod line_count;
+
+/// Concerned with measuring file size by word count.
+pub mod word_count;
+
+/// Represents all the different ways in which a filesize could be reported using various metrics.
+pub enum FileSize {
+    Word(word_count::Metric),
+    Line(line_count::Metric),
+    Byte(byte::Metric),
+    Block(block::Metric),
+}
+
+/// Determines between logical or physical size for display
+#[derive(Copy, Clone, Debug, ValueEnum, Default)]
+pub enum DiskUsage {
+    /// How many bytes does a file contain
+    Logical,
+
+    /// How much actual space on disk in bytes, taking into account sparse files and compression.
+    #[default]
+    Physical,
+
+    /// How many total lines a file contains
+    Line,
+
+    /// How many total words a file contains
+    Word,
+
+    /// How many blocks are allocated to store the file
+    #[cfg(unix)]
+    Block,
+}
+
+impl FileSize {
+    /// Extracts the inner value of [`FileSize`] which represents the file size for various metrics.
+    #[inline]
+    pub const fn value(&self) -> u64 {
+        match self {
+            Self::Byte(metric) => metric.value,
+            Self::Line(metric) => metric.value,
+            Self::Word(metric) => metric.value,
+
+            #[cfg(unix)]
+            Self::Block(metric) => metric.value,
+        }
+    }
+}
+
+impl AddAssign<&Self> for FileSize {
+    fn add_assign(&mut self, rhs: &Self) {
+        match self {
+            Self::Byte(metric) => metric.value += rhs.value(),
+            Self::Line(metric) => metric.value += rhs.value(),
+            Self::Word(metric) => metric.value += rhs.value(),
+
+            #[cfg(unix)]
+            Self::Block(metric) => metric.value += rhs.value(),
+        }
+    }
+}
+
+impl From<&Context> for FileSize {
+    fn from(ctx: &Context) -> Self {
+        use DiskUsage::{Line, Logical, Physical, Word};
+
+        match ctx.disk_usage {
+            Logical => Self::Byte(byte::Metric::init_empty_logical(ctx.human, ctx.unit)),
+            Physical => Self::Byte(byte::Metric::init_empty_physical(ctx.human, ctx.unit)),
+            Line => Self::Line(line_count::Metric::default()),
+            Word => Self::Word(word_count::Metric::default()),
+
+            #[cfg(unix)]
+            DiskUsage::Block => Self::Block(block::Metric::default()),
+        }
+    }
+}
diff --git a/src/disk_usage/file_size/word_count.rs b/src/disk_usage/file_size/word_count.rs
new file mode 100644
index 00000000..92ebf8d1
--- /dev/null
+++ b/src/disk_usage/file_size/word_count.rs
@@ -0,0 +1,47 @@
+use std::{
+    convert::{AsRef, From},
+    fmt::{self, Display},
+    fs,
+    path::Path,
+};
+
+/// Concerned with measuring file size using word count as a metric.
+#[derive(Default)]
+pub struct Metric {
+    pub value: u64,
+}
+
+impl Metric {
+    /// Reads in contents of a file given by `path` and attempts to compute the total number of
+    /// words in that file. If a file is not UTF-8 encoded as in the case of a binary jpeg file
+    /// then `None` will be returned.
+    ///
+    /// Words are UTF-8 encoded byte sequences delimited by Unicode Derived Core Property `White_Space`.
+    pub fn init<P: AsRef<Path>>(path: P) -> Option<Self> {
+        let data = fs::read_to_string(path.as_ref()).ok()?;
+
+        let words = data.split_whitespace().count();
+
+        u64::try_from(words).map(|value| Self { value }).ok()
+    }
+}
+
+impl From<u64> for Metric {
+    fn from(value: u64) -> Self {
+        Self { value }
+    }
+}
+
+impl Display for Metric {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        <u64 as Display>::fmt(&self.value, f)
+    }
+}
+
+#[test]
+fn test_line_count() {
+    let metric =
+        Metric::init("tests/data/nemesis.txt").expect("Expected 'tests/data/nemesis.txt' to exist");
+
+    assert_eq!(metric.value, 27);
+}
diff --git a/src/disk_usage/mod.rs b/src/disk_usage/mod.rs
index 5c325e2e..c855943f 100644
--- a/src/disk_usage/mod.rs
+++ b/src/disk_usage/mod.rs
@@ -1,5 +1,6 @@
 /// Binary and SI prefixes
 pub mod units;
 
-/// Rules to display disk usage for individual files
+/// Concerned with all of the different ways to measure file size: bytes, word-count, line-count,
+/// blocks (unix), etc..
 pub mod file_size;
diff --git a/src/disk_usage/units.rs b/src/disk_usage/units.rs
index bf605c29..92e1da3f 100644
--- a/src/disk_usage/units.rs
+++ b/src/disk_usage/units.rs
@@ -64,9 +64,9 @@ impl UnitPrefix for BinPrefix {
 }
 
 /// Get the closest human-readable unit prefix for value.
-impl From<f64> for BinPrefix {
-    fn from(value: f64) -> Self {
-        let log = value.log2();
+impl From<u64> for BinPrefix {
+    fn from(value: u64) -> Self {
+        let log = (value as f64).log2();
 
         if log < 10. {
             Self::Base
@@ -83,9 +83,9 @@ impl From<f64> for BinPrefix {
 }
 
 /// Get the closest human-readable unit prefix for value.
-impl From<f64> for SiPrefix {
-    fn from(value: f64) -> Self {
-        let log = value.log10();
+impl From<u64> for SiPrefix {
+    fn from(value: u64) -> Self {
+        let log = (value as f64).log10();
 
         if log < 3. {
             Self::Base
diff --git a/src/icons/fs.rs b/src/icons/fs.rs
new file mode 100644
index 00000000..b19f08f8
--- /dev/null
+++ b/src/icons/fs.rs
@@ -0,0 +1,95 @@
+use ansi_term::{ANSIGenericString, Style};
+use ignore::DirEntry;
+use std::{borrow::Cow, path::Path};
+
+/// Computes a plain, colorless icon with given parameters.
+///
+/// The precedent from highest to lowest in terms of which parameters determine the icon used
+/// is as followed: file-type, file-extension, and then file-name. If an icon cannot be
+/// computed the fall-back default icon is used.
+///
+/// If a directory entry is a link and the link target is provided, the link target will be
+/// used to determine the icon.
+pub fn compute(entry: &DirEntry, link_target: Option<&Path>) -> Cow<'static, str> {
+    let icon = entry
+        .file_type()
+        .and_then(super::icon_from_file_type)
+        .map(Cow::from);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let ext = match link_target {
+        Some(target) if entry.path_is_symlink() => target.extension(),
+        _ => entry.path().extension(),
+    };
+
+    let icon = ext
+        .and_then(super::icon_from_ext)
+        .map(|(_, i)| Cow::from(i));
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let icon = super::icon_from_file_name(entry.file_name()).map(Cow::from);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    Cow::from(super::get_default_icon().1)
+}
+
+/// Computes a plain, colored icon with given parameters. See [compute] for more details.
+pub fn compute_with_color(
+    entry: &DirEntry,
+    link_target: Option<&Path>,
+    style: Option<Style>,
+) -> Cow<'static, str> {
+    let icon = entry
+        .file_type()
+        .and_then(super::icon_from_file_type)
+        .map(Cow::from);
+
+    let paint_icon = |icon| match style {
+        Some(Style {
+            foreground: Some(fg),
+            ..
+        }) => {
+            let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
+            let styled_icon = ansi_string.to_string();
+            Cow::from(styled_icon)
+        }
+        _ => icon,
+    };
+
+    if let Some(icon) = icon {
+        return paint_icon(icon);
+    }
+
+    let ext = match link_target {
+        Some(target) if entry.path_is_symlink() => target.extension(),
+        _ => entry.path().extension(),
+    };
+
+    let icon = ext
+        .and_then(super::icon_from_ext)
+        .map(|attrs| Cow::from(super::col(attrs.0, attrs.1)));
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let icon = super::icon_from_file_name(entry.file_name())
+        .map(Cow::from)
+        .map(paint_icon);
+
+    if let Some(i) = icon {
+        return i;
+    }
+
+    let (code, icon) = super::get_default_icon();
+    Cow::from(super::col(code, icon))
+}
diff --git a/src/icons.rs b/src/icons/mod.rs
similarity index 88%
rename from src/icons.rs
rename to src/icons/mod.rs
index f8648f3a..dbcb3018 100644
--- a/src/icons.rs
+++ b/src/icons/mod.rs
@@ -1,105 +1,14 @@
 use crate::hash;
-use ansi_term::Style;
-use ansi_term::{ANSIGenericString, Color};
-use ignore::DirEntry;
+use ansi_term::Color;
 use once_cell::sync::Lazy;
 use std::{
-    borrow::Cow,
     collections::HashMap,
     ffi::{OsStr, OsString},
     fs::FileType,
-    path::Path,
 };
 
-/// Computes a plain, colorless icon with given parameters.
-///
-/// The precedent from highest to lowest in terms of which parameters determine the icon used
-/// is as followed: file-type, file-extension, and then file-name. If an icon cannot be
-/// computed the fall-back default icon is used.
-///
-/// If a directory entry is a link and the link target is provided, the link target will be
-/// used to determine the icon.
-pub fn compute(entry: &DirEntry, link_target: Option<&Path>) -> Cow<'static, str> {
-    let icon = entry
-        .file_type()
-        .and_then(icon_from_file_type)
-        .map(Cow::from);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let ext = match link_target {
-        Some(target) if entry.path_is_symlink() => target.extension(),
-        _ => entry.path().extension(),
-    };
-
-    let icon = ext.and_then(icon_from_ext).map(|(_, i)| Cow::from(i));
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let icon = icon_from_file_name(entry.file_name()).map(Cow::from);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    Cow::from(get_default_icon().1)
-}
-
-/// Computes a plain, colored icon with given parameters. See [compute] for more details.
-pub fn compute_with_color(
-    entry: &DirEntry,
-    link_target: Option<&Path>,
-    style: Option<Style>,
-) -> Cow<'static, str> {
-    let icon = entry
-        .file_type()
-        .and_then(icon_from_file_type)
-        .map(Cow::from);
-
-    let paint_icon = |icon| match style {
-        Some(Style {
-            foreground: Some(fg),
-            ..
-        }) => {
-            let ansi_string: ANSIGenericString<str> = fg.bold().paint(icon);
-            let styled_icon = ansi_string.to_string();
-            Cow::from(styled_icon)
-        }
-        _ => icon,
-    };
-
-    if let Some(icon) = icon {
-        return paint_icon(icon);
-    }
-
-    let ext = match link_target {
-        Some(target) if entry.path_is_symlink() => target.extension(),
-        _ => entry.path().extension(),
-    };
-
-    let icon = ext
-        .and_then(icon_from_ext)
-        .map(|attrs| Cow::from(col(attrs.0, attrs.1)));
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let icon = icon_from_file_name(entry.file_name())
-        .map(Cow::from)
-        .map(paint_icon);
-
-    if let Some(i) = icon {
-        return i;
-    }
-
-    let (code, icon) = get_default_icon();
-    Cow::from(col(code, icon))
-}
+/// Concerned with computing icons given filesystem parameters.
+pub mod fs;
 
 /// Attempts to return an icon given a file extension along with its default color code 8-bit
 /// value.
diff --git a/src/render/grid/cell.rs b/src/render/grid/cell.rs
index 5c931871..917dd0ef 100644
--- a/src/render/grid/cell.rs
+++ b/src/render/grid/cell.rs
@@ -1,12 +1,16 @@
 use crate::{
-    context::{time, Context},
-    disk_usage::file_size::FileSize,
+    context::Context,
+    disk_usage::{
+        file_size::{byte, DiskUsage, FileSize},
+        units::PrefixKind,
+    },
     render::theme,
     styles::{self, PLACEHOLDER},
     tree::node::Node,
 };
 use chrono::{DateTime, Local};
 use std::{
+    borrow::Cow,
     ffi::OsStr,
     fmt::{self, Display},
     path::Path,
@@ -102,12 +106,18 @@ impl<'a> Cell<'a> {
         let node = self.node;
         let ctx = self.ctx;
 
-        let formatted_size = node.file_size().map_or_else(
-            || FileSize::placeholder(ctx),
-            |size| size.format(ctx.max_size_width, ctx.max_size_unit_width),
-        );
+        let Some(file_size) = node.file_size() else {
+            return Self::fmt_size_placeholder(f, ctx)
+        };
+
+        match file_size {
+            FileSize::Byte(metric) => Self::fmt_bytes(f, metric, ctx),
+            FileSize::Line(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
+            FileSize::Word(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
 
-        write!(f, "{formatted_size}")
+            #[cfg(unix)]
+            FileSize::Block(metric) => Self::fmt_unitless_disk_usage(f, metric, ctx),
+        }
     }
 
     /// Rules on how to format block for rendering
@@ -236,6 +246,66 @@ impl<'a> Cell<'a> {
 
         write!(f, "{formatted_perms}")
     }
+
+    #[inline]
+    fn fmt_size_placeholder(f: &mut fmt::Formatter<'_>, ctx: &Context) -> fmt::Result {
+        if ctx.suppress_size || ctx.max_size_width == 0 {
+            return write!(f, "");
+        }
+
+        let placeholder = styles::get_placeholder_style().map_or_else(
+            |_| Cow::from(styles::PLACEHOLDER),
+            |style| Cow::from(style.paint(styles::PLACEHOLDER).to_string()),
+        );
+
+        let mut placeholder_padding = placeholder.len() + ctx.max_size_width - 1;
+
+        placeholder_padding += 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,
+        };
+
+        write!(f, "{placeholder:>placeholder_padding$}")
+    }
+
+    #[inline]
+    fn fmt_bytes(f: &mut fmt::Formatter<'_>, metric: &byte::Metric, ctx: &Context) -> fmt::Result {
+        let max_size_width = ctx.max_size_width;
+        let max_unit_width = ctx.max_size_unit_width;
+        let out = format!("{metric}");
+        let [size, unit]: [&str; 2] = out.split(' ').collect::<Vec<&str>>().try_into().unwrap();
+
+        if ctx.no_color() {
+            return write!(f, "{size:>max_size_width$} {unit:>max_unit_width$}");
+        }
+
+        let color = styles::get_du_theme().unwrap().get(unit).unwrap();
+
+        let out = color.paint(format!("{size:>max_size_width$} {unit:>max_unit_width$}"));
+
+        write!(f, "{out}")
+    }
+
+    #[inline]
+    fn fmt_unitless_disk_usage<M: Display>(
+        f: &mut fmt::Formatter<'_>,
+        metric: &M,
+        ctx: &Context,
+    ) -> fmt::Result {
+        let max_size_width = ctx.max_size_width;
+
+        if ctx.no_color() {
+            return write!(f, "{metric:>max_size_width$}");
+        }
+        let color = styles::get_du_theme().unwrap().get("B").unwrap();
+
+        write!(f, "{}", color.paint(format!("{metric:>max_size_width$}")))
+    }
 }
 
 impl Display for Cell<'_> {
diff --git a/src/render/theme.rs b/src/render/theme.rs
index ee305ac2..8b3e0410 100644
--- a/src/render/theme.rs
+++ b/src/render/theme.rs
@@ -1,5 +1,4 @@
 use crate::{
-    fs::permissions::FileModeXAttrs,
     styles::{self, ThemesMap},
     tree::node::Node,
 };
@@ -56,8 +55,8 @@ pub fn stylize_file_name(node: &Node) -> Cow<'_, str> {
         return name.to_string_lossy();
     };
 
-    if style.is_some() {
-        let styled_name = stylize_file_name(node);
+    if let Some(color) = style {
+        let styled_name = color.paint(name.to_string_lossy());
         let target_name = Color::Red.paint(format!("\u{2192} {}", target_name.to_string_lossy()));
 
         return Cow::from(format!("{styled_name} {target_name}"));
@@ -71,6 +70,8 @@ pub fn stylize_file_name(node: &Node) -> Cow<'_, str> {
 /// Styles the symbolic notation of file permissions.
 #[cfg(unix)]
 pub fn style_sym_permissions(node: &Node) -> String {
+    use crate::fs::permissions::FileModeXAttrs;
+
     let perms = node.mode().expect("Expected permissions to be initialized");
 
     let symb = if node.has_xattrs() {
diff --git a/src/tree/mod.rs b/src/tree/mod.rs
index e5d4939c..1792892f 100644
--- a/src/tree/mod.rs
+++ b/src/tree/mod.rs
@@ -1,6 +1,9 @@
 use crate::{
     context::{file, output::ColumnProperties, Context},
-    disk_usage::file_size::FileSize,
+    disk_usage::{
+        file_size::{DiskUsage, FileSize},
+        units::{BinPrefix, PrefixKind, SiPrefix},
+    },
     fs::inode::Inode,
     utils,
 };
@@ -186,7 +189,7 @@ impl Tree {
 
         let mut children = branches.remove(current_node.path()).unwrap();
 
-        let mut dir_size = FileSize::new(0, ctx.disk_usage, ctx.human, ctx.unit);
+        let mut dir_size = FileSize::from(ctx);
 
         for child_id in &children {
             let index = *child_id;
@@ -211,10 +214,10 @@ impl Tree {
             let node = tree[index].get();
 
             #[cfg(unix)]
-            Self::update_column_properties(column_properties, node, ctx.long);
+            Self::update_column_properties(column_properties, node, ctx);
 
             #[cfg(not(unix))]
-            Self::update_column_properties(column_properties, node);
+            Self::update_column_properties(column_properties, node, ctx);
 
             // If a hard-link is already accounted for then don't increment parent dir size.
             if let Some(inode) = node.inode() {
@@ -228,21 +231,19 @@ impl Tree {
             }
         }
 
-        if dir_size.bytes > 0 {
+        if dir_size.value() > 0 {
             let dir = tree[current_node_id].get_mut();
 
-            dir_size.precompute_unpadded_display();
-
             dir.set_file_size(dir_size);
         }
 
         let dir = tree[current_node_id].get();
 
         #[cfg(unix)]
-        Self::update_column_properties(column_properties, dir, ctx.long);
+        Self::update_column_properties(column_properties, dir, ctx);
 
         #[cfg(not(unix))]
-        Self::update_column_properties(column_properties, dir);
+        Self::update_column_properties(column_properties, dir, ctx);
 
         children.sort_by(|id_a, id_b| {
             let node_a = tree[*id_a].get();
@@ -306,16 +307,37 @@ impl Tree {
 
     /// Updates [`ColumnProperties`] with provided [Node].
     #[cfg(unix)]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, long: bool) {
+    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = file_size.size_columns;
+            let file_size_cols = utils::num_integral(file_size.value());
 
             if file_size_cols > col_props.max_size_width {
                 col_props.max_size_width = file_size_cols;
             }
+
+            match ctx.disk_usage {
+                DiskUsage::Logical | DiskUsage::Physical => {
+                    let unit_len = match ctx.unit {
+                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                            BinPrefix::Base => 1,
+                            _ => 3,
+                        },
+                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                            SiPrefix::Base => 1,
+                            _ => 2,
+                        },
+                        _ => 1,
+                    };
+
+                    if unit_len > col_props.max_size_unit_width {
+                        col_props.max_size_unit_width = unit_len;
+                    }
+                }
+                DiskUsage::Line | DiskUsage::Word | DiskUsage::Block => (),
+            }
         }
 
-        if long {
+        if ctx.long {
             if let Some(ino) = node.ino() {
                 let ino_num_integral = utils::num_integral(ino);
 
@@ -344,13 +366,34 @@ impl Tree {
 
     /// Updates [ColumnProperties] with provided [Node].
     #[cfg(not(unix))]
-    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node) {
+    fn update_column_properties(col_props: &mut ColumnProperties, node: &Node, ctx: &Context) {
         if let Some(file_size) = node.file_size() {
-            let file_size_cols = file_size.size_columns;
+            let file_size_cols = utils::num_integral(file_size.value());
 
             if file_size_cols > col_props.max_size_width {
                 col_props.max_size_width = file_size_cols;
             }
+
+            match ctx.disk_usage {
+                DiskUsage::Logical | DiskUsage::Physical => {
+                    let unit_len = match ctx.unit {
+                        PrefixKind::Bin if ctx.human => match BinPrefix::from(file_size.value()) {
+                            BinPrefix::Base => 1,
+                            _ => 3,
+                        },
+                        PrefixKind::Si if ctx.human => match SiPrefix::from(file_size.value()) {
+                            SiPrefix::Base => 1,
+                            _ => 2,
+                        },
+                        _ => 1,
+                    };
+
+                    if unit_len > col_props.max_size_unit_width {
+                        col_props.max_size_unit_width = unit_len;
+                    }
+                }
+                _ => (),
+            }
         }
     }
 }
diff --git a/src/tree/node/cmp.rs b/src/tree/node/cmp.rs
index d9e371dd..c135b9a8 100644
--- a/src/tree/node/cmp.rs
+++ b/src/tree/node/cmp.rs
@@ -127,13 +127,14 @@ fn base_comparator(sort_type: sort::Type) -> Box<NodeComparator> {
 //}
 
 mod sizing {
+    use crate::disk_usage::file_size::FileSize;
     use crate::tree::node::Node;
     use core::cmp::Ordering;
 
     /// Comparator that sorts [Node]s by size, largest to smallest.
     pub fn comparator(a: &Node, b: &Node) -> Ordering {
-        let a_size = a.file_size().map_or(0, |fs| fs.bytes);
-        let b_size = b.file_size().map_or(0, |fs| fs.bytes);
+        let a_size = a.file_size().map_or(0, FileSize::value);
+        let b_size = b.file_size().map_or(0, FileSize::value);
         b_size.cmp(&a_size)
     }
     /// Comparator that sorts [Node]s by size, smallest to largest.
diff --git a/src/tree/node/mod.rs b/src/tree/node/mod.rs
index 63561e49..4281821d 100644
--- a/src/tree/node/mod.rs
+++ b/src/tree/node/mod.rs
@@ -1,6 +1,6 @@
 use crate::{
     context::Context,
-    disk_usage::file_size::{DiskUsage, FileSize},
+    disk_usage::file_size::{byte, line_count, word_count, DiskUsage, FileSize},
     fs::inode::Inode,
     icons,
     styles::get_ls_colors,
@@ -19,9 +19,12 @@ use std::{
 };
 
 #[cfg(unix)]
-use crate::fs::{
-    permissions::{FileMode, SymbolicNotation},
-    xattr::ExtendedAttr,
+use crate::{
+    disk_usage::file_size::block,
+    fs::{
+        permissions::{FileMode, SymbolicNotation},
+        xattr::ExtendedAttr,
+    },
 };
 
 /// Ordering and sorting rules for [Node].
@@ -201,12 +204,12 @@ impl Node {
         self.style
     }
 
-    /// See [`icons::compute`].
+    /// See [`crate::icons::fs::compute`].
     pub fn compute_icon(&self, no_color: bool) -> Cow<'static, str> {
         if no_color {
-            icons::compute(self.dir_entry(), self.symlink_target_path())
+            icons::fs::compute(self.dir_entry(), self.symlink_target_path())
         } else {
-            icons::compute_with_color(self.dir_entry(), self.symlink_target_path(), self.style)
+            icons::fs::compute_with_color(self.dir_entry(), self.symlink_target_path(), self.style)
         }
     }
 }
@@ -232,15 +235,32 @@ impl TryFrom<(DirEntry, &Context)> for Node {
 
         let file_type = dir_entry.file_type();
 
-        let mut file_size = match file_type {
+        let file_size = match file_type {
             Some(ref ft) if !ctx.suppress_size => {
                 if ft.is_file() || (ft.is_symlink() && !ctx.follow) {
                     match ctx.disk_usage {
                         DiskUsage::Logical => {
-                            Some(FileSize::logical(&metadata, ctx.unit, ctx.human))
+                            let metric = byte::Metric::init_logical(&metadata, ctx.unit, ctx.human);
+                            Some(FileSize::Byte(metric))
                         }
                         DiskUsage::Physical => {
-                            FileSize::physical(path, &metadata, ctx.unit, ctx.human)
+                            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))
                         }
                     }
                 } else {
@@ -250,10 +270,6 @@ impl TryFrom<(DirEntry, &Context)> for Node {
             _ => None,
         };
 
-        if let Some(ref mut fs) = file_size {
-            fs.precompute_unpadded_display();
-        }
-
         let inode = Inode::try_from(&metadata).ok();
 
         #[cfg(unix)]
diff --git a/tests/dirs_only.rs b/tests/dirs_only.rs
index c1804e2c..b7dea5f3 100644
--- a/tests/dirs_only.rs
+++ b/tests/dirs_only.rs
@@ -7,12 +7,12 @@ fn dirs_only() {
     assert_eq!(
         utils::run_cmd(&["--dirs-only", "--sort", "name", "tests/data"]),
         indoc!(
-            "143  B ┌─ the_yellow_king
-    446  B ├─ lipsum
-    308  B ├─ dream_cycle
-    1241 B data
+            "143 B ┌─ the_yellow_king
+ 446 B ├─ lipsum
+ 308 B ├─ dream_cycle
+1241 B data
 
-    3 directories"
+3 directories"
         )
     )
 }
diff --git a/tests/flat.rs b/tests/flat.rs
index 2b96b3da..23dcd485 100644
--- a/tests/flat.rs
+++ b/tests/flat.rs
@@ -7,18 +7,18 @@ fn flat() {
     assert_eq!(
         utils::run_cmd(&["--layout", "flat", "tests/data"]),
         indoc!(
-            "143  B   the_yellow_king/cassildas_song.md
-            143  B   the_yellow_king
-            100  B   nylarlathotep.txt
-            161  B   nemesis.txt
-            83   B   necronomicon.txt
-            446  B   lipsum/lipsum.txt
-            446  B   lipsum
-            308  B   dream_cycle/polaris.txt
-            308  B   dream_cycle
-            1241 B   data
+            "143 B   the_yellow_king/cassildas_song.md
+ 143 B   the_yellow_king
+ 100 B   nylarlathotep.txt
+ 161 B   nemesis.txt
+  83 B   necronomicon.txt
+ 446 B   lipsum/lipsum.txt
+ 446 B   lipsum
+ 308 B   dream_cycle/polaris.txt
+ 308 B   dream_cycle
+1241 B   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
@@ -29,17 +29,17 @@ fn flat_human() {
         utils::run_cmd(&["--layout", "flat", "--human", "tests/data"]),
         indoc!(
             "143   B   the_yellow_king/cassildas_song.md
-             143   B   the_yellow_king
-             100   B   nylarlathotep.txt
-             161   B   nemesis.txt
-              83   B   necronomicon.txt
-             446   B   lipsum/lipsum.txt
-             446   B   lipsum
-             308   B   dream_cycle/polaris.txt
-             308   B   dream_cycle
-            1.21 KiB   data
+ 143   B   the_yellow_king
+ 100   B   nylarlathotep.txt
+ 161   B   nemesis.txt
+  83   B   necronomicon.txt
+ 446   B   lipsum/lipsum.txt
+ 446   B   lipsum
+ 308   B   dream_cycle/polaris.txt
+ 308   B   dream_cycle
+1.21 KiB   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
@@ -49,15 +49,15 @@ fn flat_with_level() {
     assert_eq!(
         utils::run_cmd(&["--layout", "flat", "--level", "1", "tests/data"]),
         indoc!(
-            "143  B   the_yellow_king
-            100  B   nylarlathotep.txt
-            161  B   nemesis.txt
-            83   B   necronomicon.txt
-            446  B   lipsum
-            308  B   dream_cycle
-            1241 B   data
+            "143 B   the_yellow_king
+ 100 B   nylarlathotep.txt
+ 161 B   nemesis.txt
+  83 B   necronomicon.txt
+ 446 B   lipsum
+ 308 B   dream_cycle
+1241 B   data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     )
 }
diff --git a/tests/glob.rs b/tests/glob.rs
index ff370aa3..c5efd687 100644
--- a/tests/glob.rs
+++ b/tests/glob.rs
@@ -7,16 +7,16 @@ fn glob() {
     assert_eq!(
         utils::run_cmd(&["--glob", "--pattern", "*.txt", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 }
@@ -27,10 +27,10 @@ fn glob_negative() {
         utils::run_cmd(&["--glob", "--pattern", "!*.txt", "tests/data"]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            143 B data
-
-            1 directory, 1 file"
+ 143 B ┌─ the_yellow_king
+ 143 B data
+ 
+ 1 directory, 1 file"
         )
     )
 }
@@ -40,16 +40,16 @@ fn glob_case_insensitive() {
     assert_eq!(
         utils::run_cmd(&["--iglob", "--pattern", "*.TXT", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     )
 }
@@ -67,10 +67,10 @@ fn glob_with_filetype() {
         ]),
         indoc!(
             "308 B    ┌─ polaris.txt
-            308 B ┌─ dream_cycle
-            308 B data
-
-            1 directory, 1 file"
+ 308 B ┌─ dream_cycle
+ 308 B data
+ 
+ 1 directory, 1 file"
         )
     )
 }
@@ -88,15 +88,15 @@ fn negated_glob_with_filetype() {
         ]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            100 B ├─ nylarlathotep.txt
-            161 B ├─ nemesis.txt
-            83  B ├─ necronomicon.txt
-            446 B │  ┌─ lipsum.txt
-            446 B ├─ lipsum
-            933 B data
-
-            2 directories, 5 files"
+ 143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 933 B data
+ 
+ 2 directories, 5 files"
         )
     )
 }
diff --git a/tests/hardlink.rs b/tests/hardlink.rs
index a4b5b9c0..c1e9e8a2 100644
--- a/tests/hardlink.rs
+++ b/tests/hardlink.rs
@@ -27,10 +27,10 @@ fn hardlink() -> Result<(), Box<dyn Error>> {
         out,
         indoc!(
             "157 B ┌─ kadath.txt
-            157 B ├─ curwin.hpl
-            157 B hardlinks
+ 157 B ├─ curwin.hpl
+ 157 B hardlinks
 
-            2 files"
+ 2 files"
         )
     );
 
diff --git a/tests/level.rs b/tests/level.rs
index f3d9cfd5..6d45cec8 100644
--- a/tests/level.rs
+++ b/tests/level.rs
@@ -7,15 +7,15 @@ fn level() {
     assert_eq!(
         utils::run_cmd(&["--level", "1", "tests/data"]),
         indoc!(
-            "143  B ┌─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B ├─ lipsum
-            308  B ├─ dream_cycle
-            1241 B data
+            "143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B ├─ lipsum
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to print at max level of 1."
     )
diff --git a/tests/line_count.rs b/tests/line_count.rs
new file mode 100644
index 00000000..dcd19472
--- /dev/null
+++ b/tests/line_count.rs
@@ -0,0 +1,24 @@
+use indoc::indoc;
+
+mod utils;
+
+#[test]
+fn line_count() {
+    assert_eq!(
+        utils::run_cmd(&["--disk-usage", "line", "tests/data"]),
+        indoc!(
+            "6    ┌─ cassildas_song.md
+ 6 ┌─ the_yellow_king
+ 1 ├─ nylarlathotep.txt
+ 4 ├─ nemesis.txt
+ 2 ├─ necronomicon.txt
+ 1 │  ┌─ lipsum.txt
+ 1 ├─ lipsum
+10 │  ┌─ polaris.txt
+10 ├─ dream_cycle
+24 data
+
+3 directories, 6 files"
+        )
+    )
+}
diff --git a/tests/prune.rs b/tests/prune.rs
index 139d87df..5a1e1148 100644
--- a/tests/prune.rs
+++ b/tests/prune.rs
@@ -7,16 +7,16 @@ fn prune() {
     assert_eq!(
         utils::run_cmd(&["--glob", "--pattern", "*.txt", "--prune", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 }
diff --git a/tests/regex.rs b/tests/regex.rs
index 64a7ef3b..af40979e 100644
--- a/tests/regex.rs
+++ b/tests/regex.rs
@@ -7,16 +7,16 @@ fn regex() {
     assert_eq!(
         utils::run_cmd(&["--pattern", r"\.txt$", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1098 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1098 B data
 
-            2 directories, 5 files"
+2 directories, 5 files"
         )
     );
 
@@ -24,10 +24,10 @@ fn regex() {
         utils::run_cmd(&["--pattern", r"^cassildas.", "--prune", "tests/data"]),
         indoc!(
             "143 B    ┌─ cassildas_song.md
-            143 B ┌─ the_yellow_king
-            143 B data
-
-            1 directory, 1 file"
+ 143 B ┌─ the_yellow_king
+ 143 B data
+ 
+ 1 directory, 1 file"
         )
     );
 }
@@ -38,10 +38,10 @@ fn regex_file_type() {
         utils::run_cmd(&["--pattern", r"^dream.", "--file-type", "dir", "tests/data"]),
         indoc!(
             "308 B    ┌─ polaris.txt
-            308 B ┌─ dream_cycle
-            308 B data
-
-            1 directory, 1 file"
+ 308 B ┌─ dream_cycle
+ 308 B data
+ 
+ 1 directory, 1 file"
         )
     );
 }
diff --git a/tests/sort.rs b/tests/sort.rs
index 9942447e..4d38ef57 100644
--- a/tests/sort.rs
+++ b/tests/sort.rs
@@ -7,18 +7,18 @@ fn sort_name() {
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "tests/data"]),
         indoc!(
-            "143  B    ┌─ cassildas_song.md
-            143  B ┌─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1241 B data
+            "143 B    ┌─ cassildas_song.md
+ 143 B ┌─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to sort alphabetically by file name"
     )
@@ -29,36 +29,36 @@ fn sort_name_dir_order() {
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "--dir-order", "first", "tests/data"]),
         indoc!(
-            "143  B    ┌─ cassildas_song.md
-            143  B ┌─ the_yellow_king
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            100  B ├─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            1241 B data
+            "143 B    ┌─ cassildas_song.md
+ 143 B ┌─ the_yellow_king
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+ 100 B ├─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     );
 
     assert_eq!(
         utils::run_cmd(&["--sort", "name", "--dir-order", "last", "tests/data"]),
         indoc!(
-            "100  B ┌─ nylarlathotep.txt
-            161  B ├─ nemesis.txt
-            83   B ├─ necronomicon.txt
-            143  B │  ┌─ cassildas_song.md
-            143  B ├─ the_yellow_king
-            446  B │  ┌─ lipsum.txt
-            446  B ├─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            1241 B data
+            "100 B ┌─ nylarlathotep.txt
+ 161 B ├─ nemesis.txt
+  83 B ├─ necronomicon.txt
+ 143 B │  ┌─ cassildas_song.md
+ 143 B ├─ the_yellow_king
+ 446 B │  ┌─ lipsum.txt
+ 446 B ├─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         )
     );
 }
@@ -68,18 +68,18 @@ fn sort_size() {
     assert_eq!(
         utils::run_cmd(&["--sort", "size-rev", "tests/data"]),
         indoc!(
-            "446  B    ┌─ lipsum.txt
-            446  B ┌─ lipsum
-            308  B │  ┌─ polaris.txt
-            308  B ├─ dream_cycle
-            161  B ├─ nemesis.txt
-            143  B │  ┌─ cassildas_song.md
-            143  B ├─ the_yellow_king
-            100  B ├─ nylarlathotep.txt
-            83   B ├─ necronomicon.txt
-            1241 B data
+            "446 B    ┌─ lipsum.txt
+ 446 B ┌─ lipsum
+ 308 B │  ┌─ polaris.txt
+ 308 B ├─ dream_cycle
+ 161 B ├─ nemesis.txt
+ 143 B │  ┌─ cassildas_song.md
+ 143 B ├─ the_yellow_king
+ 100 B ├─ nylarlathotep.txt
+  83 B ├─ necronomicon.txt
+1241 B data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to sort by descending size"
     )
diff --git a/tests/suppress_size.rs b/tests/suppress_size.rs
index c771bf7d..00a2a76c 100644
--- a/tests/suppress_size.rs
+++ b/tests/suppress_size.rs
@@ -8,17 +8,17 @@ fn suppress_size() {
         utils::run_cmd(&["--suppress-size", "tests/data"]),
         indoc!(
             "┌─ cassildas_song.md
-             ┌─ the_yellow_king
-             ├─ nylarlathotep.txt
-             ├─ nemesis.txt
-             ├─ necronomicon.txt
-             │  ┌─ lipsum.txt
-             ├─ lipsum
-             │  ┌─ polaris.txt
-             ├─ dream_cycle
-             data
+ ┌─ the_yellow_king
+ ├─ nylarlathotep.txt
+ ├─ nemesis.txt
+ ├─ necronomicon.txt
+ │  ┌─ lipsum.txt
+ ├─ lipsum
+ │  ┌─ polaris.txt
+ ├─ dream_cycle
+ data
 
-            3 directories, 6 files"
+3 directories, 6 files"
         ),
         "Failed to suppress size."
     )