feat add admonition support for GitHub/Obsidian and fence syntax

.markdownlint.json

···
 {
     "MD033": false,
-    "MD013": false
+    "MD013": false,
+    "MD028": false
 }

.vscode/settings.json

···
+{
+    "rust-analyzer.check.command": "clippy"
+}

Cargo.lock

···
  "thiserror",
  "toml",
  "tracing",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]
···
  "lantern-core",
  "owo-colors",
  "ratatui",
+ "unicode-width 0.2.0",
 ]
 
 [[package]]

README.md

···
 
 ### Navigation
 
-| Key          | Action              |
-| ------------ | ------------------- |
+| Key           | Action              |
+| ------------- | ------------------- |
 | `→`, `j`, `n` | Next slide          |
 | `←`, `k`, `p` | Previous slide      |
-| `1-9`        | Jump to slide       |
-| `q`          | Quit                |
+| `q`           | Quit                |
 
 ## Design Principles
 

ROADMAP.md

···
-# Slides
+# lantern
 
 ## Plumbing
 
-__Objective:__ Establish a clean, testable core with `clap` and a minimal `ratatui` loop.
+__Outcome:__ initialize workspace with clap CLI and ratatui terminal setup
 
-| Task                         | Description                                                                    | Key Crates                  |
-| ---------------------------- | ------------------------------------------------------------------------------ | --------------------------- |
-| __✓ Project Scaffolding__    | Initialize workspace with `slides-core`, `slides-cli`, and `slides-ui` crates. | `cargo`, `just`, `clap`     |
-|                              | Use `cargo-generate` and a `justfile` for scripts.                             |                             |
-| __✓ CLI Definition__         | Implement root command `slides` with subcommands:                              | `clap`[^1]                  |
-|                              | • `present` (TUI)                                                              |                             |
-|                              | • `print` (stdout)                                                             |                             |
-|                              | • `init` (scaffold deck)                                                       |                             |
-|                              | • `check` (lint slides).                                                       |                             |
-| __✓ Logging & Colors__       | Integrate structured logs via `tracing`.                                       | `owo-colors`[^2], `tracing` |
-|                              | Use __owo-colors__ for color abstraction (no dynamic dispatch).                |                             |
-| __✓ Terminal & Event Setup__ | Configure alternate screen, raw mode, input loop, resize handler.              | `crossterm`[^3], `ratatui`  |
-| __CI/CD + Tooling__          | Setup `cargo fmt`, `clippy`, `test`, and `cross` matrix CI.                    | GitHub Actions              |
+Scaffolded multi-crate workspace with present, print, init, and check subcommands, integrated structured logging via tracing, and configured alternate screen with crossterm input handling.
 
-## Data Model (Parser & Slides)
+## Data Model
 
-__Objective:__ Parse markdown documents into a rich `Slide` struct.
-
-| Task                     | Description                                                     | Key Crates           |
-| ------------------------ | --------------------------------------------------------------- | -------------------- |
-| __✓ Parser Core__        | Split files on `---` separators.                                | `pulldown-cmark`[^4] |
-|                          | Detect title blocks, lists, and code fences.                    |                      |
-|                          | Represent as `Vec<Slide>`.                                      |                      |
-| __✓ Slide Model__        | Define structs: `Slide`, `Block`, `TextSpan`, `CodeBlock`, etc. | Internal             |
-| __✓ Metadata Parsing__   | Optional front matter (YAML/TOML) for theme, author, etc.       | `serde_yml`[^5]      |
-| __✓ Error & Validation__ | Provide friendly parser errors with file/line info.             | `thiserror`[^6]      |
-| __✓ Basic CLI UX__       | `lantern present file.md` runs full TUI.                        | `clap`               |
-|                          | `lantern print` renders to stdout with width constraint.        |                      |
+__Outcome:__  implement markdown parser with metadata and validation
+Built pulldown-cmark-based parser that splits on --- separators into Vec<Slide>, supports YAML/TOML front matter, and provides friendly error messages with file/line context.
 
 ## Rendering & Navigation
 
···
 
 | Task                 | Description                                                        | Key Crates                   |
 | -------------------- | ------------------------------------------------------------------ | ---------------------------- |
-| __Config Discovery__ | Read from `$XDG_CONFIG_HOME/slides/config.toml` for defaults.      | `dirs`, `serde`              |
+| __CI/CD + Tooling__  | Setup `cargo fmt`, `clippy`, `test`, and `cross` matrix CI         | GitHub Actions               |
+| __Config Discovery__ | Read from `$XDG_CONFIG_HOME/lantern/config.toml` for defaults      | `dirs`, `serde`              |
 | __Theme Registry__   | Built-in theme manifest (e.g., `onedark`, `solarized`, `plain`).   | Internal                     |
 | __Release__          | Tag `v1.0.0-rc.1` with changelog and binaries for major platforms. | `cargo-dist`, GitHub Actions |
 
···
 | __Deterministic Seeds__  | Add `--seed` for any animations (typing jitter, cursor blink timing) to keep exports repeatable. | internal `timeline`          |
 | __Preset Profiles__      | Presets like `social-card`, `doc-screenshot`, `talk-demo` mapping to resolution + theme.         | internal profile registry    |
 
-[^1]: <https://docs.rs/clap/latest/clap/>
-[^2]: <https://docs.rs/owo-colors/latest/owo_colors/>
-[^3]: <https://docs.rs/crossterm/latest/crossterm/>
-[^4]: <https://docs.rs/pulldown-cmark/latest/pulldown_cmark/>
-[^5]: <https://docs.rs/serde_yml>
-[^6]: <https://docs.rs/thiserror>
 [^7]: <https://docs.rs/ratatui/latest/ratatui/>
 [^8]: <https://docs.rs/syntect/latest/syntect/>
 [^9]: <https://docs.rs/notify/latest/notify/>

core/Cargo.toml

···
 serde_yml = "0.0.12"
 syntect = "5"
 terminal-colorsaurus = "1.0.1"
-thiserror = "2.0.17"
-toml = "0.9.7"
+thiserror = "2"
+toml = "0.9"
+unicode-width = "0.2"

core/src/highlighter.rs

···
             ui_title: Color::new(200, 200, 200),
             ui_text: Color::new(220, 220, 220),
             ui_background: Color::new(30, 30, 30),
+            admonition_note: Color::new(100, 150, 200),
+            admonition_tip: Color::new(150, 100, 200),
+            admonition_warning: Color::new(200, 150, 50),
+            admonition_danger: Color::new(200, 50, 50),
+            admonition_success: Color::new(50, 200, 100),
+            admonition_info: Color::new(100, 200, 200),
         };
 
         assert!(is_dark_theme(&dark_theme));
···
             ui_title: Color::new(40, 40, 40),
             ui_text: Color::new(20, 20, 20),
             ui_background: Color::new(250, 250, 250),
+            admonition_note: Color::new(0, 100, 200),
+            admonition_tip: Color::new(100, 0, 200),
+            admonition_warning: Color::new(200, 100, 0),
+            admonition_danger: Color::new(200, 0, 0),
+            admonition_success: Color::new(0, 150, 50),
+            admonition_info: Color::new(0, 150, 200),
         };
 
         assert!(!is_dark_theme(&light_theme));

core/src/parser.rs

···
     sections.into_iter().map(parse_slide).collect()
 }
 
+/// Preprocess markdown to convert admonition syntax to a format we can parse
+///
+/// Converts both GitHub/Obsidian syntax (`> [!NOTE]`) and fence syntax (`:::note`)
+/// into a special HTML-like format that we can detect in the event stream
+fn preprocess_admonitions(markdown: &str) -> String {
+    let mut result = String::new();
+    let lines: Vec<&str> = markdown.lines().collect();
+    let mut i = 0;
+
+    while i < lines.len() {
+        let line = lines[i];
+        let trimmed = line.trim();
+
+        if let Some(admonition_type) = parse_fence_admonition(trimmed) {
+            result.push_str(&format!("<admonition type=\"{admonition_type}\">\n"));
+            i += 1;
+            while i < lines.len() {
+                let content_line = lines[i];
+                if content_line.trim() == ":::" {
+                    result.push_str("</admonition>\n");
+                    i += 1;
+                    break;
+                }
+                result.push_str(content_line);
+                result.push('\n');
+                i += 1;
+            }
+            continue;
+        }
+
+        if trimmed.starts_with('>') {
+            if let Some((admonition_type, title)) = parse_blockquote_admonition(trimmed) {
+                result.push_str(&format!("<admonition type=\"{admonition_type}\""));
+                if let Some(t) = title {
+                    result.push_str(&format!(" title=\"{t}\""));
+                }
+                result.push_str(">\n");
+                i += 1;
+
+                while i < lines.len() {
+                    let next_line = lines[i];
+                    let next_trimmed = next_line.trim();
+                    if next_trimmed.starts_with('>') {
+                        let content = next_trimmed.strip_prefix('>').unwrap_or("").trim();
+                        if !content.is_empty() {
+                            result.push_str(content);
+                            result.push('\n');
+                        }
+                        i += 1;
+                    } else {
+                        break;
+                    }
+                }
+                result.push_str("</admonition>\n");
+                continue;
+            }
+        }
+
+        result.push_str(line);
+        result.push('\n');
+        i += 1;
+    }
+
+    result
+}
+
+/// Parse fence-style admonition: `:::note` or `:::warning Title`
+fn parse_fence_admonition(line: &str) -> Option<String> {
+    let trimmed = line.trim();
+    if !trimmed.starts_with(":::") {
+        return None;
+    }
+
+    let content = trimmed.strip_prefix(":::").unwrap_or("").trim();
+    if content.is_empty() {
+        return None;
+    }
+
+    let parts: Vec<&str> = content.splitn(2, ' ').collect();
+    let admonition_type = parts[0].to_lowercase();
+
+    if admonition_type.is_empty() { None } else { Some(admonition_type) }
+}
+
+/// Parse blockquote-style admonition: `> [!NOTE]` or `> [!TIP] Custom Title`
+fn parse_blockquote_admonition(line: &str) -> Option<(String, Option<String>)> {
+    let content = line.trim().strip_prefix('>')?.trim();
+
+    if !content.starts_with("[!") {
+        return None;
+    }
+
+    let rest = content.strip_prefix("[!")?;
+    let close_bracket = rest.find(']')?;
+    let admonition_type = rest[..close_bracket].to_lowercase();
+
+    let title = rest[close_bracket + 1..].trim();
+    let title = if title.is_empty() { None } else { Some(title.to_string()) };
+
+    Some((admonition_type, title))
+}
+
+/// Parse HTML admonition tag: `<admonition type="note" title="Title">`
+fn parse_admonition_html_start(html: &str) -> Option<(AdmonitionType, Option<String>)> {
+    let html = html.trim();
+    if !html.starts_with("<admonition") {
+        return None;
+    }
+
+    let type_start = html.find("type=\"")?;
+    let type_value_start = type_start + 6;
+    let type_end = html[type_value_start..].find('"')? + type_value_start;
+    let admonition_type_str = &html[type_value_start..type_end];
+    let admonition_type = admonition_type_str.parse().ok()?;
+
+    let title = if let Some(title_start) = html.find("title=\"") {
+        let title_value_start = title_start + 7;
+        let title_end = html[title_value_start..].find('"')? + title_value_start;
+        Some(html[title_value_start..title_end].to_string())
+    } else {
+        None
+    };
+
+    Some((admonition_type, title))
+}
+
 /// Split markdown content on `---` separators
+///
+/// Ignores `---` inside fenced code blocks to avoid incorrect slide splits
 fn split_slides(markdown: &str) -> Vec<String> {
     let mut slides = Vec::new();
     let mut current = String::new();
+    let mut in_code_block = false;
 
     for line in markdown.lines() {
         let trimmed = line.trim();
-        if trimmed == "---" {
+
+        if trimmed.starts_with("```") || trimmed.starts_with("~~~") {
+            in_code_block = !in_code_block;
+        }
+
+        if trimmed == "---" && !in_code_block {
             if !current.trim().is_empty() {
                 slides.push(current);
                 current = String::new();
···
 
 /// Parse a single slide from markdown
 fn parse_slide(markdown: String) -> Result<Slide> {
+    let preprocessed = preprocess_admonitions(&markdown);
     let mut options = Options::empty();
     options.insert(Options::ENABLE_TABLES);
     options.insert(Options::ENABLE_STRIKETHROUGH);
-    let parser = Parser::new_ext(&markdown, options);
+    let parser = Parser::new_ext(&preprocessed, options);
     let mut blocks = Vec::new();
     let mut block_stack: Vec<BlockBuilder> = Vec::new();
     let mut current_style = TextStyle::default();
···
         match event {
             Event::Start(tag) => match tag {
                 Tag::Heading { level, .. } => {
-                    block_stack.push(BlockBuilder::Heading {
-                        level: level as u8,
-                        spans: Vec::new(),
-                    });
+                    block_stack.push(BlockBuilder::Heading { level: level as u8, spans: Vec::new() });
                 }
                 Tag::Paragraph => {
-                    block_stack.push(BlockBuilder::Paragraph {
-                        spans: Vec::new(),
-                    });
+                    block_stack.push(BlockBuilder::Paragraph { spans: Vec::new() });
                 }
                 Tag::CodeBlock(kind) => {
                     let language = match kind {
···
                         }
                         pulldown_cmark::CodeBlockKind::Indented => None,
                     };
-                    block_stack.push(BlockBuilder::Code {
-                        language,
-                        code: String::new(),
-                    });
+                    block_stack.push(BlockBuilder::Code { language, code: String::new() });
                 }
                 Tag::List(first) => {
                     block_stack.push(BlockBuilder::List {
···
             Event::End(tag_end) => match tag_end {
                 TagEnd::Heading(_) | TagEnd::Paragraph | TagEnd::CodeBlock => {
                     if let Some(builder) = block_stack.pop() {
-                        blocks.push(builder.build());
+                        let block = builder.build();
+                        if let Some(BlockBuilder::Admonition { blocks: adm_blocks, .. }) = block_stack.last_mut() {
+                            adm_blocks.push(block);
+                        } else {
+                            blocks.push(block);
+                        }
                     }
                 }
                 TagEnd::List(_) => {
                     if let Some(builder) = block_stack.pop() {
-                        blocks.push(builder.build());
+                        let block = builder.build();
+                        if let Some(BlockBuilder::Admonition { blocks: adm_blocks, .. }) = block_stack.last_mut() {
+                            adm_blocks.push(block);
+                        } else {
+                            blocks.push(block);
+                        }
                     }
                 }
                 TagEnd::BlockQuote(_) => {
                     if let Some(builder) = block_stack.pop() {
-                        blocks.push(builder.build());
+                        let block = builder.build();
+                        if let Some(BlockBuilder::Admonition { blocks: adm_blocks, .. }) = block_stack.last_mut() {
+                            adm_blocks.push(block);
+                        } else {
+                            blocks.push(block);
+                        }
                     }
                 }
                 TagEnd::Table => {
                     if let Some(builder) = block_stack.pop() {
-                        blocks.push(builder.build());
+                        let block = builder.build();
+                        if let Some(BlockBuilder::Admonition { blocks: adm_blocks, .. }) = block_stack.last_mut() {
+                            adm_blocks.push(block);
+                        } else {
+                            blocks.push(block);
+                        }
                     }
                 }
                 TagEnd::TableHead => {
-                    if let Some(BlockBuilder::Table {
-                        current_row,
-                        headers,
-                        in_header,
-                        ..
-                    }) = block_stack.last_mut()
-                    {
+                    if let Some(BlockBuilder::Table { current_row, headers, in_header, .. }) = block_stack.last_mut() {
                         if !current_row.is_empty() {
                             *headers = std::mem::take(current_row);
                         }
···
                     }
                 }
                 TagEnd::TableRow => {
-                    if let Some(BlockBuilder::Table {
-                        current_row,
-                        rows,
-                        ..
-                    }) = block_stack.last_mut()
-                    {
+                    if let Some(BlockBuilder::Table { current_row, rows, .. }) = block_stack.last_mut() {
                         if !current_row.is_empty() {
                             rows.push(std::mem::take(current_row));
                         }
                     }
                 }
                 TagEnd::TableCell => {
-                    if let Some(BlockBuilder::Table {
-                        current_cell,
-                        current_row,
-                        ..
-                    }) = block_stack.last_mut()
-                    {
+                    if let Some(BlockBuilder::Table { current_cell, current_row, .. }) = block_stack.last_mut() {
                         current_row.push(std::mem::take(current_cell));
                     }
                 }
                 TagEnd::Item => {
-                    if let Some(BlockBuilder::List {
-                        current_item, items, ..
-                    }) = block_stack.last_mut()
-                    {
+                    if let Some(BlockBuilder::List { current_item, items, .. }) = block_stack.last_mut() {
                         if !current_item.is_empty() {
-                            items.push(ListItem {
-                                spans: std::mem::take(current_item),
-                                nested: None,
-                            });
+                            items.push(ListItem { spans: std::mem::take(current_item), nested: None });
                         }
                     }
                 }
···
                 blocks.push(Block::Rule);
             }
 
+            Event::Html(html) => {
+                if let Some((admonition_type, title)) = parse_admonition_html_start(&html) {
+                    block_stack.push(BlockBuilder::Admonition { admonition_type, title, blocks: Vec::new() });
+                } else if html.trim().starts_with("</admonition>") {
+                    if let Some(builder) = block_stack.pop() {
+                        blocks.push(builder.build());
+                    }
+                } else if !block_stack.is_empty() {
+                    if let Some(BlockBuilder::Admonition { blocks: adm_blocks, .. }) = block_stack.last_mut() {
+                        let inner_markdown = html.to_string();
+                        let inner_options = Options::empty();
+                        let inner_parser = Parser::new_ext(&inner_markdown, inner_options);
+                        let mut inner_block_stack: Vec<BlockBuilder> = Vec::new();
+                        let inner_style = TextStyle::default();
+
+                        for inner_event in inner_parser {
+                            match inner_event {
+                                Event::Start(Tag::Paragraph) => {
+                                    inner_block_stack.push(BlockBuilder::Paragraph { spans: Vec::new() });
+                                }
+                                Event::Text(text) => {
+                                    if let Some(builder) = inner_block_stack.last_mut() {
+                                        builder.add_text(text.to_string(), &inner_style);
+                                    }
+                                }
+                                Event::End(TagEnd::Paragraph) => {
+                                    if let Some(builder) = inner_block_stack.pop() {
+                                        adm_blocks.push(builder.build());
+                                    }
+                                }
+                                _ => {}
+                            }
+                        }
+                    }
+                }
+            }
+
             _ => {}
         }
     }
···
         alignments: Vec<Alignment>,
         in_header: bool,
     },
+    Admonition {
+        admonition_type: AdmonitionType,
+        title: Option<String>,
+        blocks: Vec<Block>,
+    },
 }
 
 impl BlockBuilder {
···
         match self {
             Self::Heading { spans, .. } | Self::Paragraph { spans, .. } => {
                 if !text.is_empty() {
-                    spans.push(TextSpan {
-                        text,
-                        style: current_style.clone(),
-                    });
+                    spans.push(TextSpan { text, style: current_style.clone() });
                 }
             }
             Self::Code { code, .. } => {
···
             }
             Self::List { current_item, .. } => {
                 if !text.is_empty() {
-                    current_item.push(TextSpan {
-                        text,
-                        style: current_style.clone(),
-                    });
+                    current_item.push(TextSpan { text, style: current_style.clone() });
                 }
             }
             Self::Table { current_cell, .. } => {
                 if !text.is_empty() {
-                    current_cell.push(TextSpan {
-                        text,
-                        style: current_style.clone(),
-                    });
+                    current_cell.push(TextSpan { text, style: current_style.clone() });
                 }
             }
+            Self::Admonition { .. } => {}
             _ => {}
         }
     }
···
     fn add_code_span(&mut self, code: String) {
         match self {
             Self::Heading { spans, .. } | Self::Paragraph { spans, .. } => {
-                spans.push(TextSpan {
-                    text: code,
-                    style: TextStyle {
-                        code: true,
-                        ..Default::default()
-                    },
-                });
+                spans.push(TextSpan { text: code, style: TextStyle { code: true, ..Default::default() } });
             }
             Self::List { current_item, .. } => {
-                current_item.push(TextSpan {
-                    text: code,
-                    style: TextStyle {
-                        code: true,
-                        ..Default::default()
-                    },
-                });
+                current_item.push(TextSpan { text: code, style: TextStyle { code: true, ..Default::default() } });
             }
             Self::Table { current_cell, .. } => {
-                current_cell.push(TextSpan {
-                    text: code,
-                    style: TextStyle {
-                        code: true,
-                        ..Default::default()
-                    },
-                });
+                current_cell.push(TextSpan { text: code, style: TextStyle { code: true, ..Default::default() } });
             }
+            Self::Admonition { .. } => {}
             _ => {}
         }
     }
···
             Self::Code { language, code } => Block::Code(CodeBlock { language, code }),
             Self::List { ordered, items, .. } => Block::List(List { ordered, items }),
             Self::BlockQuote { blocks } => Block::BlockQuote { blocks },
-            Self::Table {
-                headers,
-                rows,
-                alignments,
-                ..
-            } => Block::Table(Table {
-                headers,
-                rows,
-                alignments,
-            }),
+            Self::Table { headers, rows, alignments, .. } => Block::Table(Table { headers, rows, alignments }),
+            Self::Admonition { admonition_type, title, blocks } => {
+                Block::Admonition(Admonition { admonition_type, title, blocks })
+            }
         }
     }
 }
···
     }
 
     #[test]
+    fn split_slides_ignores_separator_in_code_block() {
+        let markdown = r#"# Slide 1
+
+```markdown
+---
+```
+
+Content after code block
+
+---
+
+# Slide 2"#;
+        let slides = split_slides(markdown);
+        assert_eq!(slides.len(), 2);
+        assert!(slides[0].contains("Slide 1"));
+        assert!(slides[0].contains("---"));
+        assert!(slides[0].contains("Content after code block"));
+        assert!(slides[1].contains("Slide 2"));
+    }
+
+    #[test]
     fn parse_heading() {
         let slides = parse_slides("# Hello World").unwrap();
         assert_eq!(slides.len(), 1);
···
             }
             _ => panic!("Expected table"),
         }
+    }
+
+    #[test]
+    fn preprocess_github_admonition() {
+        let markdown = r#"> [!NOTE]
+> This is a note"#;
+        let preprocessed = preprocess_admonitions(markdown);
+        assert!(preprocessed.contains("<admonition"));
+        assert!(preprocessed.contains("type=\"note\""));
+        assert!(preprocessed.contains("</admonition>"));
+
+        let mut options = Options::empty();
+        options.insert(Options::ENABLE_TABLES);
+        options.insert(Options::ENABLE_STRIKETHROUGH);
+        let parser = Parser::new_ext(&preprocessed, options);
+        let events: Vec<_> = parser.collect();
+
+        let has_html = events.iter().any(|e| matches!(e, Event::Html(_)));
+        assert!(has_html, "Should have HTML events");
+    }
+
+    #[test]
+    fn parse_github_admonition_note() {
+        let markdown = r#"> [!NOTE]
+> This is a note"#;
+        let slides = parse_slides(markdown).unwrap();
+        assert_eq!(slides.len(), 1);
+
+        match &slides[0].blocks[0] {
+            Block::Admonition(admonition) => {
+                assert_eq!(admonition.admonition_type, AdmonitionType::Note);
+                assert_eq!(admonition.title, None);
+                assert_eq!(admonition.blocks.len(), 1);
+            }
+            _ => panic!("Expected admonition, got: {:?}", slides[0].blocks[0]),
+        }
+    }
+
+    #[test]
+    fn parse_github_admonition_with_title() {
+        let markdown = r#"> [!WARNING] Custom Warning
+> Be careful!"#;
+        let slides = parse_slides(markdown).unwrap();
+
+        match &slides[0].blocks[0] {
+            Block::Admonition(admonition) => {
+                assert_eq!(admonition.admonition_type, AdmonitionType::Warning);
+                assert_eq!(admonition.title, Some("Custom Warning".to_string()));
+                assert_eq!(admonition.blocks.len(), 1);
+            }
+            _ => panic!("Expected admonition"),
+        }
+    }
+
+    #[test]
+    fn parse_fence_admonition() {
+        let markdown = r#":::tip
+This is a helpful tip
+:::"#;
+        let slides = parse_slides(markdown).unwrap();
+        assert_eq!(slides.len(), 1);
+
+        match &slides[0].blocks[0] {
+            Block::Admonition(admonition) => {
+                assert_eq!(admonition.admonition_type, AdmonitionType::Tip);
+                assert_eq!(admonition.blocks.len(), 1);
+            }
+            _ => panic!("Expected admonition"),
+        }
+    }
+
+    #[test]
+    fn parse_admonition_danger_alias() {
+        let markdown = r#"> [!DANGER]
+> Dangerous content"#;
+        let slides = parse_slides(markdown).unwrap();
+
+        match &slides[0].blocks[0] {
+            Block::Admonition(admonition) => {
+                assert_eq!(admonition.admonition_type, AdmonitionType::Danger);
+            }
+            _ => panic!("Expected admonition"),
+        }
+    }
+
+    #[test]
+    fn admonition_type_from_str_note() {
+        assert_eq!("note".parse::<AdmonitionType>(), Ok(AdmonitionType::Note));
+        assert_eq!("NOTE".parse::<AdmonitionType>(), Ok(AdmonitionType::Note));
+    }
+
+    #[test]
+    fn admonition_type_from_str_tip_alias() {
+        assert_eq!("tip".parse::<AdmonitionType>(), Ok(AdmonitionType::Tip));
+        assert_eq!("hint".parse::<AdmonitionType>(), Ok(AdmonitionType::Tip));
+    }
+
+    #[test]
+    fn admonition_type_from_str_warning_aliases() {
+        assert_eq!("warning".parse::<AdmonitionType>(), Ok(AdmonitionType::Warning));
+        assert_eq!("caution".parse::<AdmonitionType>(), Ok(AdmonitionType::Warning));
+        assert_eq!("attention".parse::<AdmonitionType>(), Ok(AdmonitionType::Warning));
+    }
+
+    #[test]
+    fn admonition_type_from_str_invalid() {
+        assert!("invalid".parse::<AdmonitionType>().is_err());
+        assert!("".parse::<AdmonitionType>().is_err());
     }
 }

core/src/printer.rs

···
 use crate::highlighter;
 use crate::slide::{Block, CodeBlock, List, Table, TextSpan, TextStyle};
 use crate::theme::ThemeColors;
+use owo_colors::OwoColorize;
+use unicode_width::UnicodeWidthChar;
 
 /// Print slides to stdout with formatted output
 ///
···
         }
         Block::Table(table) => {
             print_table(writer, table, theme, width)?;
+        }
+        Block::Admonition(admonition) => {
+            print_admonition(writer, admonition, theme, width, indent)?;
         }
     }
 
···
     Ok(())
 }
 
+/// Print an admonition with icon, colored border, and title
+fn print_admonition<W: std::io::Write>(
+    writer: &mut W, admonition: &crate::slide::Admonition, theme: &ThemeColors, width: usize, indent: usize,
+) -> std::io::Result<()> {
+    use crate::slide::AdmonitionType;
+
+    let (icon, color, default_title) = match admonition.admonition_type {
+        AdmonitionType::Note => ("\u{24D8}", &theme.admonition_note, "Note"),
+        AdmonitionType::Tip => ("\u{1F4A1}", &theme.admonition_tip, "Tip"),
+        AdmonitionType::Important => ("\u{2757}", &theme.admonition_tip, "Important"),
+        AdmonitionType::Warning => ("\u{26A0}", &theme.admonition_warning, "Warning"),
+        AdmonitionType::Caution => ("\u{26A0}", &theme.admonition_warning, "Caution"),
+        AdmonitionType::Danger => ("\u{26D4}", &theme.admonition_danger, "Danger"),
+        AdmonitionType::Error => ("\u{2717}", &theme.admonition_danger, "Error"),
+        AdmonitionType::Info => ("\u{24D8}", &theme.admonition_info, "Info"),
+        AdmonitionType::Success => ("\u{2713}", &theme.admonition_success, "Success"),
+        AdmonitionType::Question => ("?", &theme.admonition_info, "Question"),
+        AdmonitionType::Example => ("\u{25B8}", &theme.admonition_success, "Example"),
+        AdmonitionType::Quote => ("\u{201C}", &theme.admonition_info, "Quote"),
+        AdmonitionType::Abstract => ("\u{00A7}", &theme.admonition_note, "Abstract"),
+        AdmonitionType::Todo => ("\u{2610}", &theme.admonition_info, "Todo"),
+        AdmonitionType::Bug => ("\u{1F41B}", &theme.admonition_danger, "Bug"),
+        AdmonitionType::Failure => ("\u{2717}", &theme.admonition_danger, "Failure"),
+    };
+
+    let title = admonition.title.as_deref().unwrap_or(default_title);
+    let indent_str = " ".repeat(indent);
+    let box_width = width.saturating_sub(indent);
+
+    let top_border = "\u{256D}".to_string() + &"\u{2500}".repeat(box_width.saturating_sub(2)) + "\u{256E}";
+    writeln!(writer, "{}{}", indent_str, color.to_owo_color(&top_border))?;
+
+    let icon_display_width = icon.chars().next().and_then(|c| c.width()).unwrap_or(1);
+
+    write!(writer, "{}{} ", indent_str, color.to_owo_color(&"\u{2502}"))?;
+    write!(writer, "{icon} ")?;
+    write!(writer, "{}", color.to_owo_color(&title).bold())?;
+
+    let title_padding = box_width.saturating_sub(4 + icon_display_width + 1 + title.len());
+    write!(writer, "{}", " ".repeat(title_padding))?;
+    writeln!(writer, " {}", color.to_owo_color(&"\u{2502}"))?;
+
+    if !admonition.blocks.is_empty() {
+        let separator = "\u{251C}".to_string() + &"\u{2500}".repeat(box_width.saturating_sub(2)) + "\u{2524}";
+        writeln!(writer, "{}{}", indent_str, color.to_owo_color(&separator))?;
+
+        for block in &admonition.blocks {
+            match block {
+                Block::Paragraph { spans } => {
+                    print_wrapped_admonition_paragraph(writer, spans, theme, color, &indent_str, box_width)?;
+                }
+                _ => {
+                    write!(writer, "{}{} ", indent_str, color.to_owo_color(&"\u{2502}"))?;
+                    print_block(writer, block, theme, box_width.saturating_sub(4), indent + 2)?;
+                    writeln!(writer, "{}", color.to_owo_color(&"\u{2502}"))?;
+                }
+            }
+        }
+    }
+
+    let bottom_border = "\u{2570}".to_string() + &"\u{2500}".repeat(box_width.saturating_sub(2)) + "\u{256F}";
+    writeln!(writer, "{}{}", indent_str, color.to_owo_color(&bottom_border))?;
+
+    Ok(())
+}
+
+/// Print a wrapped paragraph inside an admonition with proper text wrapping
+fn print_wrapped_admonition_paragraph<W: std::io::Write>(
+    writer: &mut W, spans: &[TextSpan], theme: &ThemeColors, border_color: &crate::theme::Color, indent_str: &str,
+    box_width: usize,
+) -> std::io::Result<()> {
+    let text = spans.iter().map(|s| s.text.as_str()).collect::<Vec<_>>().join("");
+    let words: Vec<&str> = text.split_whitespace().collect();
+
+    let content_width = box_width.saturating_sub(4);
+    let mut current_line = String::new();
+
+    for word in words {
+        if current_line.is_empty() {
+            current_line = word.to_string();
+        } else if current_line.len() + 1 + word.len() <= content_width {
+            current_line.push(' ');
+            current_line.push_str(word);
+        } else {
+            write!(writer, "{}{} ", indent_str, border_color.to_owo_color(&"\u{2502}"))?;
+            write!(writer, "{}", theme.body(&current_line))?;
+            let padding = content_width.saturating_sub(current_line.len());
+            write!(writer, "{}", " ".repeat(padding))?;
+            writeln!(writer, "{}", border_color.to_owo_color(&"\u{2502}"))?;
+            current_line = word.to_string();
+        }
+    }
+
+    if !current_line.is_empty() {
+        write!(writer, "{}{} ", indent_str, border_color.to_owo_color(&"\u{2502}"))?;
+        write!(writer, "{}", theme.body(&current_line))?;
+        let padding = content_width.saturating_sub(current_line.len());
+        write!(writer, "{}", " ".repeat(padding))?;
+        writeln!(writer, "{}", border_color.to_owo_color(&"\u{2502}"))?;
+    }
+
+    Ok(())
+}
+
 /// Print a table with borders and proper column width calculation
 ///
 /// Calculates column widths based on content and distributes available space
···
 
         assert!(separator.contains("─┼─"));
         assert!(separator.contains("─"));
+    }
+
+    #[test]
+    fn print_admonition_with_wrapping() {
+        use crate::slide::{Admonition, AdmonitionType};
+
+        let admonition = Admonition {
+            admonition_type: AdmonitionType::Tip,
+            title: Some("Tip".to_string()),
+            blocks: vec![Block::Paragraph {
+                spans: vec![TextSpan::plain(
+                    "Variables are immutable by default - use mut only when you need to change values",
+                )],
+            }],
+        };
+
+        let slide = Slide::with_blocks(vec![Block::Admonition(admonition)]);
+        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("Tip"));
+        assert!(text.contains("Variables are immutable"));
+        assert!(text.contains("mut"));
+        assert!(text.contains("╭") && text.contains("╮"));
+        assert!(text.contains("├") && text.contains("┤"));
+        assert!(text.contains("╰") && text.contains("╯"));
+        assert!(text.contains("│"));
+    }
+
+    #[test]
+    fn print_admonition_border_length() {
+        use crate::slide::{Admonition, AdmonitionType};
+
+        let admonition = Admonition {
+            admonition_type: AdmonitionType::Note,
+            title: None,
+            blocks: vec![Block::Paragraph { spans: vec![TextSpan::plain("Test content")] }],
+        };
+
+        let slide = Slide::with_blocks(vec![Block::Admonition(admonition)]);
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let width = 60;
+        let result = print_slides(&mut output, &[slide], &theme, width);
+        assert!(result.is_ok());
+
+        let text = String::from_utf8_lossy(&output);
+        let lines: Vec<&str> = text.lines().collect();
+
+        for line in &lines {
+            if line.contains("╭") || line.contains("├") || line.contains("╰") {
+                let stripped = strip_ansi_codes(line);
+                let visible_len = stripped.chars().count();
+                assert!(
+                    visible_len <= width,
+                    "Border line too long: {visible_len} chars (max {width})\nLine: {stripped}"
+                );
+            }
+        }
+    }
+
+    fn strip_ansi_codes(s: &str) -> String {
+        let mut result = String::new();
+        let mut chars = s.chars().peekable();
+
+        while let Some(c) = chars.next() {
+            if c == '\x1b' {
+                if chars.peek() == Some(&'[') {
+                    chars.next();
+                    for ch in chars.by_ref() {
+                        if ch.is_ascii_alphabetic() {
+                            break;
+                        }
+                    }
+                }
+            } else {
+                result.push(c);
+            }
+        }
+
+        result
+    }
+
+    #[test]
+    fn print_admonition_wraps_long_text() {
+        use crate::slide::{Admonition, AdmonitionType};
+
+        let long_text = "This is a very long text that should definitely wrap across multiple lines when rendered in a narrow width to ensure readability and proper formatting";
+
+        let admonition = Admonition {
+            admonition_type: AdmonitionType::Warning,
+            title: Some("Warning".to_string()),
+            blocks: vec![Block::Paragraph { spans: vec![TextSpan::plain(long_text)] }],
+        };
+
+        let slide = Slide::with_blocks(vec![Block::Admonition(admonition)]);
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let result = print_slides(&mut output, &[slide], &theme, 50);
+        assert!(result.is_ok());
+
+        let text = String::from_utf8_lossy(&output);
+        let content_lines: Vec<&str> = text
+            .lines()
+            .filter(|line| line.contains("│") && !line.contains("╭") && !line.contains("├") && !line.contains("╰"))
+            .collect();
+
+        assert!(content_lines.len() > 2, "Long text should wrap to multiple lines");
     }
 }

core/src/slide.rs

···
+use std::str::FromStr;
+
 use serde::{Deserialize, Serialize};
 
 /// A single slide in a presentation
···
     BlockQuote { blocks: Vec<Block> },
     /// Table
     Table(Table),
+    /// Admonition/alert box with type, optional title, and content
+    Admonition(Admonition),
 }
 
 /// Styled text span within a block
···
     Left,
     Center,
     Right,
+}
+
+/// Admonition type determines styling and icon
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+pub enum AdmonitionType {
+    Note,
+    Tip,
+    Important,
+    Warning,
+    Caution,
+    Danger,
+    Error,
+    Info,
+    Success,
+    Question,
+    Example,
+    Quote,
+    Abstract,
+    Todo,
+    Bug,
+    Failure,
+}
+
+/// Error type for parsing AdmonitionType
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ParseAdmonitionTypeError;
+
+impl std::fmt::Display for ParseAdmonitionTypeError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "invalid admonition type")
+    }
+}
+
+impl std::error::Error for ParseAdmonitionTypeError {}
+
+impl FromStr for AdmonitionType {
+    type Err = ParseAdmonitionTypeError;
+
+    /// Parse admonition type from string (case-insensitive)
+    ///
+    /// Supports GitHub and Obsidian aliases
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "note" => Ok(Self::Note),
+            "tip" | "hint" => Ok(Self::Tip),
+            "important" => Ok(Self::Important),
+            "warning" | "caution" | "attention" => Ok(Self::Warning),
+            "danger" | "error" => Ok(Self::Danger),
+            "info" => Ok(Self::Info),
+            "success" | "check" | "done" => Ok(Self::Success),
+            "question" | "help" | "faq" => Ok(Self::Question),
+            "example" => Ok(Self::Example),
+            "quote" => Ok(Self::Quote),
+            "abstract" | "summary" | "tldr" => Ok(Self::Abstract),
+            "todo" => Ok(Self::Todo),
+            "bug" => Ok(Self::Bug),
+            "failure" | "fail" | "missing" => Ok(Self::Failure),
+            _ => Err(ParseAdmonitionTypeError),
+        }
+    }
+}
+
+/// Admonition/alert box with styled content
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Admonition {
+    pub admonition_type: AdmonitionType,
+    pub title: Option<String>,
+    pub blocks: Vec<Block>,
 }
 
 #[cfg(test)]

core/src/term.rs

···
+use crossterm::event::{self, Event, KeyCode, KeyEvent, KeyModifiers};
+use std::{io, time::Duration};
+
+#[cfg(not(test))]
 use crossterm::{
-    event::{self, Event, KeyCode, KeyEvent, KeyModifiers},
     execute,
     terminal::{EnterAlternateScreen, LeaveAlternateScreen, disable_raw_mode, enable_raw_mode},
 };
-use std::{io, time::Duration};
 
 /// Terminal manager that handles setup and cleanup
 ///
···
     ///
     /// Enables alternate screen and raw mode for full terminal control.
     pub fn setup() -> io::Result<Self> {
-        let mut stdout = io::stdout();
-        execute!(stdout, EnterAlternateScreen)?;
-        enable_raw_mode()?;
+        #[cfg(not(test))]
+        {
+            let mut stdout = io::stdout();
+            execute!(stdout, EnterAlternateScreen)?;
+            enable_raw_mode()?;
+        }
 
         Ok(Self::default())
     }
···
     ///
     /// Called automatically on drop, but can be called manually for explicit cleanup.
     pub fn restore(&mut self) -> io::Result<()> {
-        if self.in_raw_mode {
-            disable_raw_mode()?;
-            self.in_raw_mode = false;
+        #[cfg(not(test))]
+        {
+            if self.in_raw_mode {
+                disable_raw_mode()?;
+                self.in_raw_mode = false;
+            }
+
+            if self.in_alternate_screen {
+                let mut stdout = io::stdout();
+                execute!(stdout, LeaveAlternateScreen)?;
+                self.in_alternate_screen = false;
+            }
         }
 
-        if self.in_alternate_screen {
-            let mut stdout = io::stdout();
-            execute!(stdout, LeaveAlternateScreen)?;
+        #[cfg(test)]
+        {
+            self.in_raw_mode = false;
             self.in_alternate_screen = false;
         }
 

core/src/theme.rs

···
     pub ui_title: Color,
     pub ui_text: Color,
     pub ui_background: Color,
+    pub admonition_note: Color,
+    pub admonition_tip: Color,
+    pub admonition_warning: Color,
+    pub admonition_danger: Color,
+    pub admonition_success: Color,
+    pub admonition_info: Color,
 }
 
 impl Default for ThemeColors {
···
         let ui_title = parse_hex_color(&palette.base06)?;
         let ui_text = parse_hex_color(&palette.base05)?;
 
+        let admonition_note = parse_hex_color(&palette.base0d)?;
+        let admonition_tip = parse_hex_color(&palette.base0e)?;
+        let admonition_warning = parse_hex_color(&palette.base0a)?;
+        let admonition_danger = parse_hex_color(&palette.base08)?;
+        let admonition_success = parse_hex_color(&palette.base0b)?;
+        let admonition_info = parse_hex_color(&palette.base0c)?;
+
         Some(Self {
             heading: Color::new(heading.0, heading.1, heading.2),
             heading_bold: true,
···
             ui_title: Color::new(ui_title.0, ui_title.1, ui_title.2),
             ui_text: Color::new(ui_text.0, ui_text.1, ui_text.2),
             ui_background: Color::new(ui_background.0, ui_background.1, ui_background.2),
+            admonition_note: Color::new(admonition_note.0, admonition_note.1, admonition_note.2),
+            admonition_tip: Color::new(admonition_tip.0, admonition_tip.1, admonition_tip.2),
+            admonition_warning: Color::new(admonition_warning.0, admonition_warning.1, admonition_warning.2),
+            admonition_danger: Color::new(admonition_danger.0, admonition_danger.1, admonition_danger.2),
+            admonition_success: Color::new(admonition_success.0, admonition_success.1, admonition_success.2),
+            admonition_info: Color::new(admonition_info.0, admonition_info.1, admonition_info.2),
         })
     }
 

docs/src/extensions.md

···
+# Extensions
+
+## Admonitions/Alerts
+
+Admonitions (also called alerts or callouts) are special highlighted blocks that draw attention to important information. Lantern supports both GitHub-flavored markdown syntax and a custom fence syntax.
+
+### Supported Types
+
+All admonitions are rendered with colored borders and icons:
+
+- **Note/Info** - Blue - General information
+- **Tip/Hint/Important** - Purple - Helpful suggestions
+- **Warning/Caution/Attention** - Yellow - Important warnings
+- **Danger/Error** - Red - Critical issues
+- **Success/Check/Done** - Green - Success messages
+- **Question/Help/FAQ** - Cyan - Questions and help
+- **Example** - Green - Example content
+- **Quote** - Cyan - Quotations
+- **Abstract/Summary/TLDR** - Blue - Summaries
+- **Todo** - Cyan - Todo items
+- **Bug** - Red - Bug reports
+- **Failure/Fail/Missing** - Red - Failures
+
+### GitHub/Obsidian Syntax
+
+```markdown
+> [!NOTE]
+> Useful information that users should know, even when skimming content.
+
+> [!TIP]
+> Helpful advice for doing things better or more easily.
+
+> [!IMPORTANT]
+> Key information users need to know to achieve their goal.
+
+> [!WARNING]
+> Urgent info that needs immediate user attention to avoid problems.
+
+> [!CAUTION]
+> Advises about risks or negative outcomes of certain actions.
+```
+
+### Obsidian
+
+```markdown
+> [!quote]
+> Lorem ipsum dolor sit amet
+
+> [!quote] Optional Title
+> Lorem ipsum dolor sit amet
+
+> [!example]
+> Lorem ipsum dolor sit amet
+
+> [!bug]
+> Lorem ipsum dolor sit amet
+
+> [!danger]
+> Lorem ipsum dolor sit amet
+
+> [!failure]
+> Lorem ipsum dolor sit amet
+
+> [!warning]
+> Lorem ipsum dolor sit amet
+
+> [!question]
+> Lorem ipsum dolor sit amet
+
+> [!success]
+> Lorem ipsum dolor sit amet
+
+> [!tip]
+> Lorem ipsum dolor sit amet
+
+> [!todo]
+> Lorem ipsum dolor sit amet
+
+> [!abstract]
+> Lorem ipsum dolor sit amet
+
+> [!note]
+> Lorem ipsum dolor sit amet
+```
+
+#### Aliases
+
+| Main     | Alias              |
+| -------- | ------------------ |
+| danger   | error              |
+| failure  | fail, missing      |
+| warning  | caution, attention |
+| question | help, faq          |
+| success  | check, done        |
+| tip      | hint, important    |
+| abstract | summary, tldr      |
+
+### Fence Syntax
+
+You can also use a custom fence syntax with `:::`:
+
+```markdown
+:::note
+This is a note using fence syntax
+:::
+
+:::warning
+This is a warning with fence syntax
+:::
+
+:::tip
+Pro tip: You can use either syntax!
+:::
+```
+
+### Custom Titles
+
+For GitHub/Obsidian syntax, you can provide a custom title:
+
+```markdown
+> [!WARNING] Custom Warning Title
+> This warning has a custom title instead of the default "Warning"
+```
+
+### Implementation Details
+
+Admonitions are:
+
+- Parsed during markdown preprocessing
+- Converted to internal AST representation
+- Rendered with themed colors from the active color scheme
+- Displayed with Unicode icons (ⓘ, ⚠, ✓, etc.)
+- Support nested markdown content (paragraphs, lists, code, etc.)

docs/src/quickstart.md

···
 
 - `→`, `j`, `Space`, `n` - Next slide
 - `←`, `k`, `p` - Previous slide
-- `0-9` - Jump to slide (single digit)
 - `Shift+N` - Toggle speaker notes
 - `q`, `Ctrl+C`, `Esc` - Quit presentation
 

examples/learn-markdown.md

···
+---
+theme: default
+author: Learn Markdown
+---
+
+# Markdown Basics
+
+A quick reference for Markdown syntax
+
+---
+
+## Headings
+
+Markdown supports multiple heading styles:
+
+```markdown
+# This is an h1
+## This is an h2
+### This is an h3
+#### This is an h4
+##### This is an h5
+###### This is an h6
+```
+
+Alternative syntax for h1 and h2:
+
+```markdown
+This is an h1
+=============
+
+This is an h2
+-------------
+```
+
+---
+
+## Text Formatting
+
+**Bold text:**
+
+```markdown
+**This text is in bold.**
+__And so is this text.__
+```
+
+*Italic text:*
+
+```markdown
+*This text is in italics.*
+_And so is this text._
+```
+
+Combined:
+
+```markdown
+***This text is in both.***
+**_As is this!_**
+*__And this!__*
+```
+
+Strikethrough:
+
+```markdown
+~~This text is rendered with strikethrough.~~
+```
+
+---
+
+## Paragraphs
+
+Paragraphs are separated by blank lines:
+
+```markdown
+This is a paragraph. I'm typing in a paragraph.
+
+Now I'm in paragraph 2.
+I'm still in paragraph 2 too!
+
+I'm in paragraph three!
+```
+
+Line breaks require two spaces at the end or `<br />`:
+
+```markdown
+I end with two spaces (highlight to see them).
+There's a <br /> above me!
+```
+
+---
+
+## Block Quotes
+
+Use `>` to create block quotes:
+
+```markdown
+> This is a block quote. You can either
+> manually wrap your lines and put a `>`
+> before every line or you can let your
+> lines get really long and wrap on their own.
+```
+
+Nested quotes:
+
+```markdown
+> You can also use more than one level
+>> of indentation?
+> How neat is that?
+```
+
+---
+
+## Lists
+
+**Unordered lists** use `*`, `+`, or `-`:
+
+```markdown
+* Item
+* Item
+* Another item
+
+- Item
+- Item
+- One last item
+```
+
+**Ordered lists** use numbers:
+
+```markdown
+1. Item one
+2. Item two
+3. Item three
+```
+
+Nested lists:
+
+```markdown
+1. Item one
+2. Item two
+3. Item three
+    * Sub-item
+    * Sub-item
+4. Item four
+```
+
+---
+
+## Task Lists
+
+Create checkboxes with `[ ]` and `[x]`:
+
+```markdown
+- [ ] First task to complete
+- [ ] Second task that needs done
+- [x] This task has been completed
+```
+
+> [!NOTE]
+> Task lists are a GitHub-flavored Markdown extension
+
+---
+
+## Code
+
+**Inline code** uses backticks:
+
+```markdown
+John didn't even know what the `go_to()` function did!
+```
+
+**Code blocks** use triple backticks or indentation:
+
+````markdown
+```rust
+fn main() {
+    println!("Hello, world!");
+}
+```
+
+    This is code
+    So is this
+````
+
+---
+
+## Horizontal Rules
+
+Create horizontal rules with three or more:
+
+```markdown
+***
+---
+- - -
+****************
+```
+
+All render as:
+
+***
+
+___
+
+- - -
+
+---
+
+## Links
+
+**Inline links:**
+
+```markdown
+[Click me!](http://test.com/)
+[Click me!](http://test.com/ "Link to Test.com")
+[Go to music](/music/)
+```
+
+**Reference links:**
+
+```markdown
+[Click this link][link1] for more info!
+[Also check out this link][foobar] if you want.
+
+[link1]: http://test.com/ "Cool!"
+[foobar]: http://foobar.biz/ "Alright!"
+```
+
+**Implicit reference:**
+
+```markdown
+[This][] is a link.
+
+[This]: http://thisisalink.com/
+```
+
+---
+
+## Internal Links
+
+Link to headings using slugified IDs:
+
+```markdown
+- [Heading](#heading)
+- [Another heading](#another-heading)
+- [Chapter](#chapter)
+  - [Subchapter <h3 />](#subchapter-h3-)
+```
+
+> [!TIP]
+> Heading IDs are created by lowercasing and replacing spaces with hyphens
+
+---
+
+## Images
+
+**Inline images:**
+
+```markdown
+![Alt text for image](http://imgur.com/myimage.jpg "Optional title")
+```
+
+**Reference images:**
+
+```markdown
+![This is the alt-attribute.][myimage]
+
+[myimage]: relative/urls/cool/image.jpg "Optional title"
+```
+
+> [!NOTE]
+> Images use the same syntax as links, but with a `!` prefix
+
+---
+
+## Automatic Links
+
+URLs and email addresses can be auto-linked:
+
+```markdown
+<http://testwebsite.com/>
+<[e-mail]>
+```
+
+These are equivalent to:
+
+```markdown
+[http://testwebsite.com/](http://testwebsite.com/)
+[[e-mail]](mailto:[e-mail])
+```
+
+---
+
+## Escaping
+
+Use backslash to escape special characters:
+
+```markdown
+I want to type *this* but not in italics:
+\*this text surrounded by asterisks\*
+```
+
+Special characters you can escape:
+
+```markdown
+\   backslash
+`   backtick
+*   asterisk
+_   underscore
+{}  curly braces
+[]  square brackets
+()  parentheses
+#   hash mark
++   plus sign
+-   minus sign
+.   dot
+!   exclamation mark
+```
+
+---
+
+## HTML Elements
+
+You can use HTML in Markdown:
+
+```markdown
+Your computer crashed? Try sending a
+<kbd>Ctrl</kbd>+<kbd>Alt</kbd>+<kbd>Del</kbd>
+```
+
+> [!WARNING]
+> You cannot use Markdown syntax within HTML element contents
+
+---
+
+## Tables
+
+Create tables with pipes and hyphens:
+
+```markdown
+| Col1         | Col2     | Col3          |
+| :----------- | :------: | ------------: |
+| Left-aligned | Centered | Right-aligned |
+| blah         | blah     | blah          |
+```
+
+Compact syntax also works:
+
+```markdown
+Col 1 | Col2 | Col3
+:-- | :-: | --:
+Ugh this is ugly | make it | stop
+```
+
+Alignment is controlled by colons:
+
+- `:--` = left-aligned
+- `:-:` = centered
+- `--:` = right-aligned
+
+---
+
+## Admonitions
+
+> [!IMPORTANT]
+> Admonitions are NOT standard Markdown - they are an extension
+
+Common admonition types:
+
+```markdown
+> [!NOTE]
+> Useful information
+
+> [!TIP]
+> Helpful advice
+
+> [!IMPORTANT]
+> Critical information
+
+> [!WARNING]
+> Proceed with caution
+
+> [!CAUTION]
+> Potential risks ahead
+```
+
+---
+
+## Admonition Examples
+
+> [!NOTE]
+> This is a note admonition with helpful context
+
+> [!TIP]
+> Use Markdown for clear, readable documentation
+
+> [!WARNING]
+> Not all Markdown processors support the same features
+
+> [!IMPORTANT]
+> Always check your Markdown processor's documentation for supported features
+
+---
+
+## Comments
+
+HTML comments work in Markdown:
+
+```markdown
+<!-- This is a comment and won't be rendered -->
+```
+
+Comments are useful for:
+
+- Leaving notes for yourself or collaborators
+- Temporarily hiding content
+- Adding metadata that shouldn't display
+
+---
+
+## Summary
+
+Markdown provides:
+
+- **Simple syntax** for formatted text
+- **Readable source** that looks good even as plain text
+- **Portable format** supported by many tools
+- **Extensions** like tables, task lists, and admonitions
+
+> [!SUCCESS]
+> You now know the basics of Markdown!
+
+---
+
+## Resources
+
+**Learn more:**
+
+- Markdown Guide (https://www.markdownguide.org/)
+- GitHub Flavored Markdown (https://github.github.com/gfm/)
+- CommonMark Spec (https://commonmark.org/)
+
+**Practice:**
+
+- Markdown Tutorial (https://www.markdowntutorial.com/)
+- Dillinger (https://dillinger.io/) - Online Markdown editor
+
+---
+
+## Thank You
+
+Happy writing!

examples/learn-rust.md

···
 mutable += 2;
 ```
 
+> [!TIP]
+> Variables are immutable by default - use `mut` only when you need to change values
+
 ---
 
 ## Numbers
···
 // Now var2 can be used again
 ```
 
-**Key rule:** Either many immutable references OR one mutable reference.
+> [!WARNING]
+> Only ONE mutable reference OR many immutable references at a time
 
 ---
 
 ## Memory Safety
 
-Rust's borrow checker ensures:
+> [!IMPORTANT]
+> Rust's borrow checker ensures memory safety at compile time
+
+Guarantees:
 
 - No use after free
 - No double free

ui/Cargo.toml

···
 crossterm = "0.29.0"
 lantern-core = { path = "../core" }
 owo-colors = "4.2.3"
+unicode-width = "0.2"

ui/src/renderer.rs

···
     style::{Modifier, Style},
     text::{Line, Span, Text},
 };
+use unicode_width::UnicodeWidthChar;
 
 /// Render a slide's blocks into ratatui Text
 ///
···
             Block::Rule => render_rule(theme, &mut lines),
             Block::BlockQuote { blocks } => render_blockquote(blocks, theme, &mut lines),
             Block::Table(table) => render_table(table, theme, &mut lines),
+            Block::Admonition(admonition) => render_admonition(admonition, theme, &mut lines),
         }
 
         lines.push(Line::raw(""));
···
             lines.push(Line::from(line_spans));
         }
     }
+}
+
+/// Render an admonition with colored border and icon
+fn render_admonition(
+    admonition: &lantern_core::slide::Admonition, theme: &ThemeColors, lines: &mut Vec<Line<'static>>,
+) {
+    use lantern_core::slide::AdmonitionType;
+
+    let (icon, color, default_title) = match admonition.admonition_type {
+        AdmonitionType::Note => ("\u{24D8}", &theme.admonition_note, "Note"),
+        AdmonitionType::Tip => ("\u{1F4A1}", &theme.admonition_tip, "Tip"),
+        AdmonitionType::Important => ("\u{2757}", &theme.admonition_tip, "Important"),
+        AdmonitionType::Warning => ("\u{26A0}", &theme.admonition_warning, "Warning"),
+        AdmonitionType::Caution => ("\u{26A0}", &theme.admonition_warning, "Caution"),
+        AdmonitionType::Danger => ("\u{26D4}", &theme.admonition_danger, "Danger"),
+        AdmonitionType::Error => ("\u{2717}", &theme.admonition_danger, "Error"),
+        AdmonitionType::Info => ("\u{24D8}", &theme.admonition_info, "Info"),
+        AdmonitionType::Success => ("\u{2713}", &theme.admonition_success, "Success"),
+        AdmonitionType::Question => ("?", &theme.admonition_info, "Question"),
+        AdmonitionType::Example => ("\u{25B8}", &theme.admonition_success, "Example"),
+        AdmonitionType::Quote => ("\u{201C}", &theme.admonition_info, "Quote"),
+        AdmonitionType::Abstract => ("\u{00A7}", &theme.admonition_note, "Abstract"),
+        AdmonitionType::Todo => ("\u{2610}", &theme.admonition_info, "Todo"),
+        AdmonitionType::Bug => ("\u{1F41B}", &theme.admonition_danger, "Bug"),
+        AdmonitionType::Failure => ("\u{2717}", &theme.admonition_danger, "Failure"),
+    };
+
+    let title = admonition.title.as_deref().unwrap_or(default_title);
+    let color_style = to_ratatui_style(color, false);
+    let bold_color_style = to_ratatui_style(color, true);
+
+    let top_border = format!("\u{256D}{}\u{256E}", "\u{2500}".repeat(58));
+    lines.push(Line::from(Span::styled(top_border, color_style)));
+
+    let icon_display_width = icon.chars().next().and_then(|c| c.width()).unwrap_or(1);
+
+    let title_line = vec![
+        Span::styled("\u{2502} ".to_string(), color_style),
+        Span::raw(format!("{icon} ")),
+        Span::styled(title.to_string(), bold_color_style),
+        Span::styled(
+            " ".repeat(56_usize.saturating_sub(icon_display_width + 1 + title.len())),
+            color_style,
+        ),
+        Span::styled(" \u{2502}".to_string(), color_style),
+    ];
+    lines.push(Line::from(title_line));
+
+    if !admonition.blocks.is_empty() {
+        let separator = format!("\u{251C}{}\u{2524}", "\u{2500}".repeat(58));
+        lines.push(Line::from(Span::styled(separator, color_style)));
+
+        for block in &admonition.blocks {
+            if let Block::Paragraph { spans } = block {
+                let text: String = spans.iter().map(|s| s.text.as_str()).collect();
+                let words: Vec<&str> = text.split_whitespace().collect();
+                let content_width = 56; // 60 total - 2 for borders - 2 for spaces
+
+                let mut current_line = String::new();
+                for word in words {
+                    if current_line.is_empty() {
+                        current_line = word.to_string();
+                    } else if current_line.len() + 1 + word.len() <= content_width {
+                        current_line.push(' ');
+                        current_line.push_str(word);
+                    } else {
+                        let mut line_spans = vec![Span::styled("\u{2502} ".to_string(), color_style)];
+                        line_spans.push(Span::raw(current_line.clone()));
+                        let padding = content_width.saturating_sub(current_line.len());
+                        line_spans.push(Span::raw(" ".repeat(padding)));
+                        line_spans.push(Span::styled(" \u{2502}".to_string(), color_style));
+                        lines.push(Line::from(line_spans));
+                        current_line = word.to_string();
+                    }
+                }
+
+                if !current_line.is_empty() {
+                    let mut line_spans = vec![Span::styled("\u{2502} ".to_string(), color_style)];
+                    line_spans.push(Span::raw(current_line.clone()));
+                    let padding = content_width.saturating_sub(current_line.len());
+                    line_spans.push(Span::raw(" ".repeat(padding)));
+                    line_spans.push(Span::styled(" \u{2502}".to_string(), color_style));
+                    lines.push(Line::from(line_spans));
+                }
+            }
+        }
+    }
+
+    let bottom_border = format!("\u{2570}{}\u{256F}", "\u{2500}".repeat(58));
+    lines.push(Line::from(Span::styled(bottom_border, color_style)));
 }
 
 /// Render a table with basic formatting