diff --git a/Cargo.lock b/Cargo.lock
index 46d38c0..c4f9b9b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -372,12 +372,6 @@ dependencies = [
 name = "helptext"
 version = "0.1.1"
 
-[[package]]
-name = "hermit-abi"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbf6a919d6cf397374f7dfeeea91d974c7c0a7221d0d0f4f20d859d329e53fcc"
-
 [[package]]
 name = "home"
 version = "0.5.9"
@@ -403,17 +397,6 @@ dependencies = [
  "winapi-util",
 ]
 
-[[package]]
-name = "is-terminal"
-version = "0.4.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "261f68e344040fbd0edea105bef17c66edf46f984ddb1115b775ce31be948f4b"
-dependencies = [
- "hermit-abi",
- "libc",
- "windows-sys 0.52.0",
-]
-
 [[package]]
 name = "is_ci"
 version = "1.2.0"
@@ -516,7 +499,7 @@ checksum = "317f146e2eb7021892722af37cf1b971f0a70c8406f487e24952667616192c64"
 dependencies = [
  "cfg-if",
  "owo-colors",
- "supports-color 3.0.2",
+ "supports-color",
  "supports-hyperlinks",
  "supports-unicode",
  "terminal_size",
@@ -694,9 +677,10 @@ dependencies = [
  "pcre2",
  "pomsky",
  "predicates 2.1.5",
+ "regex",
  "serde",
  "serde_json",
- "supports-color 2.1.0",
+ "supports-color",
 ]
 
 [[package]]
@@ -906,16 +890,6 @@ version = "0.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
 
-[[package]]
-name = "supports-color"
-version = "2.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d6398cde53adc3c4557306a96ce67b302968513830a77a95b2b17305d9719a89"
-dependencies = [
- "is-terminal",
- "is_ci",
-]
-
 [[package]]
 name = "supports-color"
 version = "3.0.2"
diff --git a/helptext/src/color.rs b/helptext/src/color.rs
deleted file mode 100644
index be3438e..0000000
--- a/helptext/src/color.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-/// All supported colors in the formatting machinery
-#[non_exhaustive]
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Color {
-    /// Cyan text; alias: c
-    Cyan,
-    /// Green text; alias: g
-    Green,
-    /// Magenta text; alias: m
-    Magenta,
-    /// Red text; alias: r
-    Red,
-    /// Yellow text; alias: y
-    Yellow,
-    /// Cyan bold text; alias: C
-    CyanBold,
-    /// Green bold text; alias: G
-    GreenBold,
-    /// Magenta bold text; alias: M
-    MagentaBold,
-    /// Red bold text; alias: R
-    RedBold,
-    /// Yellow bold text; alias: Y
-    YellowBold,
-}
-
-#[allow(non_upper_case_globals)]
-impl Color {
-    pub const c: Color = Color::Cyan;
-    pub const g: Color = Color::Green;
-    pub const m: Color = Color::Magenta;
-    pub const r: Color = Color::Red;
-    pub const y: Color = Color::Yellow;
-
-    pub const C: Color = Color::CyanBold;
-    pub const G: Color = Color::GreenBold;
-    pub const M: Color = Color::MagentaBold;
-    pub const R: Color = Color::RedBold;
-    pub const Y: Color = Color::YellowBold;
-
-    pub(crate) const ANSI_RESET: &'static str = "\x1b[0m";
-    pub(crate) const ANSI_C: &'static str = "\x1b[36m";
-    pub(crate) const ANSI_G: &'static str = "\x1b[32m";
-    pub(crate) const ANSI_M: &'static str = "\x1b[35m";
-    pub(crate) const ANSI_R: &'static str = "\x1b[31m";
-    pub(crate) const ANSI_Y: &'static str = "\x1b[33m";
-    pub(crate) const ANSI_CB: &'static str = "\x1b[36;1m";
-    pub(crate) const ANSI_GB: &'static str = "\x1b[32;1m";
-    pub(crate) const ANSI_MB: &'static str = "\x1b[35;1m";
-    pub(crate) const ANSI_RB: &'static str = "\x1b[31;1m";
-    pub(crate) const ANSI_YB: &'static str = "\x1b[33;1m";
-}
-
-impl Color {
-    pub fn ansi_code(self) -> &'static str {
-        match self {
-            Color::Cyan => Self::ANSI_C,
-            Color::Green => Self::ANSI_G,
-            Color::Magenta => Self::ANSI_M,
-            Color::Red => Self::ANSI_R,
-            Color::Yellow => Self::ANSI_Y,
-            Color::CyanBold => Self::ANSI_CB,
-            Color::GreenBold => Self::ANSI_GB,
-            Color::MagentaBold => Self::ANSI_MB,
-            Color::RedBold => Self::ANSI_RB,
-            Color::YellowBold => Self::ANSI_YB,
-        }
-    }
-}
diff --git a/helptext/src/help.rs b/helptext/src/help.rs
index 6ba166f..69aebfc 100644
--- a/helptext/src/help.rs
+++ b/helptext/src/help.rs
@@ -1,6 +1,6 @@
 use std::io::{self, Write};
 
-use crate::Color;
+use crate::Style;
 
 /// A structured help message.
 ///
@@ -9,9 +9,9 @@ use crate::Color;
 pub struct Help<'a>(pub &'a [HelpSection<'a>]);
 
 impl Help<'_> {
-    pub fn write(&self, buf: &mut impl Write, long: bool, colored: bool) -> io::Result<()> {
+    pub fn write(&self, buf: &mut impl Write, long: bool, styled: bool) -> io::Result<()> {
         for section in self.0 {
-            section.write(buf, long, colored, 0, false)?;
+            section.write(buf, long, styled, 0, false)?;
         }
         Ok(())
     }
@@ -35,19 +35,19 @@ impl HelpSection<'_> {
         &self,
         buf: &mut impl Write,
         long: bool,
-        colored: bool,
+        styled: bool,
         indent: usize,
         same_line: bool,
     ) -> io::Result<bool> {
         match *self {
             HelpSection::Short(section) => {
                 if !long {
-                    return section.write(buf, long, colored, indent, same_line);
+                    return section.write(buf, long, styled, indent, same_line);
                 }
             }
             HelpSection::Long(section) => {
                 if long {
-                    return section.write(buf, long, colored, indent, same_line);
+                    return section.write(buf, long, styled, indent, same_line);
                 }
             }
             HelpSection::Text(segments) => {
@@ -57,7 +57,7 @@ impl HelpSection<'_> {
                     )?;
                 }
                 for segment in segments {
-                    segment.write(&mut *buf, colored, indent)?;
+                    segment.write(&mut *buf, styled, indent)?;
                 }
                 buf.write_all(b"\n")?;
                 return Ok(true);
@@ -67,10 +67,10 @@ impl HelpSection<'_> {
                     &b"\n                                                  "[..indent + 1],
                 )?;
 
-                if colored {
-                    buf.write_all(Color::ANSI_Y.as_bytes())?;
+                if styled {
+                    buf.write_all(Style::ANSI_UB.as_bytes())?;
                     buf.write_all(name.as_bytes())?;
-                    buf.write_all(Color::ANSI_RESET.as_bytes())?;
+                    buf.write_all(Style::ANSI_RESET.as_bytes())?;
                 } else {
                     buf.write_all(name.as_bytes())?;
                 }
@@ -84,7 +84,7 @@ impl HelpSection<'_> {
                             &b"                                                  "[..new_indent],
                         )?;
                     }
-                    line_written |= section.write(buf, long, colored, new_indent, false)?;
+                    line_written |= section.write(buf, long, styled, new_indent, false)?;
                 }
                 return Ok(line_written);
             }
@@ -114,10 +114,10 @@ impl HelpSection<'_> {
                         &b"                                                  "[..indent],
                     )?;
 
-                    if colored {
-                        buf.write_all(Color::ANSI_G.as_bytes())?;
+                    if styled {
+                        buf.write_all(Style::ANSI_G.as_bytes())?;
                         buf.write_all(key.as_bytes())?;
-                        buf.write_all(Color::ANSI_RESET.as_bytes())?;
+                        buf.write_all(Style::ANSI_RESET.as_bytes())?;
                     } else {
                         buf.write_all(key.as_bytes())?;
                     }
@@ -136,7 +136,7 @@ impl HelpSection<'_> {
                         line_written |= section.write(
                             buf,
                             long,
-                            colored,
+                            styled,
                             new_indent,
                             is_small && !line_written,
                         )?;
@@ -162,7 +162,7 @@ pub enum TableMode {
 
 #[derive(Debug, Clone)]
 pub struct Segment<'a> {
-    pub style: Option<Color>,
+    pub style: Option<Style>,
     pub text: &'a str,
     pub ticks: bool,
 }
@@ -172,10 +172,10 @@ impl<'a> Segment<'a> {
         Segment { style: None, text, ticks: false }
     }
 
-    pub fn write(&self, buf: &mut impl Write, colored: bool, indent: usize) -> io::Result<()> {
-        if let Some(color) = &self.style {
-            if colored {
-                buf.write_all(color.ansi_code().as_bytes())?;
+    pub fn write(&self, buf: &mut impl Write, styled: bool, indent: usize) -> io::Result<()> {
+        if let Some(style) = &self.style {
+            if styled {
+                buf.write_all(style.ansi_code().as_bytes())?;
             } else if self.ticks {
                 buf.write_all(b"`")?;
             }
@@ -193,8 +193,8 @@ impl<'a> Segment<'a> {
         }
 
         if self.style.is_some() {
-            if colored {
-                buf.write_all(Color::ANSI_RESET.as_bytes())?;
+            if styled {
+                buf.write_all(Style::ANSI_RESET.as_bytes())?;
             } else if self.ticks {
                 buf.write_all(b"`")?;
             }
diff --git a/helptext/src/lib.rs b/helptext/src/lib.rs
index 0ca9b46..e0e5e76 100644
--- a/helptext/src/lib.rs
+++ b/helptext/src/lib.rs
@@ -2,7 +2,7 @@
 //!
 //! The syntax of the help message is explained in the [`sections`] macro.
 //!
-//! The syntax for colorizing text is explained in the [`text`] macro.
+//! The syntax for styling text is explained in the [`text`] macro.
 //!
 //! ```
 //! use helptext::{Help, sections};
@@ -11,10 +11,10 @@
 //!     ["my-cool-program " {env!("CARGO_PKG_VERSION")}]
 //!     ["Use " c:"-h" " for short descriptions and " c:"--help" " for more details."]
 //!     []
-//!     "USAGE" {
+//!     "Usage" {
 //!         ["my-cool-program [OPTIONS] <INPUT>"]
 //!     }
-//!     "OPTIONS" {
+//!     "Options" {
 //!         table Auto {
 //!             "-h, --help" => {
 //!                 ["Print help information"]
@@ -51,19 +51,19 @@
 //!     }
 //! ));
 //!
-//! fn print_short_help(use_colors: bool) {
+//! fn print_short_help(use_styles: bool) {
 //!     HELP.write(
 //!         &mut std::io::stdout().lock(),
 //!         false,  // don't show long help
-//!         use_colors,
+//!         use_styles,
 //!     );
 //! }
 //!
-//! fn print_long_help(use_colors: bool) {
+//! fn print_long_help(use_styles: bool) {
 //!     HELP.write(
 //!         &mut std::io::stdout().lock(),
 //!         true,  // show long help
-//!         use_colors,
+//!         use_styles,
 //!     );
 //! }
 //! ```
@@ -74,9 +74,9 @@
 //!
 //! ![Long help](https://raw.githubusercontent.com/pomsky-lang/pomsky/main/helptext/docs/long_help.png)
 
-mod color;
 mod help;
 mod macros;
+mod style;
 
-pub use color::Color;
 pub use help::*;
+pub use style::Style;
diff --git a/helptext/src/macros.rs b/helptext/src/macros.rs
index eaf162d..3adcdae 100644
--- a/helptext/src/macros.rs
+++ b/helptext/src/macros.rs
@@ -2,27 +2,27 @@
 #[macro_export]
 macro_rules! text_impl {
     // c:"text"
-    ([$color_id:ident : $lit:literal $($rest:tt)*] $($done:tt)*) => {
+    ([$style_id:ident : $lit:literal $($rest:tt)*] $($done:tt)*) => {
         $crate::text_impl!([$($rest)*] $($done)*, $crate::Segment {
-            style: Some($crate::Color::$color_id), text: $lit, ticks: true
+            style: Some($crate::Style::$style_id), text: $lit, ticks: true
         })
     };
     // c:{expr}
-    ([$color_id:ident : {$ex:expr} $($rest:tt)*] $($done:tt)*) => {
+    ([$style_id:ident : {$ex:expr} $($rest:tt)*] $($done:tt)*) => {
         $crate::text_impl!([$($rest)*] $($done)*, $crate::Segment {
-            style: Some($crate::Color::$color_id), text: $ex, ticks: true
+            style: Some($crate::Style::$style_id), text: $ex, ticks: true
         })
     };
     // c!"text"
-    ([$color_id:ident ! $lit:literal $($rest:tt)*] $($done:tt)*) => {
+    ([$style_id:ident ! $lit:literal $($rest:tt)*] $($done:tt)*) => {
         $crate::text_impl!([$($rest)*] $($done)*, $crate::Segment {
-            style: Some($crate::Color::$color_id), text: $lit, ticks: false
+            style: Some($crate::Style::$style_id), text: $lit, ticks: false
         })
     };
     // c!{expr}
-    ([$color_id:ident ! {$ex:expr} $($rest:tt)*] $($done:tt)*) => {
+    ([$style_id:ident ! {$ex:expr} $($rest:tt)*] $($done:tt)*) => {
         $crate::text_impl!([$($rest)*] $($done)*, $crate::Segment {
-            style: Some($crate::Color::$color_id), text: $ex, ticks: false
+            style: Some($crate::Style::$style_id), text: $ex, ticks: false
         })
     };
     // "text"
@@ -131,14 +131,15 @@ macro_rules! sections_impl {
 ///
 /// Each segment can be preceded by one of
 ///
-/// - `c:`, where `c` is a [`Color`](crate::Color) variant; the segment is
-///   printed in color if supported, otherwise it is wrapped in backticks
-/// - `c!`, where `c` is a [`Color`](crate::Color) variant; the segment is
-///   printed in color if supported, otherwise no formatting is applied
+/// - `c:`, where `c` is a [`Style`](crate::Style) variant; the segment is
+///   styled if supported, otherwise it is wrapped in backticks
+/// - `c!`, where `c` is a [`Style`](crate::Style) variant; the segment is
+///   styled if supported, otherwise no formatting is applied
 ///
-/// Each color can be abbreviated with its first letter (cyan ➔ c, green ➔ g,
+/// Each color style can be abbreviated with its first letter (cyan ➔ c, green ➔ g,
 /// magenta ➔ m, red ➔ r, yellow ➔ y); use an uppercase letter to make it
-/// bold (bold cyan ➔ C, etc.)
+/// bold (bold cyan ➔ C, etc.). The `Underline` and `UnderlineBold` styles
+/// are abbreviated as `u` and `U`, respectively.
 ///
 /// Segments are _not_ separated with commas, for example:
 ///
@@ -180,7 +181,7 @@ macro_rules! text {
 ///
 ///    ```
 ///    # helptext::sections!(
-///    "USAGE" {
+///    "Usage" {
 ///        ["section 1"]
 ///        ["section 2"]
 ///    }
diff --git a/helptext/src/style.rs b/helptext/src/style.rs
new file mode 100644
index 0000000..fabef2f
--- /dev/null
+++ b/helptext/src/style.rs
@@ -0,0 +1,82 @@
+/// All supported styles in the formatting machinery
+#[non_exhaustive]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum Style {
+    /// Cyan text; alias: c
+    Cyan,
+    /// Green text; alias: g
+    Green,
+    /// Magenta text; alias: m
+    Magenta,
+    /// Red text; alias: r
+    Red,
+    /// Yellow text; alias: y
+    Yellow,
+    /// Cyan bold text; alias: C
+    CyanBold,
+    /// Green bold text; alias: G
+    GreenBold,
+    /// Magenta bold text; alias: M
+    MagentaBold,
+    /// Red bold text; alias: R
+    RedBold,
+    /// Yellow bold text; alias: Y
+    YellowBold,
+
+    /// Underlined text; alias: u
+    Underline,
+    /// Underlined bold text; alias: U
+    UnderlineBold,
+}
+
+#[allow(non_upper_case_globals)]
+impl Style {
+    pub const c: Style = Style::Cyan;
+    pub const g: Style = Style::Green;
+    pub const m: Style = Style::Magenta;
+    pub const r: Style = Style::Red;
+    pub const y: Style = Style::Yellow;
+    pub const u: Style = Style::Underline;
+
+    pub const C: Style = Style::CyanBold;
+    pub const G: Style = Style::GreenBold;
+    pub const M: Style = Style::MagentaBold;
+    pub const R: Style = Style::RedBold;
+    pub const Y: Style = Style::YellowBold;
+    pub const U: Style = Style::UnderlineBold;
+
+    pub(crate) const ANSI_RESET: &'static str = "\x1b[0m";
+    pub(crate) const ANSI_C: &'static str = "\x1b[36m";
+    pub(crate) const ANSI_G: &'static str = "\x1b[32m";
+    pub(crate) const ANSI_M: &'static str = "\x1b[35m";
+    pub(crate) const ANSI_R: &'static str = "\x1b[31m";
+    pub(crate) const ANSI_Y: &'static str = "\x1b[33m";
+    pub(crate) const ANSI_CB: &'static str = "\x1b[36;1m";
+    pub(crate) const ANSI_GB: &'static str = "\x1b[32;1m";
+    pub(crate) const ANSI_MB: &'static str = "\x1b[35;1m";
+    pub(crate) const ANSI_RB: &'static str = "\x1b[31;1m";
+    pub(crate) const ANSI_YB: &'static str = "\x1b[33;1m";
+
+    pub(crate) const ANSI_U: &'static str = "\x1b[4m";
+    pub(crate) const ANSI_UB: &'static str = "\x1b[4;1m";
+}
+
+impl Style {
+    pub fn ansi_code(self) -> &'static str {
+        match self {
+            Style::Cyan => Self::ANSI_C,
+            Style::Green => Self::ANSI_G,
+            Style::Magenta => Self::ANSI_M,
+            Style::Red => Self::ANSI_R,
+            Style::Yellow => Self::ANSI_Y,
+            Style::CyanBold => Self::ANSI_CB,
+            Style::GreenBold => Self::ANSI_GB,
+            Style::MagentaBold => Self::ANSI_MB,
+            Style::RedBold => Self::ANSI_RB,
+            Style::YellowBold => Self::ANSI_YB,
+
+            Style::Underline => Self::ANSI_U,
+            Style::UnderlineBold => Self::ANSI_UB,
+        }
+    }
+}
diff --git a/pomsky-bin/Cargo.toml b/pomsky-bin/Cargo.toml
index 4092029..4ebf02f 100644
--- a/pomsky-bin/Cargo.toml
+++ b/pomsky-bin/Cargo.toml
@@ -20,16 +20,17 @@ path = "src/main.rs"
 
 [features]
 default = ["test"]
-test = ["dep:pcre2"]
+test = ["dep:pcre2", "dep:regex", "dep:ignore"]
 
 [dependencies]
 lexopt = "0.3.0"
-supports-color = "2.0.0"
+supports-color = "3.0.2"
 helptext = { version = "0.1.0", path = "../helptext" }
 serde_json = "1.0.91"
 serde = { version = "1.0.152", features = ["derive"] }
 pcre2 = { version = "0.2.5", optional = true }
-ignore = "0.4.23"
+regex = { version = "1.11.1", optional = true }
+ignore = { version = "0.4.23", optional = true }
 
 [dependencies.miette]
 version = "7.4.0"
diff --git a/pomsky-bin/src/args/engines.rs b/pomsky-bin/src/args/engines.rs
index 9927461..e8499f0 100644
--- a/pomsky-bin/src/args/engines.rs
+++ b/pomsky-bin/src/args/engines.rs
@@ -5,6 +5,7 @@ use super::ParseArgsError;
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub(crate) enum RegexEngine {
     Pcre2,
+    Rust,
 }
 
 impl RegexEngine {
@@ -12,6 +13,7 @@ impl RegexEngine {
         let lower = value.to_string_lossy().to_ascii_lowercase();
         Ok(match lower.as_str() {
             "pcre2" => RegexEngine::Pcre2,
+            "rust" => RegexEngine::Rust,
             _ => return Err(ParseArgsError::UnknownEngine(lower)),
         })
     }
diff --git a/pomsky-bin/src/args/errors.rs b/pomsky-bin/src/args/errors.rs
index 55a6741..a2715b8 100644
--- a/pomsky-bin/src/args/errors.rs
+++ b/pomsky-bin/src/args/errors.rs
@@ -6,6 +6,7 @@ pub(crate) enum ParseArgsError {
     StdinUtf8(FromUtf8Error),
     UnexpectedTwice(&'static str),
     NoInput,
+    NoPath,
     InputAndPath,
     UnknownFlavor(String),
     UnknownEngine(String),
@@ -29,31 +30,32 @@ impl fmt::Display for ParseArgsError {
             ParseArgsError::StdinUtf8(e) => write!(f, "Could not parse stdin: {e}"),
             ParseArgsError::UnexpectedTwice(option) => write!(
                 f,
-                "The argument '{option}' was provided more than once, \
+                "The argument `{option}` was provided more than once, \
                     but cannot be used multiple times"
             ),
             ParseArgsError::UnknownFlavor(flavor) => write!(
                 f,
-                "'{flavor}' isn't a valid flavor\n\
+                "`{flavor}` isn't a valid flavor\n\
                     possible values: pcre, python, java, javascript, dotnet, ruby, rust"
             ),
             ParseArgsError::UnknownEngine(engine) => {
-                write!(f, "'{engine}' isn't a valid regex engine\npossible values: pcre2")
+                write!(f, "`{engine}` isn't a valid regex engine\npossible values: pcre2")
             }
             ParseArgsError::UnknownList(list) => {
-                write!(f, "'{list}' isn't a valid list\npossible values: shorthands")
+                write!(f, "`{list}` isn't a valid list\npossible values: shorthands")
             }
             ParseArgsError::NoInput => write!(f, "No input provided"),
+            ParseArgsError::NoPath => write!(f, "No file path provided"),
             ParseArgsError::InputAndPath => {
                 write!(f, "You can only provide an input or a path, but not both")
             }
             ParseArgsError::WarningsNoEquals(warning) => write!(
                 f,
-                "'{warning}' contains no '='\n\
-                    try '-W{warning}=0' to disable {warning} warnings"
+                "`{warning}` contains no `=`\n\
+                    try `-W{warning}=0` to disable {warning} warnings"
             ),
             ParseArgsError::WarningsNoZero(warning) => {
-                write!(f, "warnings can only be disabled, try '-W{warning}=0'")
+                write!(f, "warnings can only be disabled, try `-W{warning}=0`")
             }
             ParseArgsError::WarningsNotAllowed(warning) => {
                 write!(f, "`{warning}` diagnostic kind cannot be disabled")
diff --git a/pomsky-bin/src/args/features.rs b/pomsky-bin/src/args/features.rs
index dfa05e6..b2f90e3 100644
--- a/pomsky-bin/src/args/features.rs
+++ b/pomsky-bin/src/args/features.rs
@@ -2,9 +2,14 @@ use std::ffi::OsString;
 
 use pomsky::features::PomskyFeatures;
 
+use crate::format::Logger;
+
 use super::ParseArgsError;
 
-pub(super) fn parse_features(value: OsString) -> Result<PomskyFeatures, ParseArgsError> {
+pub(super) fn parse_features(
+    logger: &Logger,
+    value: OsString,
+) -> Result<PomskyFeatures, ParseArgsError> {
     let lower = value.to_string_lossy().to_ascii_lowercase();
 
     let mut features = PomskyFeatures::new();
@@ -29,7 +34,7 @@ pub(super) fn parse_features(value: OsString) -> Result<PomskyFeatures, ParseArg
                 "recursion" => features.recursion(true),
                 "intersection" => features.intersection(true),
                 s => {
-                    efprintln!(Y!"warning" ": unknown feature `" {s} "`");
+                    logger.warn().println(format_args!("unknown feature `{s}`"));
                     features
                 }
             };
diff --git a/pomsky-bin/src/args/help.rs b/pomsky-bin/src/args/help.rs
index fdbfdd2..ddc75ae 100644
--- a/pomsky-bin/src/args/help.rs
+++ b/pomsky-bin/src/args/help.rs
@@ -2,7 +2,7 @@ use helptext::{sections, Help, HelpSection};
 use supports_color::Stream;
 
 const USAGE: Help = Help(sections![
-    "USAGE" {
+    "Usage" {
         ["pomsky [OPTIONS] <INPUT>\n\
         pomsky [OPTIONS] --path <PATH>\n\
         command | pomsky [OPTIONS]"]
@@ -88,13 +88,13 @@ pub(super) const HELP: Help = Help(sections![
     \n\
     Use " c:"-h" " for short descriptions and " c:"--help" " for more details."]
 
-    "USAGE" {
+    "Usage" {
         ["pomsky [OPTIONS] <INPUT>\n\
         pomsky [OPTIONS] --path <PATH>\n\
         command | pomsky [OPTIONS]"]
     }
 
-    "SUBCOMMANDS" {
+    "Subcommands" {
         table Auto {
             "pomsky test" => {
                 ["Run unit tests in pomsky expressions"]
@@ -104,7 +104,7 @@ pub(super) const HELP: Help = Help(sections![
         }
     }
 
-    "ARGS" {
+    "Args" {
         table Auto {
             "<INPUT>" => {
                 ["Pomsky expression to compile"]
@@ -115,7 +115,7 @@ pub(super) const HELP: Help = Help(sections![
         }
     }
 
-    "OPTIONS" {
+    "Options" {
         table Auto {
             "    --allowed-features <FEATURE>..." => {
                 ["Comma-separated list of allowed features [default: all enabled]"]
@@ -151,8 +151,8 @@ pub(super) const HELP: Help = Help(sections![
         }
     }
 
-    Long "FLAVORS" FLAVORS
-    Long "FEATURES" FEATURES
+    Long "Flavors" FLAVORS
+    Long "Features" FEATURES
 ]);
 
 pub(super) const TEST_HELP: Help = Help(sections![
@@ -163,13 +163,11 @@ pub(super) const TEST_HELP: Help = Help(sections![
     \n\
     Use " c:"-h" " for short descriptions and " c:"--help" " for more details."]
 
-    "USAGE" {
-        ["pomsky test [OPTIONS] --path <PATH>\n\
-        pomsky test [OPTIONS] <INPUT>\n\
-        command | pomsky test [OPTIONS]"]
+    "Usage" {
+        ["pomsky test [OPTIONS] --path <PATH>"]
     }
 
-    "ARGS" {
+    "Args" {
         table Auto {
             "<INPUT>" => {
                 ["Pomsky expression to test"]
@@ -180,7 +178,7 @@ pub(super) const TEST_HELP: Help = Help(sections![
         }
     }
 
-    "OPTIONS" {
+    "Options" {
         table Auto {
             "    --allowed-features <FEATURE>..." => {
                 ["Comma-separated list of allowed features [default: all enabled]"]
@@ -199,7 +197,7 @@ pub(super) const TEST_HELP: Help = Help(sections![
                 ["Print help information"]
                 Long ["Use " c:"-h" " for short descriptions and " c:"--help" " for more details."]
             }
-            "-p, --path <FILE>" => {
+            "-p, --path <PATH>" => {
                 ["File or directory containing the pomsky expressions to compile"]
                 Long ["If a directory is specified, all contained " c:"*.pomsky" " files are tested.
 Note that pomsky respects " c:".gitignore" " files."]
@@ -214,12 +212,12 @@ Note that pomsky respects " c:".gitignore" " files."]
         }
     }
 
-    Long "FLAVORS" FLAVORS
-    Long "ENGINES" ENGINES
-    Long "FEATURES" FEATURES
+    Long "Flavors" FLAVORS
+    Long "Engines" ENGINES
+    Long "Features" FEATURES
 ]);
 
-pub(crate) fn print_short_usage_and_help_err() {
+pub(crate) fn print_usage_and_help() {
     let _ = USAGE.write(&mut std::io::stderr().lock(), false, is_colored(Stream::Stderr));
 }
 
diff --git a/pomsky-bin/src/args/mod.rs b/pomsky-bin/src/args/mod.rs
index 6be6ec9..6f16751 100644
--- a/pomsky-bin/src/args/mod.rs
+++ b/pomsky-bin/src/args/mod.rs
@@ -2,12 +2,14 @@ use std::path::PathBuf;
 
 use pomsky::{features::PomskyFeatures, options::RegexFlavor};
 
+pub(crate) use self::engines::RegexEngine;
 pub(crate) use errors::ParseArgsError;
-pub(crate) use help::print_short_usage_and_help_err;
+pub(crate) use help::print_usage_and_help;
 pub(crate) use input::Input;
 pub(crate) use warnings::DiagnosticSet;
 
-use self::engines::RegexEngine;
+use crate::format::Logger;
+
 use self::parse::{ListKind, Parsed};
 
 mod engines;
@@ -62,8 +64,8 @@ pub(crate) struct TestOptions {
     pub(crate) pass_with_no_tests: bool,
 }
 
-pub(super) fn parse_args() -> Result<(Subcommand, GlobalOptions), ParseArgsError> {
-    match parse::parse_args_inner(lexopt::Parser::from_env())? {
+pub(super) fn parse_args(logger: &Logger) -> Result<(Subcommand, GlobalOptions), ParseArgsError> {
+    match parse::parse_args_inner(logger, lexopt::Parser::from_env())? {
         Parsed::Options(subcommand, opts) => Ok((subcommand, opts)),
         Parsed::Help(help) => {
             match help {
diff --git a/pomsky-bin/src/args/parse.rs b/pomsky-bin/src/args/parse.rs
index 62b69bd..1e03622 100644
--- a/pomsky-bin/src/args/parse.rs
+++ b/pomsky-bin/src/args/parse.rs
@@ -4,6 +4,7 @@ use std::path::PathBuf;
 use pomsky::{features::PomskyFeatures, options::RegexFlavor};
 
 use crate::args::RegexEngine;
+use crate::format::Logger;
 
 use super::{
     CompileOptions, DiagnosticSet, GlobalOptions, Input, ParseArgsError, Subcommand, TestOptions,
@@ -17,8 +18,11 @@ pub(super) enum Parsed {
     List(ListKind),
 }
 
-pub fn parse_args_inner(mut parser: lexopt::Parser) -> Result<Parsed, ParseArgsError> {
-    RootParser::new().parse(&mut parser)
+pub fn parse_args_inner(
+    logger: &Logger,
+    mut parser: lexopt::Parser,
+) -> Result<Parsed, ParseArgsError> {
+    RootParser::new().parse(logger, &mut parser)
 }
 
 #[derive(PartialEq)]
@@ -44,7 +48,7 @@ struct RootParser {
 
 // we have to do this to deduplicate code without creating borrowcheck issues, because `parser` is a lending iterator
 macro_rules! parse_root_arg {
-    ($arg:expr, $parser:expr, $root:expr) => {
+    ($logger:expr, $arg:expr, $parser:expr, $root:expr) => {
         match $arg {
             Short('d') | Long("debug") => $root.debug.set_arg(true, "--debug")?,
             Short('f') | Long("flavor") => {
@@ -54,7 +58,7 @@ macro_rules! parse_root_arg {
             }
             Short('W') | Long("warnings") => $root.warnings.parse($parser.value()?)?,
             Long("allowed-features") => $root.allowed_features.set_arg(
-                super::features::parse_features($parser.value()?)?,
+                super::features::parse_features($logger, $parser.value()?)?,
                 "--allowed-features",
             )?,
             Long("json") => $root.json.set_arg(true, "--json")?,
@@ -67,7 +71,7 @@ macro_rules! parse_root_arg {
 }
 
 macro_rules! parse_compile_options {
-    ($arg:expr, $parser:expr, $self:expr) => {
+    ($logger:expr, $arg:expr, $parser:expr, $self:expr) => {
         match $arg {
             Short('p') | Long("path") => $self.path.set_arg($parser.value()?.parse()?, "--path")?,
             Short('t') | Long("test") => {
@@ -77,7 +81,7 @@ macro_rules! parse_compile_options {
             Value(val) if $self.input_value.is_none() => {
                 $self.input_value = Some(val.into_string().map_err(lexopt::Error::from)?);
             }
-            _ => parse_root_arg!($arg, $parser, $self.root),
+            _ => parse_root_arg!($logger, $arg, $parser, $self.root),
         }
     };
 }
@@ -93,7 +97,7 @@ impl RootParser {
         }
     }
 
-    fn parse(self, parser: &mut lexopt::Parser) -> Result<Parsed, ParseArgsError> {
+    fn parse(self, logger: &Logger, parser: &mut lexopt::Parser) -> Result<Parsed, ParseArgsError> {
         use lexopt::prelude::*;
 
         let Some(arg) = parser.next()? else {
@@ -111,11 +115,11 @@ impl RootParser {
                 };
                 Ok(Parsed::List(ListKind::Shorthands))
             }
-            Value(val) if val == "test" => TestParser::new(self).parse(parser),
+            Value(val) if val == "test" => TestParser::new(self).parse(logger, parser),
             arg => {
                 let mut compile_parser = CompileParser::new(self);
-                parse_compile_options!(arg, parser, compile_parser);
-                compile_parser.parse(parser)
+                parse_compile_options!(logger, arg, parser, compile_parser);
+                compile_parser.parse(logger, parser)
             }
         }
     }
@@ -147,11 +151,15 @@ impl CompileParser {
         Self { root, input_value: None, path: None, no_new_line: false, test: None }
     }
 
-    fn parse(mut self, parser: &mut lexopt::Parser) -> Result<Parsed, ParseArgsError> {
+    fn parse(
+        mut self,
+        logger: &Logger,
+        parser: &mut lexopt::Parser,
+    ) -> Result<Parsed, ParseArgsError> {
         use lexopt::prelude::*;
 
         while let Some(arg) = parser.next()? {
-            parse_compile_options!(arg, parser, self);
+            parse_compile_options!(logger, arg, parser, self);
         }
         self.finish()
     }
@@ -185,7 +193,11 @@ impl TestParser {
         Self { root, path: None, engine: None, pass_with_no_tests: None }
     }
 
-    fn parse(mut self, parser: &mut lexopt::Parser) -> Result<Parsed, ParseArgsError> {
+    fn parse(
+        mut self,
+        logger: &Logger,
+        parser: &mut lexopt::Parser,
+    ) -> Result<Parsed, ParseArgsError> {
         use lexopt::prelude::*;
 
         while let Some(arg) = parser.next()? {
@@ -201,14 +213,14 @@ impl TestParser {
                 }
                 Short('h') => return Ok(Parsed::Help(Help::TestShort)),
                 Long("help") => return Ok(Parsed::Help(Help::TestLong)),
-                _ => parse_root_arg!(arg, parser, self.root),
+                _ => parse_root_arg!(logger, arg, parser, self.root),
             }
         }
         self.finish()
     }
 
     fn finish(self) -> Result<Parsed, ParseArgsError> {
-        let path = self.path.ok_or(ParseArgsError::NoInput)?;
+        let path = self.path.ok_or(ParseArgsError::NoPath)?;
 
         self.root.finish(Subcommand::Test(TestOptions {
             path,
diff --git a/pomsky-bin/src/format.rs b/pomsky-bin/src/format.rs
index 8dd034b..47bdaf3 100644
--- a/pomsky-bin/src/format.rs
+++ b/pomsky-bin/src/format.rs
@@ -1,16 +1,11 @@
-use std::io::Write;
+use std::{
+    fmt::Display,
+    io::{StderrLock, Write},
+};
 
-macro_rules! efprintln {
-    ($($args:tt)*) => {{
-        $crate::format::efwriteln(helptext::text![$($args)*]);
-    }};
-}
+use helptext::{Segment, Style};
 
-macro_rules! efprint {
-    ($($args:tt)*) => {{
-        $crate::format::efwrite(helptext::text![$($args)*]);
-    }};
-}
+use crate::Severity;
 
 pub(crate) fn supports_color() -> bool {
     matches!(
@@ -19,17 +14,198 @@ pub(crate) fn supports_color() -> bool {
     )
 }
 
-pub(crate) fn efwriteln(segments: &[helptext::Segment]) {
-    let mut buf = std::io::stderr().lock();
-    for segment in segments {
-        let _ = segment.write(&mut buf, supports_color(), 0);
+pub(crate) struct Logger {
+    colored: bool,
+    enabled: bool,
+}
+
+impl Logger {
+    fn copy(&self) -> Self {
+        Logger { colored: self.colored, enabled: self.enabled }
+    }
+
+    pub(crate) fn new() -> Self {
+        Logger { colored: supports_color(), enabled: true }
+    }
+
+    pub(crate) fn color(&self, colored: bool) -> Self {
+        let mut copy = self.copy();
+        copy.colored = colored;
+        copy
+    }
+
+    pub(crate) fn enabled(self, enabled: bool) -> Self {
+        let mut copy = self.copy();
+        copy.enabled = enabled;
+        copy
+    }
+
+    pub(crate) fn emptyln(&self) {
+        if self.enabled {
+            let mut buf = std::io::stderr().lock();
+            let _ = buf.write_all(b"\n");
+        }
+    }
+
+    pub(crate) fn basic(&self) -> Formatted<FormatBasic> {
+        Formatted { format: FormatBasic, logger: self }
+    }
+
+    pub(crate) fn diagnostic<'a>(
+        &self,
+        severity: Severity,
+        kind: &'a str,
+    ) -> Formatted<FormatDetailed<'a, 4>> {
+        let label = match severity {
+            Severity::Error => Segment { style: Some(Style::R), text: "error", ticks: false },
+            Severity::Warning => Segment { style: Some(Style::Y), text: "warning", ticks: false },
+        };
+        let start = [label, Segment::new("("), Segment::new(kind), Segment::new("):")];
+        Formatted { format: FormatDetailed { start }, logger: self }
+    }
+
+    pub(crate) fn diagnostic_with_code<'a>(
+        &self,
+        severity: Severity,
+        code: &'a str,
+        kind: &'a str,
+    ) -> Formatted<FormatDetailed<'a, 5>> {
+        let label = match severity {
+            Severity::Error => Segment { style: Some(Style::R), text: "error ", ticks: false },
+            Severity::Warning => Segment { style: Some(Style::Y), text: "warning ", ticks: false },
+        };
+        let start = [
+            label,
+            Segment { style: Some(Style::R), text: code, ticks: false },
+            Segment::new("("),
+            Segment::new(kind),
+            Segment::new("):"),
+        ];
+        Formatted { format: FormatDetailed { start }, logger: self }
+    }
+
+    pub(crate) fn error(&self) -> Formatted<FormatError> {
+        Formatted { format: FormatError, logger: self }
+    }
+
+    pub(crate) fn warn(&self) -> Formatted<FormatWarning> {
+        Formatted { format: FormatWarning, logger: self }
+    }
+
+    pub(crate) fn note(&self) -> Formatted<FormatNote> {
+        Formatted { format: FormatNote, logger: self }
     }
-    let _ = buf.write_all(b"\n");
 }
 
-pub(crate) fn efwrite(segments: &[helptext::Segment]) {
-    let mut buf = std::io::stderr().lock();
-    for segment in segments {
-        let _ = segment.write(&mut buf, supports_color(), 0);
+pub(crate) struct FormatDetailed<'a, const N: usize> {
+    start: [Segment<'a>; N],
+}
+pub(crate) struct FormatError;
+pub(crate) struct FormatWarning;
+pub(crate) struct FormatNote;
+pub(crate) struct FormatBasic;
+
+pub(crate) trait Format {
+    fn start_segments(&self) -> &'_ [Segment<'_>];
+    fn force_enabled() -> bool {
+        false
+    }
+}
+
+impl<const N: usize> Format for FormatDetailed<'_, N> {
+    fn start_segments(&self) -> &[Segment<'_>] {
+        &self.start
+    }
+}
+
+const ERROR_SEGMENT: Segment<'_> =
+    Segment { style: Some(Style::RedBold), ticks: false, text: "error" };
+const WARN_SEGMENT: Segment<'_> =
+    Segment { style: Some(Style::YellowBold), ticks: false, text: "warning" };
+const NOTE_SEGMENT: Segment<'_> =
+    Segment { style: Some(Style::CyanBold), ticks: false, text: "note" };
+const END_SEGMENT: Segment<'_> = Segment { style: None, ticks: false, text: ": " };
+
+impl Format for FormatError {
+    fn start_segments(&self) -> &[Segment<'_>] {
+        &[ERROR_SEGMENT, END_SEGMENT]
+    }
+
+    fn force_enabled() -> bool {
+        true
+    }
+}
+
+impl Format for FormatWarning {
+    fn start_segments(&self) -> &[Segment<'_>] {
+        &[WARN_SEGMENT, END_SEGMENT]
+    }
+}
+
+impl Format for FormatNote {
+    fn start_segments(&self) -> &[Segment<'_>] {
+        &[NOTE_SEGMENT, END_SEGMENT]
+    }
+}
+
+impl Format for FormatBasic {
+    fn start_segments(&self) -> &[Segment<'_>] {
+        &[]
+    }
+}
+
+pub(crate) struct Formatted<'a, F: Format> {
+    logger: &'a Logger,
+    format: F,
+}
+
+impl<F: Format> Formatted<'_, F> {
+    fn start(&self, buf: &mut StderrLock<'_>) {
+        for segment in self.format.start_segments() {
+            let _ = segment.write(buf, self.logger.colored, 0);
+        }
+    }
+
+    pub(crate) fn print(&self, display: impl Display) {
+        if self.logger.enabled || F::force_enabled() {
+            let mut buf = std::io::stderr().lock();
+            self.start(&mut buf);
+
+            let _ = buf.write_fmt(format_args!("{display}"));
+            buf.flush().unwrap();
+        }
+    }
+
+    pub(crate) fn println(&self, display: impl Display) {
+        if self.logger.enabled || F::force_enabled() {
+            let mut buf = std::io::stderr().lock();
+            self.start(&mut buf);
+
+            let _ = buf.write_fmt(format_args!("{display}\n"));
+        }
+    }
+
+    pub(crate) fn fmt(&self, segments: &[Segment]) {
+        if self.logger.enabled || F::force_enabled() {
+            let mut buf = std::io::stderr().lock();
+            self.start(&mut buf);
+
+            for segment in segments {
+                let _ = segment.write(&mut buf, self.logger.colored, 0);
+            }
+            buf.flush().unwrap();
+        }
+    }
+
+    pub(crate) fn fmtln(&self, segments: &[Segment]) {
+        if self.logger.enabled || F::force_enabled() {
+            let mut buf = std::io::stderr().lock();
+            self.start(&mut buf);
+
+            for segment in segments {
+                let _ = segment.write(&mut buf, self.logger.colored, 0);
+            }
+            let _ = buf.write_all(b"\n");
+        }
     }
 }
diff --git a/pomsky-bin/src/lib.rs b/pomsky-bin/src/lib.rs
index 62b55ff..6204e69 100644
--- a/pomsky-bin/src/lib.rs
+++ b/pomsky-bin/src/lib.rs
@@ -3,8 +3,11 @@ mod format;
 mod args;
 mod result;
 #[cfg(feature = "test")]
-mod test;
+mod test_runner;
+#[cfg(feature = "test")]
+mod testing;
 
+use format::Logger;
 pub use result::{
     CompilationResult, Diagnostic, Kind, QuickFix, Replacement, Severity, Span, Timings, Version,
 };
@@ -19,26 +22,29 @@ use pomsky::{
 use args::{CompileOptions, GlobalOptions, Input};
 
 pub fn main() {
-    let (subcommand, args) = args::parse_args().unwrap_or_else(|error| {
-        efprintln!(R!"error" ": " {&error.to_string()});
-        args::print_short_usage_and_help_err();
+    let mut logger = Logger::new();
+
+    let (subcommand, args) = args::parse_args(&logger).unwrap_or_else(|error| {
+        logger.error().println(error);
+        args::print_usage_and_help();
         exit(2)
     });
 
-    if args.json && std::env::var_os("NO_COLOR").is_none() {
-        std::env::set_var("NO_COLOR", "1");
+    if args.json {
+        logger = logger.color(false).enabled(false);
     }
 
     match subcommand {
         args::Subcommand::Compile(compile_args) => {
             if compile_args.test.is_some() {
-                handle_disabled_tests();
-                show_tests_deprecated_warning();
+                handle_disabled_tests(&logger);
+                show_tests_deprecated_warning(&logger);
             }
 
             match &compile_args.input {
                 Input::Value(input) => {
                     compile(None, input, &compile_args, &args).output(
+                        &logger,
                         args.json,
                         !compile_args.no_new_line,
                         compile_args.in_test_suite,
@@ -48,6 +54,7 @@ pub fn main() {
                 Input::File(path) => match std::fs::read_to_string(path) {
                     Ok(input) => {
                         compile(Some(path), &input, &compile_args, &args).output(
+                            &logger,
                             args.json,
                             !compile_args.no_new_line,
                             compile_args.in_test_suite,
@@ -55,152 +62,43 @@ pub fn main() {
                         );
                     }
                     Err(error) => {
-                        efprintln!(R!"error" ": " {&error.to_string()});
+                        logger.error().println(error);
                         exit(3);
                     }
                 },
             }
         }
-        args::Subcommand::Test(test_args) => {
-            handle_disabled_tests();
-
-            let compile_args = CompileOptions {
-                input: Input::File(test_args.path),
-                no_new_line: false,
-                test: test_args.engine,
-                in_test_suite: true,
-            };
-
-            let Input::File(path) = &compile_args.input else { unreachable!() };
-
-            let current_dir = std::env::current_dir().expect("Could not get current directory");
-            let path = if path.is_relative() { current_dir.join(path) } else { path.to_owned() };
-            let metadata = std::fs::metadata(&path).expect("Could not get path metadata");
-            let mut results = Vec::new();
-
-            if metadata.is_dir() {
-                let mut total = 0;
-                let mut failed = 0;
-                let start = Instant::now();
+        args::Subcommand::Test(_test_args) => {
+            handle_disabled_tests(&logger);
 
-                for entry in ignore::WalkBuilder::new(path)
-                    .follow_links(true)
-                    .filter_entry(is_dir_or_pomsky_file)
-                    .build()
-                {
-                    if let Ok(entry) = entry.map_err(|d| handle_walk_error(d, &current_dir)) {
-                        if entry.file_type().is_some_and(|ty| ty.is_file()) {
-                            total += 1;
-
-                            let path = entry.path();
-                            match std::fs::read_to_string(path) {
-                                Ok(input) => {
-                                    efprint!(C!"testing " {&path.strip_prefix(&current_dir)
-                                        .unwrap_or(path).display().to_string()} " ... ");
-                                    let result = compile(Some(path), &input, &compile_args, &args);
-                                    if !result.success {
-                                        failed += 1;
-                                    }
-                                    if args.json {
-                                        eprintln!(
-                                            "{}",
-                                            if result.success { "ok" } else { "failed" }
-                                        );
-                                        results.push(result);
-                                    } else {
-                                        result.output(
-                                            args.json,
-                                            !compile_args.no_new_line,
-                                            compile_args.in_test_suite,
-                                            &input,
-                                        )
-                                    }
-                                }
-                                Err(error) => {
-                                    efprintln!(R!"error" ": " {&error.to_string()});
-                                    exit(3);
-                                }
-                            }
-                        }
-                    };
-                }
-
-                if total == 0 && !args.json {
-                    if test_args.pass_with_no_tests {
-                        exit(0);
-                    } else {
-                        efprintln!(R!"error" ": no " C!"*.pomsky" " files found to test");
-                        exit(7);
-                    }
-                }
-
-                let time = start.elapsed();
-                eprintln!();
-                if failed > 0 {
-                    efprintln!("test result: " R!{&failed.to_string()} R!" pomsky file(s) failed" ", "
-                        {&total.to_string()} " files tested in " {&format!("{time:.2?}")});
-                } else {
-                    efprintln!("test result: " G!"ok" ", " {&total.to_string()} " files tested");
-                }
-                print_json_test_result(args.json, &results);
-            } else if metadata.is_file() {
-                match std::fs::read_to_string(&path) {
-                    Ok(input) => {
-                        efprint!(C!"testing " {&path.strip_prefix(&current_dir).unwrap_or(&path).display().to_string()} " ... ");
-                        let result = compile(Some(&path), &input, &compile_args, &args);
-                        if args.json {
-                            eprintln!("{}", if result.success { "ok" } else { "failed" });
-                            results.push(result);
-                            print_json_test_result(true, &results);
-                        } else {
-                            result.output(
-                                args.json,
-                                !compile_args.no_new_line,
-                                compile_args.in_test_suite,
-                                &input,
-                            )
-                        }
-                    }
-                    Err(error) => {
-                        efprintln!(R!"error" ": " {&error.to_string()});
-                        exit(3);
-                    }
-                }
-            } else {
-                efprintln!(R!"error" ": expected file or directory, but " c:{&path.display().to_string()} " is neither");
-                exit(5);
-            }
+            #[cfg(feature = "test")]
+            testing::test(&logger, args, _test_args);
         }
     }
 }
 
-fn handle_disabled_tests() {
+fn handle_disabled_tests(_logger: &Logger) {
     #[cfg(not(feature = "test"))]
     {
-        print_diagnostic(
-            &Diagnostic::ad_hoc(
-                Severity::Error,
-                None,
-                "Testing is not supported, because this pomsky binary \
-                was compiled with the `test` feature disabled!"
-                    .into(),
-                None,
-            ),
-            None,
+        _logger.error_plain(
+            "Testing is not supported, because this pomsky binary \
+            was compiled with the `test` feature disabled!",
         );
         exit(4);
     }
 }
 
-fn show_tests_deprecated_warning() {
-    efprintln!(Y!"warning" ": The `--test` argument is deprecated, \
-        use the `pomsky test` subcommand instead");
+fn show_tests_deprecated_warning(logger: &Logger) {
+    logger
+        .warn()
+        .println("The `--test` argument is deprecated, use the `pomsky test` subcommand instead");
 }
 
+// TODO: refactor this
 fn compile(
     path: Option<&Path>,
     input: &str,
-    compile_args: &CompileOptions,
+    #[allow(unused)] compile_args: &CompileOptions,
     args: &GlobalOptions,
 ) -> CompilationResult {
     let start = Instant::now();
@@ -245,7 +143,7 @@ fn compile(
             let mut test_errors = Vec::new();
 
             let start = Instant::now();
-            test::run_tests(&parsed, input, options, &mut test_errors);
+            test_runner::run_tests(&parsed, input, options, &mut test_errors);
             time_test = start.elapsed().as_micros();
 
             if !test_errors.is_empty() {
@@ -284,66 +182,3 @@ fn compile(
         )
     }
 }
-
-fn handle_walk_error(error: ignore::Error, current_dir: &Path) {
-    match error {
-        ignore::Error::Partial(errors) => {
-            for error in errors {
-                handle_walk_error(error, current_dir);
-            }
-        }
-        ignore::Error::WithLineNumber { line, err } => {
-            handle_walk_error(*err, current_dir);
-            efprintln!("    at line " C!{&line.to_string()});
-        }
-        ignore::Error::WithPath { path, err } => {
-            handle_walk_error(*err, current_dir);
-            efprintln!("    at path " C!{&path.display().to_string()});
-        }
-        ignore::Error::WithDepth { depth, err } => {
-            handle_walk_error(*err, current_dir);
-            efprintln!("    at depth " C!{&depth.to_string()});
-        }
-        ignore::Error::Loop { ancestor, child } => {
-            let ancestor = ancestor.strip_prefix(current_dir).unwrap_or(&ancestor);
-            let child = child.canonicalize().unwrap_or(child);
-
-            efprintln!(R!"error" ": file system loop detected!");
-            efprintln!("    ancestor: " C!{&ancestor.display().to_string()});
-            efprintln!("    child: " C!{&child.display().to_string()});
-        }
-        ignore::Error::Io(error) => {
-            efprintln!(R!"error" ": " {&error.to_string()})
-        }
-        ignore::Error::Glob { glob, err } => {
-            efprintln!(R!"error" ": " {&err});
-            if let Some(glob) = glob {
-                efprintln!("    glob: " C!{&glob});
-            }
-        }
-        ignore::Error::UnrecognizedFileType(file_type) => {
-            efprintln!(R!"error" ": file type " C!{&file_type} " not recognized");
-        }
-        ignore::Error::InvalidDefinition => {
-            efprintln!(R!"error" ": file type definition could not be parsed");
-        }
-    }
-}
-
-fn is_dir_or_pomsky_file(entry: &ignore::DirEntry) -> bool {
-    let Some(ty) = entry.file_type() else { return false };
-    if ty.is_dir() {
-        return true;
-    }
-    let Some(ext) = entry.path().extension() else { return false };
-    ext == "pomsky"
-}
-
-fn print_json_test_result(json: bool, results: &[CompilationResult]) {
-    if json {
-        match serde_json::to_string(&results) {
-            Ok(string) => println!("{string}"),
-            Err(e) => eprintln!("{e}"),
-        }
-    }
-}
diff --git a/pomsky-bin/src/result/mod.rs b/pomsky-bin/src/result/mod.rs
index 26d09e9..e1fd22e 100644
--- a/pomsky-bin/src/result/mod.rs
+++ b/pomsky-bin/src/result/mod.rs
@@ -1,8 +1,11 @@
 use std::{fmt, path::Path};
 
+use helptext::text;
 use pomsky::diagnose::{DiagnosticCode, DiagnosticKind};
 use serde::{Deserialize, Serialize};
 
+use crate::format::Logger;
+
 mod serde_code;
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -89,7 +92,14 @@ impl CompilationResult {
             .collect()
     }
 
-    pub(crate) fn output(self, json: bool, new_line: bool, in_test_suite: bool, source_code: &str) {
+    pub(crate) fn output(
+        self,
+        logger: &Logger,
+        json: bool,
+        new_line: bool,
+        in_test_suite: bool,
+        source_code: &str,
+    ) {
         let success = self.success;
         if json {
             match serde_json::to_string(&self) {
@@ -98,13 +108,9 @@ impl CompilationResult {
             }
         } else {
             if in_test_suite {
-                if success {
-                    efprintln!(G!"ok");
-                } else {
-                    efprintln!(R!"failed");
-                }
+                logger.basic().fmtln(if success { text![G!"ok"] } else { text![R!"failed"] });
             }
-            self.output_human_readable(new_line, in_test_suite, Some(source_code));
+            self.output_human_readable(logger, new_line, in_test_suite, Some(source_code));
         }
         if !success && !in_test_suite {
             std::process::exit(1);
@@ -113,6 +119,7 @@ impl CompilationResult {
 
     fn output_human_readable(
         mut self,
+        logger: &Logger,
         new_line: bool,
         in_test_suite: bool,
         source_code: Option<&str>,
@@ -121,25 +128,18 @@ impl CompilationResult {
             self.diagnostics.retain(|d| d.severity == Severity::Error);
         }
         let initial_len = self.diagnostics.len();
-        let error_len = self.diagnostics.iter().filter(|d| d.severity == Severity::Error).count();
-        let warning_len = self.diagnostics.len() - error_len;
 
         if self.diagnostics.len() > 8 {
             self.diagnostics.drain(8..);
         }
 
         for diag in &self.diagnostics {
-            diag.print_human_readable(source_code);
+            diag.print_human_readable(logger, source_code);
         }
 
-        if !self.diagnostics.is_empty() {
-            if initial_len > self.diagnostics.len() {
-                efprintln!(C!"note" ": " {&(initial_len - self.diagnostics.len()).to_string()} " diagnostic(s) were omitted");
-            }
-            if initial_len > 3 && error_len == 0 {
-                let warning_len = warning_len.to_string();
-                efprintln!(Y!"warning" ": pomsky generated " {&warning_len} " warnings");
-            }
+        if !self.diagnostics.is_empty() && initial_len > self.diagnostics.len() {
+            let omitted = initial_len - self.diagnostics.len();
+            logger.note().println(format_args!("{omitted} diagnostic(s) were omitted"));
         }
 
         if let Some(compiled) = &self.output {
@@ -187,7 +187,7 @@ pub struct Diagnostic {
     pub visual: String,
 }
 
-#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, PartialEq, Serialize, Deserialize, Clone, Copy)]
 #[serde(rename_all = "lowercase")]
 pub enum Severity {
     Error,
@@ -344,22 +344,15 @@ impl Diagnostic {
         }
     }
 
-    fn print_human_readable(&self, source_code: Option<&str>) {
+    fn print_human_readable(&self, logger: &Logger, source_code: Option<&str>) {
         let kind = self.kind.as_str();
-        let display = self.miette_display(source_code).to_string();
-        if let Some(code) = self.code {
-            let code = code.to_string();
-            match self.severity {
-                Severity::Error => efprint!(R!"error " R!{&code} "(" {&kind} "):" {&display}),
-                Severity::Warning => {
-                    efprint!(Y!"warning " Y!{&code} "(" {&kind} "):" {&display})
-                }
-            }
-        } else {
-            match self.severity {
-                Severity::Error => efprint!(R!"error" "(" {&kind} "):" {&display}),
-                Severity::Warning => efprint!(Y!"warning" "(" {&kind} "):" {&display}),
+        let display = self.miette_display(source_code);
+
+        match self.code {
+            Some(code) => {
+                logger.diagnostic_with_code(self.severity, &code.to_string(), kind).print(display);
             }
+            None => logger.diagnostic(self.severity, kind).print(display),
         }
     }
 
diff --git a/pomsky-bin/src/test.rs b/pomsky-bin/src/test_runner.rs
similarity index 61%
rename from pomsky-bin/src/test.rs
rename to pomsky-bin/src/test_runner.rs
index 00fd129..4179730 100644
--- a/pomsky-bin/src/test.rs
+++ b/pomsky-bin/src/test_runner.rs
@@ -1,11 +1,14 @@
-use pcre2::bytes::Regex;
+use std::ops::Index;
+
+use pcre2::bytes::Regex as PcreRegex;
 use pomsky::{
     diagnose::{Diagnostic, DiagnosticCode, Severity},
     features::PomskyFeatures,
-    options::{CompileOptions, RegexFlavor},
+    options::CompileOptions,
     test::{CaptureIdent, TestCase, TestCaseMatch, TestCaseMatchAll, TestCaseReject},
     Expr,
 };
+use regex::Regex as RustRegex;
 
 pub(crate) fn run_tests(
     parsed: &Expr,
@@ -13,32 +16,44 @@ pub(crate) fn run_tests(
     options: CompileOptions,
     errors: &mut Vec<Diagnostic>,
 ) {
-    let (Some(pcre_pattern), _) = parsed.compile(
-        input,
-        CompileOptions {
-            flavor: RegexFlavor::Pcre,
-            allowed_features: PomskyFeatures::default(),
-            ..options
-        },
-    ) else {
+    let (Some(pattern), _) = parsed
+        .compile(input, CompileOptions { allowed_features: PomskyFeatures::default(), ..options })
+    else {
         let msg = "Failed to compile the expression in the PCRE flavor for running tests".into();
         errors.push(Diagnostic::ad_hoc(Severity::Error, None, msg, None));
         return;
     };
 
-    let regex = pcre2::bytes::RegexBuilder::new()
-        .jit_if_available(true)
-        .ucp(true)
-        .utf(true)
-        .build(&pcre_pattern);
+    let regex = match options.flavor {
+        pomsky::options::RegexFlavor::Pcre => {
+            let regex = pcre2::bytes::RegexBuilder::new()
+                .jit_if_available(true)
+                .ucp(true)
+                .utf(true)
+                .build(&pattern);
 
-    let regex = match regex {
-        Ok(regex) => regex,
-        Err(e) => {
-            let help = Some(format!("The compiled regex is {pcre_pattern:?}"));
-            errors.push(Diagnostic::ad_hoc(Severity::Error, None, e.to_string(), help));
-            return;
+            match regex {
+                Ok(regex) => Regex::Pcre(regex),
+                Err(e) => {
+                    let help = Some(format!("The compiled regex is {pattern:?}"));
+                    errors.push(Diagnostic::ad_hoc(Severity::Error, None, e.to_string(), help));
+                    return;
+                }
+            }
         }
+        pomsky::options::RegexFlavor::Rust => {
+            let regex = RustRegex::new(&pattern);
+
+            match regex {
+                Ok(regex) => Regex::Rust(regex),
+                Err(e) => {
+                    let help = Some(format!("The compiled regex is {pattern:?}"));
+                    errors.push(Diagnostic::ad_hoc(Severity::Error, None, e.to_string(), help));
+                    return;
+                }
+            }
+        }
+        _ => panic!("Unsupported flavor"),
     };
 
     let tests = parsed.extract_tests_ref();
@@ -54,7 +69,7 @@ pub(crate) fn run_tests(
 }
 
 fn check_test_match(regex: &Regex, test_case: &TestCaseMatch, errors: &mut Vec<Diagnostic>) {
-    let result = regex.captures(test_case.literal.content.as_bytes());
+    let result = regex.captures(&test_case.literal.content);
     match result {
         Ok(Some(captures)) => {
             if captures[0].len() != test_case.literal.content.len() {
@@ -107,7 +122,7 @@ fn check_all_test_matches(
     errors: &mut Vec<Diagnostic>,
 ) {
     let captures_iter = regex
-        .captures_iter(test_case.literal.content.as_bytes())
+        .captures_iter(&test_case.literal.content)
         .map(Some)
         .chain(std::iter::repeat_with(|| None));
     let expected_iter = test_case.matches.iter().map(Some).chain(std::iter::repeat(None));
@@ -174,7 +189,7 @@ fn check_all_test_matches(
 }
 
 fn check_test_reject(regex: &Regex, test_case: &TestCaseReject, errors: &mut Vec<Diagnostic>) {
-    let result = regex.captures(test_case.literal.content.as_bytes());
+    let result = regex.captures(&test_case.literal.content);
     match result {
         Ok(Some(captures)) => {
             let is_exact = captures[0].len() == test_case.literal.content.len();
@@ -202,3 +217,97 @@ fn check_test_reject(regex: &Regex, test_case: &TestCaseReject, errors: &mut Vec
         }
     }
 }
+
+enum Regex {
+    Pcre(PcreRegex),
+    Rust(RustRegex),
+}
+
+impl Regex {
+    fn as_str(&self) -> &str {
+        match self {
+            Regex::Pcre(regex) => regex.as_str(),
+            Regex::Rust(regex) => regex.as_str(),
+        }
+    }
+
+    fn captures<'a>(&'a self, subject: &'a str) -> Result<Option<Captures<'a>>, pcre2::Error> {
+        match self {
+            Regex::Pcre(regex) => regex.captures(subject.as_bytes()).map(|o| o.map(Captures::Pcre)),
+            Regex::Rust(regex) => Ok(regex.captures(subject).map(Captures::Rust)),
+        }
+    }
+
+    fn captures_iter<'r, 's>(&'r self, subject: &'s str) -> CaptureMatches<'r, 's> {
+        match self {
+            Regex::Pcre(regex) => CaptureMatches::Pcre(regex.captures_iter(subject.as_bytes())),
+            Regex::Rust(regex) => CaptureMatches::Rust(regex.captures_iter(subject)),
+        }
+    }
+}
+
+enum Captures<'a> {
+    Pcre(pcre2::bytes::Captures<'a>),
+    Rust(regex::Captures<'a>),
+}
+
+impl Captures<'_> {
+    fn name(&self, name: &str) -> Option<Match<'_>> {
+        match self {
+            Captures::Pcre(captures) => captures.name(name).map(Match::Pcre),
+            Captures::Rust(captures) => captures.name(name).map(Match::Rust),
+        }
+    }
+
+    fn get(&self, index: usize) -> Option<Match<'_>> {
+        match self {
+            Captures::Pcre(captures) => captures.get(index).map(Match::Pcre),
+            Captures::Rust(captures) => captures.get(index).map(Match::Rust),
+        }
+    }
+}
+
+impl Index<usize> for Captures<'_> {
+    type Output = [u8];
+
+    fn index(&self, index: usize) -> &Self::Output {
+        match self {
+            Captures::Pcre(captures) => &captures[index],
+            Captures::Rust(captures) => captures[index].as_bytes(),
+        }
+    }
+}
+
+enum Match<'s> {
+    Pcre(pcre2::bytes::Match<'s>),
+    Rust(regex::Match<'s>),
+}
+
+impl Match<'_> {
+    fn as_bytes(&self) -> &[u8] {
+        match self {
+            Match::Pcre(mat) => mat.as_bytes(),
+            Match::Rust(mat) => mat.as_str().as_bytes(),
+        }
+    }
+}
+
+enum CaptureMatches<'r, 's> {
+    Pcre(pcre2::bytes::CaptureMatches<'r, 's>),
+    Rust(regex::CaptureMatches<'r, 's>),
+}
+
+impl<'s> Iterator for CaptureMatches<'_, 's> {
+    type Item = Result<Captures<'s>, pcre2::Error>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self {
+            CaptureMatches::Pcre(capture_matches) => {
+                capture_matches.next().map(|r| r.map(Captures::Pcre))
+            }
+            CaptureMatches::Rust(capture_matches) => {
+                capture_matches.next().map(|c| Ok(Captures::Rust(c)))
+            }
+        }
+    }
+}
diff --git a/pomsky-bin/src/testing.rs b/pomsky-bin/src/testing.rs
new file mode 100644
index 0000000..88795bf
--- /dev/null
+++ b/pomsky-bin/src/testing.rs
@@ -0,0 +1,243 @@
+use std::{path::Path, process::exit, time::Instant};
+
+use helptext::text;
+use pomsky::options::RegexFlavor;
+
+use crate::{
+    args::{CompileOptions, GlobalOptions, Input, RegexEngine, TestOptions},
+    format::Logger,
+    CompilationResult,
+};
+
+pub(crate) struct TestDirectoryResult {
+    pub(crate) total: usize,
+    pub(crate) failed: usize,
+    pub(crate) results: Vec<CompilationResult>,
+}
+
+pub(crate) fn test(logger: &Logger, args: GlobalOptions, test_args: TestOptions) {
+    let (test_engine, flavor) = match (args.flavor, test_args.engine) {
+        (None, None) => {
+            logger.error().println("No regex engine specified");
+            exit(2);
+        }
+        (None, Some(engine)) => match engine {
+            RegexEngine::Pcre2 => (engine, RegexFlavor::Pcre),
+            RegexEngine::Rust => (engine, RegexFlavor::Rust),
+        },
+        (Some(flavor), None) => match flavor {
+            RegexFlavor::Pcre => (RegexEngine::Pcre2, flavor),
+            RegexFlavor::Rust => (RegexEngine::Rust, flavor),
+            _ => {
+                logger
+                    .error()
+                    .println(format_args!("No supported regex engine for the {flavor:?} flavor"));
+                exit(2);
+            }
+        },
+        (Some(flavor), Some(engine)) => (engine, flavor),
+    };
+
+    let args = GlobalOptions { flavor: Some(flavor), ..args };
+    let compile_args = CompileOptions {
+        input: Input::File(test_args.path),
+        no_new_line: false,
+        test: Some(test_engine),
+        in_test_suite: true,
+    };
+
+    let Input::File(path) = &compile_args.input else { unreachable!() };
+
+    let Ok(current_dir) = std::env::current_dir() else {
+        logger.error().println("Could not get current directory");
+        exit(3);
+    };
+    let path = if path.is_relative() { current_dir.join(path) } else { path.to_owned() };
+    let Ok(metadata) = std::fs::metadata(&path) else {
+        logger.error().println("Could not get path metadata");
+        exit(3);
+    };
+
+    if metadata.is_dir() {
+        let start = Instant::now();
+
+        let TestDirectoryResult { total, failed, results } =
+            test_directory(logger, &path, &current_dir, &args, &compile_args);
+
+        if total == 0 && !args.json {
+            if test_args.pass_with_no_tests {
+                exit(0);
+            } else {
+                logger.error().println("no `*.pomsky` files found to test");
+                exit(5);
+            }
+        }
+
+        logger.emptyln();
+
+        let time = start.elapsed();
+        let time_fmt = format!("{time:.2?}");
+        if failed > 0 {
+            logger.basic().fmtln(text![
+                "test result: " R!{&failed.to_string()} R!" pomsky file(s) failed" ", "
+                {&total.to_string()} " files tested in " {&time_fmt}
+            ]);
+        } else {
+            logger.basic().fmtln(text![
+                "test result: " G!"ok" ", "
+                {&total.to_string()} " files tested in " {&time_fmt}
+            ]);
+        }
+        print_json_test_result(args.json, &results);
+    } else if metadata.is_file() {
+        let mut results = Vec::new();
+        let mut failed = 0;
+        test_single(logger, &path, &current_dir, &args, &compile_args, &mut results, &mut failed);
+        print_json_test_result(args.json, &results);
+    } else {
+        logger.error().println(format_args!(
+            "expected file or directory, but `{}` is neither",
+            path.display()
+        ));
+        exit(3);
+    }
+}
+
+fn test_directory(
+    logger: &Logger,
+    path: &Path,
+    current_dir: &Path,
+    args: &GlobalOptions,
+    compile_args: &CompileOptions,
+) -> TestDirectoryResult {
+    let mut total = 0;
+    let mut failed = 0;
+    let mut results = Vec::new();
+
+    for entry in ignore::WalkBuilder::new(path)
+        .follow_links(true)
+        .filter_entry(is_dir_or_pomsky_file)
+        .build()
+    {
+        if let Ok(entry) = entry.map_err(|d| handle_walk_error(d, logger, current_dir)) {
+            if entry.file_type().is_some_and(|ty| ty.is_file()) {
+                total += 1;
+
+                let path = entry.path();
+                test_single(
+                    logger,
+                    path,
+                    current_dir,
+                    args,
+                    compile_args,
+                    &mut results,
+                    &mut failed,
+                );
+            }
+        };
+    }
+
+    TestDirectoryResult { total, failed, results }
+}
+
+fn test_single(
+    logger: &Logger,
+    path: &Path,
+    current_dir: &Path,
+    args: &GlobalOptions,
+    compile_args: &CompileOptions,
+    results: &mut Vec<CompilationResult>,
+    failed: &mut usize,
+) {
+    match std::fs::read_to_string(path) {
+        Ok(input) => {
+            logger.basic().fmt(text![C!"testing " {&show_relative(path, current_dir)} " ... "]);
+            let result = super::compile(Some(path), &input, compile_args, args);
+            if !result.success {
+                *failed += 1;
+            }
+            if args.json {
+                results.push(result);
+            } else {
+                result.output(
+                    logger,
+                    args.json,
+                    !compile_args.no_new_line,
+                    compile_args.in_test_suite,
+                    &input,
+                );
+            }
+        }
+        Err(error) => {
+            logger.error().println(error);
+            exit(3);
+        }
+    }
+}
+
+fn is_dir_or_pomsky_file(entry: &ignore::DirEntry) -> bool {
+    let Some(ty) = entry.file_type() else { return false };
+    if ty.is_dir() {
+        return true;
+    }
+    let Some(ext) = entry.path().extension() else { return false };
+    ext == "pomsky"
+}
+
+fn handle_walk_error(error: ignore::Error, logger: &Logger, current_dir: &Path) {
+    match error {
+        ignore::Error::Partial(errors) => {
+            for error in errors {
+                handle_walk_error(error, logger, current_dir);
+            }
+        }
+        ignore::Error::WithLineNumber { line, err } => {
+            handle_walk_error(*err, logger, current_dir);
+            logger.basic().fmtln(text!["    at line " C!{&line.to_string()}]);
+        }
+        ignore::Error::WithPath { path, err } => {
+            handle_walk_error(*err, logger, current_dir);
+            logger.basic().fmtln(text!["    at path " C!{&path.display().to_string()}]);
+        }
+        ignore::Error::WithDepth { depth, err } => {
+            handle_walk_error(*err, logger, current_dir);
+            logger.basic().fmtln(text!["    at depth " C!{&depth.to_string()}]);
+        }
+        ignore::Error::Loop { ancestor, child } => {
+            let ancestor = ancestor.strip_prefix(current_dir).unwrap_or(&ancestor);
+            let child = child.canonicalize().unwrap_or(child);
+
+            logger.error().println("file system loop detected!");
+            logger.basic().fmtln(text!["    ancestor: " C!{&ancestor.display().to_string()}]);
+            logger.basic().fmtln(text!["    child: " C!{&child.display().to_string()}]);
+        }
+        ignore::Error::Io(error) => {
+            logger.error().println(error);
+        }
+        ignore::Error::Glob { glob, err } => {
+            logger.error().println(err);
+            if let Some(glob) = glob {
+                logger.basic().fmtln(text!["    glob: " C!{&glob}]);
+            }
+        }
+        ignore::Error::UnrecognizedFileType(file_type) => {
+            logger.error().println(format_args!("file type `{file_type}` not recognized"));
+        }
+        ignore::Error::InvalidDefinition => {
+            logger.error().println("file type definition could not be parsed");
+        }
+    }
+}
+
+pub(crate) fn print_json_test_result(json: bool, results: &[CompilationResult]) {
+    if json {
+        match serde_json::to_string(&results) {
+            Ok(string) => println!("{string}"),
+            Err(e) => eprintln!("{e}"),
+        }
+    }
+}
+
+fn show_relative(path: &Path, relative_to: &Path) -> String {
+    path.strip_prefix(relative_to).unwrap_or(path).display().to_string()
+}
diff --git a/pomsky-bin/tests/e2e.rs b/pomsky-bin/tests/e2e.rs
index bbbf84b..c2223da 100644
--- a/pomsky-bin/tests/e2e.rs
+++ b/pomsky-bin/tests/e2e.rs
@@ -69,14 +69,14 @@ impl PredicateReflection for Output {
 const ERROR: &str = "error: ";
 const ERROR_COLOR: &str = "\u{1b}[31;1merror\u{1b}[0m: ";
 const USAGE: &str = r#"
-USAGE:
+Usage:
     pomsky [OPTIONS] <INPUT>
     pomsky [OPTIONS] --path <PATH>
     command | pomsky [OPTIONS]
 For more information try `--help`
 "#;
 const USAGE_COLOR: &str = "\n\
-\u{1b}[33mUSAGE\u{1b}[0m:\n    \
+\u{1b}[4;1mUsage\u{1b}[0m:\n    \
     pomsky [OPTIONS] <INPUT>\n    \
     pomsky [OPTIONS] --path <PATH>\n    \
     command | pomsky [OPTIONS]\n\
@@ -114,18 +114,18 @@ Compile pomsky expressions, a new regular expression language
 
 Use `-h` for short descriptions and `--help` for more details.
 
-USAGE:
+Usage:
     pomsky [OPTIONS] <INPUT>
     pomsky [OPTIONS] --path <PATH>
     command | pomsky [OPTIONS]
 
-SUBCOMMANDS:
+Subcommands:
     pomsky test  Run unit tests in pomsky expressions
 
-ARGS:
+Args:
     <INPUT>  Pomsky expression to compile
 
-OPTIONS:
+Options:
         --allowed-features <FEATURE>...  Comma-separated list of allowed features [default: all enabled]
     -f, --flavor <FLAVOR>                Regex flavor [default: `pcre`]
     -h, --help                           Print help information
@@ -143,7 +143,7 @@ fn unknown_flag() {
     cmd.assert().failure().stderr(format!(
         "{ERROR}invalid option '-k'
 
-USAGE:
+Usage:
     pomsky [OPTIONS] <INPUT>
     pomsky [OPTIONS] --path <PATH>
     command | pomsky [OPTIONS]
@@ -238,14 +238,14 @@ fn arg_input_with_flavor() {
 fn invalid_flavor() {
     let mut cmd = command(&[":foo('test')+", "-f", "jsx"]);
     cmd.assert().failure().stderr(format!(
-        "error: 'jsx' isn't a valid flavor
+        "error: `jsx` isn't a valid flavor
 possible values: pcre, python, java, javascript, dotnet, ruby, rust
 {USAGE}"
     ));
 
     let mut cmd = command_color(&[":foo('test')+", "-f", "jsx"]);
     cmd.assert().failure().stderr(format!(
-        "{ERROR_COLOR}'jsx' isn't a valid flavor
+        "{ERROR_COLOR}`jsx` isn't a valid flavor
 possible values: pcre, python, java, javascript, dotnet, ruby, rust
 {USAGE_COLOR}"
     ));
@@ -255,7 +255,7 @@ possible values: pcre, python, java, javascript, dotnet, ruby, rust
 fn flavor_used_multiple_times() {
     let mut cmd = command(&[":foo('test')+", "-fjs", "-f", "rust"]);
     cmd.assert().failure().stderr(format!(
-        "error: The argument '--flavor' was provided more than once, but cannot be used multiple times
+        "error: The argument `--flavor` was provided more than once, but cannot be used multiple times
 {USAGE}"
     ));
 }
@@ -307,7 +307,7 @@ fn no_newline() {
 
     let mut cmd = command(&["-n", ":foo('test')+", "-n"]);
     cmd.assert().failure().stderr(format!(
-        r#"error: The argument '--no-new-line' was provided more than once, but cannot be used multiple times
+        r#"error: The argument `--no-new-line` was provided more than once, but cannot be used multiple times
 {USAGE}"#
     ));
 }
@@ -442,12 +442,12 @@ fn json_output_errors() {
                     fixes: vec![],
                     visual: String::from(
                         "error P0100(syntax):
-  x Expected character class, string, code point, Unicode property or `]`
-   ,----
- 1 | [.][^test]
-   :  |
-   :  `-- error occurred here
-   `----
+  × Expected character class, string, code point, Unicode property or `]`
+   ╭────
+ 1 │ [.][^test]
+   ·  ┬
+   ·  ╰── error occurred here
+   ╰────
 ",
                     ),
                 }],
diff --git a/pomsky-lib/src/diagnose/diagnostics.rs b/pomsky-lib/src/diagnose/diagnostics.rs
index 228db56..23cba72 100644
--- a/pomsky-lib/src/diagnose/diagnostics.rs
+++ b/pomsky-lib/src/diagnose/diagnostics.rs
@@ -244,7 +244,7 @@ impl Diagnostic {
             fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
                 miette::GraphicalReportHandler::new()
                     .with_width(100)
-                    .with_theme(GraphicalTheme::none())
+                    .with_theme(GraphicalTheme::unicode_nocolor())
                     .render_report(f, &self.0)
             }
         }