feat: implement basic cli ux with print command and documentation

ROADMAP.md

···
 | __✓ 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__       | `slides present file.md` runs full TUI.                         | `clap`               |
+| __✓ Basic CLI UX__     | `slides present file.md` runs full TUI.                         | `clap`               |
 |                        | `slides print` renders to stdout with width constraint.         |                      |
 
 ## Rendering & Navigation
···
 | Task                      | Description                                                                                       | Key Crates             |
 | ------------------------- | ------------------------------------------------------------------------------------------------- | ---------------------- |
 | __✓ Ratatui Integration__ | Build basic slide viewer using layout, blocks, paragraphs.                                        | `ratatui`[^7]          |
-| __Input & State__         | Support `←/→`, `j/k`, `q`, numeric jumps, and window resize.                                      | `crossterm`, `ratatui` |
-| __Status Bar__            | Display slide count, filename, clock, and theme name.                                             | `ratatui`              |
+| __✓ Input & State__       | Support `←/→`, `j/k`, `q`, numeric jumps, and window resize.                                      | `crossterm`, `ratatui` |
+| __✓ Status Bar__          | Display slide count, filename, clock, and theme name.                                             | `ratatui`              |
 | __✓ Color Styling__       | Apply consistent color palette via `owo-colors`. Define traits like `ThemeColor`.                 | `owo-colors`           |
 | __Configurable Themes__   | Support themes via TOML files mapping semantic roles (`heading`, `body`, `accent`) → color pairs. | `toml`, `serde`        |
 
···
 | __Tables & Lists__   | Render GitHub-style tables, bullets, and task lists.         | `pulldown-cmark`, `ratatui`   |
 | __Admonitions__      | Highlighted boxes with icons                                 | `owo-colors`, internal glyphs |
 | __Horizontal Rules__ | Use box-drawing (`─`, `═`) and shading (`░`, `▓`).           | Unicode constants             |
-| __Generators__.      | `slides init` scaffolds an example deck with code and notes. | `include_str!`, `fs`          |
+| __Generators__       | `slides init` scaffolds an example deck with code and notes. | `include_str!`, `fs`          |
 
 ## RC
 

cli/src/main.rs

···
     Present {
         /// Path to the markdown file
         file: PathBuf,
-
         /// Theme to use for presentation
         #[arg(short, long)]
         theme: Option<String>,
···
     Print {
         /// Path to the markdown file
         file: PathBuf,
-
         /// Maximum width for output (in characters)
         #[arg(short, long, default_value = "80")]
         width: usize,
-
         /// Theme to use for coloring
         #[arg(short, long)]
         theme: Option<String>,
···
         /// Directory to create the deck in
         #[arg(default_value = ".")]
         path: PathBuf,
-
         /// Name of the deck file
         #[arg(short, long, default_value = "slides.md")]
         name: String,
···
     Check {
         /// Path to the markdown file
         file: PathBuf,
-
         /// Enable strict mode with additional checks
         #[arg(short, long)]
         strict: bool,
···
         }
 
         Commands::Print { file, width, theme } => {
-            tracing::info!("Printing slides from: {} (width: {})", file.display(), width);
-            if let Some(theme) = theme {
-                tracing::debug!("Using theme: {}", theme);
+            if let Err(e) = run_print(&file, width, theme) {
+                eprintln!("Error: {}", e);
+                std::process::exit(1);
             }
-            eprintln!("Print mode not yet implemented");
         }
 
         Commands::Init { path, name } => {
···
     result
 }
 
+fn run_print(file: &PathBuf, width: usize, theme_arg: Option<String>) -> io::Result<()> {
+    tracing::info!("Printing slides from: {} (width: {})", file.display(), width);
+
+    let markdown = std::fs::read_to_string(file)
+        .map_err(|e| io::Error::new(e.kind(), format!("Failed to read file {}: {}", file.display(), e)))?;
+
+    let (meta, slides) = parse_slides_with_meta(&markdown)
+        .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, format!("Parse error: {}", e)))?;
+
+    if slides.is_empty() {
+        return Err(io::Error::new(io::ErrorKind::InvalidData, "No slides found in file"));
+    }
+
+    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();
+
+    slides_core::printer::print_slides_to_stdout(&slides, &theme, width)?;
+
+    Ok(())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
···
             }
             _ => panic!("Expected Check command"),
         }
+    }
+
+    #[test]
+    fn run_print_with_test_file() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join("test_slides.md");
+
+        let content = "# Test Slide\n\nThis is a test paragraph.\n\n---\n\n# Second Slide\n\n- Item 1\n- Item 2";
+        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_empty_file() {
+        let temp_dir = std::env::temp_dir();
+        let test_file = temp_dir.join("empty_slides.md");
+
+        std::fs::write(&test_file, "").expect("Failed to write test file");
+
+        let result = run_print(&test_file, 80, None);
+        assert!(result.is_err());
+
+        std::fs::remove_file(&test_file).ok();
+    }
+
+    #[test]
+    fn run_print_nonexistent_file() {
+        let test_file = PathBuf::from("/nonexistent/file.md");
+        let result = run_print(&test_file, 80, None);
+        assert!(result.is_err());
     }
 }

core/src/lib.rs

···
 pub mod error;
 pub mod metadata;
 pub mod parser;
+pub mod printer;
 pub mod slide;
 pub mod term;
 pub mod theme;

core/src/printer.rs

···
+use crate::slide::{Block, CodeBlock, List, Table, TextSpan, TextStyle};
+use crate::theme::ThemeColors;
+
+/// Print slides to stdout with formatted output
+///
+/// Renders slides as plain text with ANSI colors and width constraints.
+pub fn print_slides_to_stdout(
+    slides: &[crate::slide::Slide], theme: &ThemeColors, width: usize,
+) -> std::io::Result<()> {
+    let stdout = std::io::stdout();
+    let mut handle = stdout.lock();
+    print_slides(&mut handle, slides, theme, width)
+}
+
+/// Print slides to any writer with formatted output
+pub fn print_slides<W: std::io::Write>(
+    writer: &mut W, slides: &[crate::slide::Slide], theme: &ThemeColors, width: usize,
+) -> std::io::Result<()> {
+    for (idx, slide) in slides.iter().enumerate() {
+        if idx > 0 {
+            writeln!(writer)?;
+            let sep_text = "═".repeat(width);
+            let separator = theme.rule(&sep_text);
+            writeln!(writer, "{}", separator)?;
+            writeln!(writer)?;
+        }
+
+        print_slide(writer, slide, theme, width)?;
+    }
+
+    Ok(())
+}
+
+/// Print a single slide with formatted blocks
+fn print_slide<W: std::io::Write>(
+    writer: &mut W, slide: &crate::slide::Slide, theme: &ThemeColors, width: usize,
+) -> std::io::Result<()> {
+    for block in &slide.blocks {
+        print_block(writer, block, theme, width, 0)?;
+        writeln!(writer)?;
+    }
+
+    Ok(())
+}
+
+/// Print a single block with appropriate formatting
+fn print_block<W: std::io::Write>(
+    writer: &mut W, block: &Block, theme: &ThemeColors, width: usize, indent: usize,
+) -> std::io::Result<()> {
+    match block {
+        Block::Heading { level, spans } => {
+            print_heading(writer, *level, spans, theme)?;
+        }
+        Block::Paragraph { spans } => {
+            print_paragraph(writer, spans, theme, width, indent)?;
+        }
+        Block::Code(code) => {
+            print_code_block(writer, code, theme, width)?;
+        }
+        Block::List(list) => {
+            print_list(writer, list, theme, width, indent)?;
+        }
+        Block::Rule => {
+            let rule_text = "─".repeat(width.saturating_sub(indent));
+            let rule = theme.rule(&rule_text);
+            writeln!(writer, "{}{}", " ".repeat(indent), rule)?;
+        }
+        Block::BlockQuote { blocks } => {
+            print_blockquote(writer, blocks, theme, width, indent)?;
+        }
+        Block::Table(table) => {
+            print_table(writer, table, theme, width)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Print a heading with level-appropriate styling
+fn print_heading<W: std::io::Write>(
+    writer: &mut W, level: u8, spans: &[TextSpan], theme: &ThemeColors,
+) -> std::io::Result<()> {
+    let prefix = match level {
+        1 => "# ",
+        2 => "## ",
+        3 => "### ",
+        4 => "#### ",
+        5 => "##### ",
+        _ => "###### ",
+    };
+
+    write!(writer, "{}", theme.heading(&prefix))?;
+
+    for span in spans {
+        print_span(writer, span, theme, true)?;
+    }
+
+    writeln!(writer)?;
+    Ok(())
+}
+
+/// Print a paragraph with word wrapping
+fn print_paragraph<W: std::io::Write>(
+    writer: &mut W, spans: &[TextSpan], theme: &ThemeColors, width: usize, indent: usize,
+) -> std::io::Result<()> {
+    let indent_str = " ".repeat(indent);
+    let effective_width = width.saturating_sub(indent);
+
+    let text = spans.iter().map(|s| s.text.as_str()).collect::<Vec<_>>().join("");
+
+    let words: Vec<&str> = text.split_whitespace().collect();
+    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() <= effective_width {
+            current_line.push(' ');
+            current_line.push_str(word);
+        } else {
+            write!(writer, "{}", indent_str)?;
+            for span in spans {
+                if current_line.contains(&span.text) {
+                    print_span(writer, span, theme, false)?;
+                    break;
+                }
+            }
+            if !spans.is_empty() && !current_line.is_empty() {
+                write!(writer, "{}", theme.body(&current_line))?;
+            }
+            writeln!(writer)?;
+            current_line = word.to_string();
+        }
+    }
+
+    if !current_line.is_empty() {
+        write!(writer, "{}", indent_str)?;
+        for span in spans {
+            print_span(writer, span, theme, false)?;
+        }
+        writeln!(writer)?;
+    }
+
+    Ok(())
+}
+
+/// Print a code block with language tag
+fn print_code_block<W: std::io::Write>(
+    writer: &mut W, code: &CodeBlock, theme: &ThemeColors, width: usize,
+) -> std::io::Result<()> {
+    if let Some(lang) = &code.language {
+        writeln!(writer, "{}", theme.code_fence(&format!("```{}", lang)))?;
+    } else {
+        writeln!(writer, "{}", theme.code_fence(&"```"))?;
+    }
+
+    for line in code.code.lines() {
+        let trimmed = if line.len() > width - 4 { &line[..width - 4] } else { line };
+        writeln!(writer, "{}", theme.code(&trimmed))?;
+    }
+
+    writeln!(writer, "{}", theme.code_fence(&"```"))?;
+    Ok(())
+}
+
+/// Print a list with bullets or numbers
+fn print_list<W: std::io::Write>(
+    writer: &mut W, list: &List, theme: &ThemeColors, width: usize, indent: usize,
+) -> std::io::Result<()> {
+    for (idx, item) in list.items.iter().enumerate() {
+        let marker = if list.ordered { format!("{}. ", idx + 1) } else { "• ".to_string() };
+
+        write!(writer, "{}", " ".repeat(indent))?;
+        write!(writer, "{}", theme.list_marker(&marker))?;
+
+        for span in &item.spans {
+            print_span(writer, span, theme, false)?;
+        }
+
+        writeln!(writer)?;
+
+        if let Some(nested) = &item.nested {
+            print_list(writer, nested, theme, width, indent + 2)?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Print a blockquote with border
+fn print_blockquote<W: std::io::Write>(
+    writer: &mut W, blocks: &[Block], theme: &ThemeColors, width: usize, indent: usize,
+) -> std::io::Result<()> {
+    for block in blocks {
+        match block {
+            Block::Paragraph { spans } => {
+                write!(writer, "{}", " ".repeat(indent))?;
+                write!(writer, "{}", theme.blockquote_border(&"│ "))?;
+                for span in spans {
+                    print_span(writer, span, theme, false)?;
+                }
+                writeln!(writer)?;
+            }
+            _ => {
+                write!(writer, "{}", " ".repeat(indent))?;
+                write!(writer, "{}", theme.blockquote_border(&"│ "))?;
+                print_block(writer, block, theme, width, indent + 2)?;
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Print a table with borders
+///
+/// TODO: Implement proper column width calculation and alignment
+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 !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)?;
+
+        let separator = "─".repeat(width);
+        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(&" │ "))?;
+            }
+            for span in cell {
+                print_span(writer, span, theme, false)?;
+            }
+        }
+        writeln!(writer)?;
+    }
+
+    Ok(())
+}
+
+/// Print a text span with styling
+fn print_span<W: std::io::Write>(
+    writer: &mut W, span: &TextSpan, theme: &ThemeColors, is_heading: bool,
+) -> std::io::Result<()> {
+    let text = &span.text;
+    let style = &span.style;
+
+    if is_heading {
+        write!(writer, "{}", apply_text_style(&theme.heading(text), style))?;
+    } else if style.code {
+        write!(writer, "{}", apply_text_style(&theme.code(text), style))?;
+    } else {
+        write!(writer, "{}", apply_text_style(&theme.body(text), style))?;
+    }
+
+    Ok(())
+}
+
+/// Apply text style modifiers to styled text
+fn apply_text_style<T: std::fmt::Display>(styled: &owo_colors::Styled<T>, text_style: &TextStyle) -> String {
+    let mut result = styled.to_string();
+
+    if text_style.bold {
+        result = format!("\x1b[1m{}\x1b[22m", result);
+    }
+    if text_style.italic {
+        result = format!("\x1b[3m{}\x1b[23m", result);
+    }
+    if text_style.strikethrough {
+        result = format!("\x1b[9m{}\x1b[29m", result);
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::slide::Slide;
+
+    #[test]
+    fn print_empty_slides() {
+        let slides: Vec<Slide> = vec![];
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let result = print_slides(&mut output, &slides, &theme, 80);
+        assert!(result.is_ok());
+        assert_eq!(output.len(), 0);
+    }
+
+    #[test]
+    fn print_single_heading() {
+        let slide = Slide::with_blocks(vec![Block::Heading {
+            level: 1,
+            spans: vec![TextSpan::plain("Hello World")],
+        }]);
+        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("Hello World"));
+    }
+
+    #[test]
+    fn print_paragraph_with_wrapping() {
+        let long_text = "This is a very long paragraph that should wrap when printed to stdout with a width constraint applied to ensure readability.";
+        let slide = Slide::with_blocks(vec![Block::Paragraph { spans: vec![TextSpan::plain(long_text)] }]);
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+
+        let result = print_slides(&mut output, &[slide], &theme, 40);
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn print_code_block() {
+        let slide = Slide::with_blocks(vec![Block::Code(CodeBlock::with_language(
+            "rust",
+            "fn main() {\n    println!(\"Hello\");\n}",
+        ))]);
+        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("```rust"));
+        assert!(text.contains("fn main()"));
+    }
+
+    #[test]
+    fn print_multiple_slides() {
+        let slides = vec![
+            Slide::with_blocks(vec![Block::Heading {
+                level: 1,
+                spans: vec![TextSpan::plain("Slide 1")],
+            }]),
+            Slide::with_blocks(vec![Block::Heading {
+                level: 1,
+                spans: vec![TextSpan::plain("Slide 2")],
+            }]),
+        ];
+
+        let theme = ThemeColors::default();
+        let mut output = Vec::new();
+        let result = print_slides(&mut output, &slides, &theme, 80);
+        assert!(result.is_ok());
+
+        let text = String::from_utf8_lossy(&output);
+        assert!(text.contains("Slide 1"));
+        assert!(text.contains("Slide 2"));
+    }
+}

docs/src/SUMMARY.md

···
 # Summary
 
-- [Chapter 1](./chapter_1.md)
+[Introduction](./chapter_1.md)
+
+# Getting Started
+
+- [Quickstart](./quickstart.md)
+
+# Reference
+
+- [Symbols](./appendices/symbols.md)

docs/src/quickstart.md

···
+# Quickstart
+
+Get started with slides-rs in minutes.
+
+## Installation
+
+Currently, you'll need to build from source:
+
+```bash
+git clone https://github.com/yourusername/slides-rs.git
+cd slides-rs
+cargo build --release
+```
+
+The binary will be available at `target/release/slides`.
+
+## Creating Your First Deck
+
+Create a new markdown file called `presentation.md`:
+
+````markdown
+---
+theme: default
+author: Your Name
+---
+
+# Welcome to Slides
+
+A modern terminal-based presentation tool
+
+---
+
+## Features
+
+- Parse markdown into slides
+- Interactive TUI navigation with full keyboard support
+- Speaker notes with toggle visibility
+- Live presentation timer
+- Status bar with slide count and navigation hints
+- Print to stdout
+- Syntax highlighting (coming soon)
+
+---
+
+## Code Example
+
+```rust
+fn main() {
+    println!("Hello, slides!");
+}
+```
+
+Supports multiple languages with syntax highlighting.
+
+---
+
+## Lists and Formatting
+
+- Unordered lists with bullets
+- **Bold text** for emphasis
+- *Italic text* for style
+- `inline code` for commands
+
+---
+
+# Thank You
+
+Questions?
+````
+
+## Presenting Your Slides
+
+Run the interactive TUI presenter:
+
+```bash
+slides present presentation.md
+```
+
+### Navigation Keys
+
+- `→`, `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
+
+## Printing to Stdout
+
+Print all slides to stdout with formatting:
+
+```bash
+slides print presentation.md
+```
+
+Adjust output width:
+
+```bash
+slides print presentation.md --width 100
+```
+
+Use a specific theme:
+
+```bash
+slides print presentation.md --theme dark
+```
+
+## Slide Separators
+
+Slides are separated by three dashes on a line by themselves:
+
+```markdown
+# Slide 1
+
+Content here
+
+---
+
+# Slide 2
+
+More content
+```
+
+## Front Matter
+
+Optional metadata at the start of your file:
+
+YAML format:
+
+```yaml
+---
+theme: dark
+author: Jane Doe
+---
+```
+
+TOML format:
+
+```toml
++++
+theme = "monokai"
+author = "John Smith"
++++
+```
+
+## Supported Markdown
+
+Currently supported:
+
+- Headings (H1-H6)
+- Paragraphs with inline formatting (bold, italic, strikethrough, code)
+- Code blocks with language tags
+- Lists (ordered and unordered with nesting)
+- Horizontal rules
+- Blockquotes
+- Tables
+
+## Speaker Notes
+
+Add speaker notes to any slide using the `::: notes` directive:
+
+```markdown
+# Your Slide Title
+
+Main content visible to the audience.
+
+::: notes
+These are your speaker notes.
+Press Shift+N to toggle their visibility.
+They appear in a separate panel during presentation.
+:::
+```
+
+## Status Bar
+
+The status bar at the bottom displays:
+
+- Filename of the current presentation
+- Current slide number / Total slides
+- Active theme name
+- Navigation hints
+- Notes visibility indicator (✓ when shown)
+- Elapsed presentation time (HH:MM:SS)
+
+## Environment Variables
+
+Customize defaults with environment variables:
+
+```bash
+# Set default theme
+export SLIDES_THEME=dark
+
+# Set default author (used if not in frontmatter)
+export USER=YourName
+```

examples/learn-rust.md

···
+---
+theme: default
+author: Learn Rust
+---
+
+# Learn Rust
+
+A quick tour through Rust fundamentals
+
+---
+
+## Comments
+
+Rust supports multiple comment styles:
+
+```rust
+// Line comments look like this
+// and extend multiple lines
+
+/* Block comments
+   /* can be nested. */ */
+
+/// Documentation comments support markdown
+/// # Examples
+/// ```
+/// let five = 5
+/// ```
+```
+
+---
+
+## Functions
+
+Functions use `fn` keyword with type annotations:
+
+```rust
+fn add2(x: i32, y: i32) -> i32 {
+    // Implicit return (no semicolon)
+    x + y
+}
+```
+
+**Key points:**
+
+- `i32` is a 32-bit signed integer
+- Last expression without `;` is the return value
+- Function parameters must have type annotations
+
+---
+
+## Variables
+
+Rust has immutable bindings by default:
+
+```rust
+// Immutable binding
+let x: i32 = 1;
+
+// Type inference works most of the time
+let implicit_x = 1;
+let implicit_f = 1.3;
+
+// Mutable variable
+let mut mutable = 1;
+mutable = 4;
+mutable += 2;
+```
+
+---
+
+## Numbers
+
+Integer and float types with suffixes:
+
+```rust
+// Integer/float suffixes
+let y: i32 = 13i32;
+let f: f64 = 1.3f64;
+
+// Arithmetic
+let sum = x + y + 13;
+```
+
+---
+
+## Strings
+
+Two main string types in Rust:
+
+```rust
+// String slice (&str) - immutable view
+let x: &str = "hello world!";
+
+// String - heap-allocated, growable
+let s: String = "hello world".to_string();
+
+// String slice from String
+let s_slice: &str = &s;
+
+// Printing
+println!("{} {}", f, x);
+```
+
+---
+
+## Arrays and Vectors
+
+Fixed-size arrays and dynamic vectors:
+
+```rust
+// Fixed-size array
+let four_ints: [i32; 4] = [1, 2, 3, 4];
+
+// Dynamic vector
+let mut vector: Vec<i32> = vec![1, 2, 3, 4];
+vector.push(5);
+
+// Slice - immutable view
+let slice: &[i32] = &vector;
+
+// Debug printing
+println!("{:?} {:?}", vector, slice);
+```
+
+---
+
+## Tuples
+
+Fixed-size sets of values of possibly different types:
+
+```rust
+// Tuple declaration
+let x: (i32, &str, f64) = (1, "hello", 3.4);
+
+// Destructuring
+let (a, b, c) = x;
+println!("{} {} {}", a, b, c); // 1 hello 3.4
+
+// Indexing
+println!("{}", x.1); // hello
+```
+
+---
+
+## Structs
+
+Custom data types with named fields:
+
+```rust
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+let origin: Point = Point { x: 0, y: 0 };
+
+// Tuple struct (unnamed fields)
+struct Point2(i32, i32);
+let origin2 = Point2(0, 0);
+```
+
+---
+
+## Enums
+
+Enums can have variants with or without data:
+
+```rust
+// Basic C-like enum
+enum Direction {
+    Left,
+    Right,
+    Up,
+    Down,
+}
+
+let up = Direction::Up;
+
+// Enum with fields
+enum OptionalI32 {
+    AnI32(i32),
+    Nothing,
+}
+
+let two: OptionalI32 = OptionalI32::AnI32(2);
+```
+
+---
+
+## Generics
+
+Type parameters for reusable code:
+
+```rust
+struct Foo<T> { bar: T }
+
+enum Optional<T> {
+    SomeVal(T),
+    NoVal,
+}
+```
+
+The standard library provides `Option<T>` for optional values, replacing null pointers.
+
+---
+
+## Methods
+
+Functions associated with types:
+
+```rust
+impl<T> Foo<T> {
+    // Borrowed self
+    fn bar(&self) -> &T {
+        &self.bar
+    }
+
+    // Mutably borrowed self
+    fn bar_mut(&mut self) -> &mut T {
+        &mut self.bar
+    }
+
+    // Consumed self
+    fn into_bar(self) -> T {
+        self.bar
+    }
+}
+```
+
+---
+
+## Traits
+
+Interfaces that define shared behavior:
+
+```rust
+trait Frobnicate<T> {
+    fn frobnicate(self) -> Option<T>;
+}
+
+impl<T> Frobnicate<T> for Foo<T> {
+    fn frobnicate(self) -> Option<T> {
+        Some(self.bar)
+    }
+}
+
+let foo = Foo { bar: 1 };
+println!("{:?}", foo.frobnicate()); // Some(1)
+```
+
+---
+
+## Pattern Matching
+
+Powerful control flow with `match`:
+
+```rust
+let foo = OptionalI32::AnI32(1);
+match foo {
+    OptionalI32::AnI32(n) => println!("it's an i32: {}", n),
+    OptionalI32::Nothing  => println!("it's nothing!"),
+}
+```
+
+---
+
+## Advanced Pattern Matching
+
+Destructure and use guards:
+
+```rust
+struct FooBar { x: i32, y: OptionalI32 }
+let bar = FooBar { x: 15, y: OptionalI32::AnI32(32) };
+
+match bar {
+    FooBar { x: 0, y: OptionalI32::AnI32(0) } =>
+        println!("The numbers are zero!"),
+    FooBar { x: n, y: OptionalI32::AnI32(m) } if n == m =>
+        println!("The numbers are the same"),
+    FooBar { x: n, y: OptionalI32::AnI32(m) } =>
+        println!("Different numbers: {} {}", n, m),
+    FooBar { x: _, y: OptionalI32::Nothing } =>
+        println!("The second number is Nothing!"),
+}
+```
+
+---
+
+## For Loops
+
+Iterate over arrays and ranges:
+
+```rust
+// Array iteration
+let array = [1, 2, 3];
+for i in array {
+    println!("{}", i);
+}
+
+// Range iteration
+for i in 0u32..10 {
+    print!("{} ", i);
+}
+// prints: 0 1 2 3 4 5 6 7 8 9
+```
+
+---
+
+## If Expressions
+
+`if` can be used as an expression:
+
+```rust
+if 1 == 1 {
+    println!("Maths is working!");
+} else {
+    println!("Oh no...");
+}
+
+// if as expression
+let value = if true {
+    "good"
+} else {
+    "bad"
+};
+```
+
+---
+
+## Loops
+
+Multiple loop constructs:
+
+```rust
+// while loop
+while condition {
+    println!("Looping...");
+    break  // Exit the loop
+}
+
+// Infinite loop
+loop {
+    println!("Hello!");
+    break  // Must break explicitly
+}
+```
+
+---
+
+## Owned Pointers (Box)
+
+`Box<T>` provides heap allocation with single ownership:
+
+```rust
+let mut mine: Box<i32> = Box::new(3);
+*mine = 5; // dereference
+
+// Ownership transfer (move)
+let mut now_its_mine = mine;
+*now_its_mine += 2;
+
+println!("{}", now_its_mine); // 7
+// println!("{}", mine); // Error! moved
+```
+
+When `Box` goes out of scope, memory is automatically deallocated.
+
+---
+
+## Immutable References
+
+Borrowing without transferring ownership:
+
+```rust
+let mut var = 4;
+var = 3;
+let ref_var: &i32 = &var;
+
+println!("{}", var);      // Still works!
+println!("{}", *ref_var); // 3
+
+// var = 5;      // Error! var is borrowed
+// *ref_var = 6; // Error! immutable reference
+
+ref_var; // Use the reference
+var = 2; // Borrow ended, can mutate again
+```
+
+---
+
+## Mutable References
+
+Exclusive mutable access:
+
+```rust
+let mut var2 = 4;
+let ref_var2: &mut i32 = &mut var2;
+*ref_var2 += 2;
+
+println!("{}", *ref_var2); // 6
+
+// var2 = 2; // Error! var2 is mutably borrowed
+
+ref_var2; // Use ends here
+// Now var2 can be used again
+```
+
+**Key rule:** Either many immutable references OR one mutable reference.
+
+---
+
+## Memory Safety
+
+Rust's borrow checker ensures:
+
+- No use after free
+- No double free
+- No data races
+- No dangling pointers
+
+All at **compile time** with **zero runtime cost**.
+
+---
+
+## Next Steps
+
+- Explore the [Rust Book](https://doc.rust-lang.org/book/)
+- Try [Rust by Example](https://doc.rust-lang.org/rust-by-example/)
+- Practice with [Rustlings](https://github.com/rust-lang/rustlings)
+- Join the [Rust community](https://www.rust-lang.org/community)
+
+---
+
+## Thank You
+
+Happy Rusting!