rich-rs

Rich text and beautiful formatting for the terminal: a Rust port of Python's Rich library.

rich-rs focuses on expressive terminal output with a small, composable API. It supports tables, progress bars, Markdown, syntax highlighting, tracebacks, and more without extra setup.

Compatibility

rich-rs works on Linux, macOS, and Windows. True color / emoji works with modern terminals; legacy Windows console is limited to 16 colors.

Minimum Supported Rust Version: 1.85+ (Rust 2024 edition)

Installing

Add to your Cargo.toml:

[dependencies]
rich-rs = "1.0.2"

Run the demo to see rich-rs in action:

cargo run --example demo

Console Printing

To add rich output to your application, create a Console and use its print methods:

use rich_rs::{Console, Text};

let mut console = Console::new();
let text = Text::from_markup("Hello, [bold magenta]World[/]!", false).unwrap();
console.print(&text, None, None, None, false, "\n").unwrap();

rich-rs will automatically word-wrap text to fit the terminal width and detect color support.

Markup

rich-rs uses a BBCode-like markup syntax for inline styling:

use rich_rs::{Console, Text};

let mut console = Console::new();
console.print(&Text::from_markup("[bold red]Error:[/] Something went wrong", false).unwrap(), None, None, None, false, "\n").unwrap();
console.print(&Text::from_markup("[link=https://example.com]Click here[/link]", false).unwrap(), None, None, None, false, "\n").unwrap();
console.print(&Text::from_markup(":warning: [yellow]Warning[/] :warning:", true).unwrap(), None, None, None, false, "\n").unwrap();

rich-rs Library

rich-rs ships with a set of built-in renderables you can combine to produce clean, beautiful CLI output.

Click the headings below for details:

rich-rs can render flexible tables with unicode box characters, borders, styles, and cell alignment.

use rich_rs::{Console, Table, Column, Style, SimpleColor, JustifyMethod, Text};

let mut console = Console::new();
let mut table = Table::new();

table.add_column(Column::with_header(Box::new(Text::styled("Name", Style::new().with_color(SimpleColor::Standard(6))))));
table.add_column(Column::with_header(Box::new(Text::styled("Age", Style::new().with_color(SimpleColor::Standard(5))))).justify(JustifyMethod::Right));
table.add_column(Column::with_header(Box::new(Text::styled("City", Style::new().with_color(SimpleColor::Standard(2))))));

table.add_row_strs(&["Alice", "30", "New York"]);
table.add_row_strs(&["Bob", "25", "Los Angeles"]);
table.add_row_strs(&["Charlie", "35", "Chicago"]);

console.print(&table, None, None, None, false, "\n").unwrap();

Tables automatically resize columns to fit the terminal width, wrapping text as needed.

rich-rs can render multiple flicker-free progress bars to track long-running tasks.

use rich_rs::progress::{Progress, ProgressIteratorExt};

// Simple iterator progress
for item in (0..100).progress() {
    std::thread::sleep(std::time::Duration::from_millis(50));
}

For more control, create a Progress instance with custom columns:

use rich_rs::progress::Progress;

let progress = Progress::new();
let task = progress.add_task("Downloading...", Some(100));
// ... update task progress

Built-in columns include percentage, file size, transfer speed, time elapsed, and time remaining.

rich-rs can update content in-place for real-time displays.

use rich_rs::{Console, Live, Text};
use std::time::Duration;

let console = Console::new();
let mut live = Live::new(console);

live.start().unwrap();
for i in 0..10 {
    live.update(Text::plain(&format!("Count: {}", i)));
    std::thread::sleep(Duration::from_millis(500));
}
live.stop().unwrap();

Live display supports transient mode (clears on exit), alt-screen mode, and vertical overflow handling.

rich-rs uses syntect to implement syntax highlighting with multiple themes.

use rich_rs::{Console, Syntax};

let mut console = Console::new();

let code = r#"fn main() {
    let greeting = "Hello, World!";
    println!("{}", greeting);
}
"#;

let syntax = Syntax::new(code, "rust")
    .with_line_numbers(true)
    .with_theme("base16-ocean.dark");

console.print(&syntax, None, None, None, false, "\n").unwrap();

Available themes include base16-ocean.dark, Solarized (dark), InspiredGitHub, and more.

rich-rs can render markdown with syntax-highlighted code blocks.

use rich_rs::{Console, markdown::Markdown};

let mut console = Console::new();

let md = r#"# Hello World

This is **bold** and *italic*.

- Item one
- Item two

```rust
fn main() {
    println!("Hello!");
}

"#;

let markdown = Markdown::new(md); console.print(&markdown, None, None, None, false, "\n").unwrap();

![Markdown](imgs/markdown.svg)

Supports CommonMark + GitHub Flavored Markdown including tables, task lists, and fenced code blocks.

</details>

<details>
<summary>Trees</summary>

rich-rs can render hierarchical data with guide lines.

```rust
use rich_rs::{Console, Tree, Text, Style, SimpleColor};

let mut console = Console::new();

let mut tree = Tree::new(Box::new(Text::from_markup("[bold]:open_file_folder: Project[/]", true).unwrap()));
let src = tree.add(Box::new(Text::from_markup("[blue]:open_file_folder: src[/]", true).unwrap()));
src.add(Box::new(Text::from_markup("[green]:page_facing_up: main.rs[/]", true).unwrap()));
src.add(Box::new(Text::from_markup("[green]:page_facing_up: lib.rs[/]", true).unwrap()));
tree.add(Box::new(Text::from_markup("[yellow]:page_facing_up: Cargo.toml[/]", true).unwrap()));

console.print(&tree, None, None, None, false, "\n").unwrap();

rich-rs can render content in bordered boxes with titles.

use rich_rs::{Console, Panel, Text, Style, SimpleColor};
use rich_rs::r#box::ROUNDED;

let mut console = Console::new();

let content = Text::from_markup(
    "This is a [bold cyan]Panel[/]!\n\nPanels are great for highlighting important content.",
    true
).unwrap();

let panel = Panel::new(Box::new(content))
    .with_title("Information")
    .with_box(ROUNDED)
    .with_border_style(Style::new().with_color(SimpleColor::Standard(4)));

console.print(&panel, None, None, None, false, "\n").unwrap();

rich-rs can render beautiful panic backtraces with syntax-highlighted source context.

use rich_rs::traceback;

// Install as the default panic handler
traceback::install();

// Now panics will show beautiful tracebacks

Tracebacks show the call stack with source code snippets and local variable values.

rich-rs can pretty-print data structures with syntax highlighting.

use rich_rs::{Console, Pretty};

let mut console = Console::new();

let data = r#"{"name": "rich-rs", "version": "1.0.0", "features": ["tables", "syntax"]}"#;
let pretty = Pretty::from_str(data).with_indent_guides(true);

console.print(&pretty, None, None, None, false, "\n").unwrap();

rich-rs provides interactive prompts with validation and choices.

use rich_rs::prompt::{Prompt, Confirm, IntPrompt};

// Text prompt with choices
let color = Prompt::new("Favorite color?")
    .with_choices(&["red", "green", "blue"])
    .run()?;

// Numeric input
let age: i64 = IntPrompt::ask("How old are you?")?;

// Yes/No confirmation
if Confirm::ask("Continue?")? {
    println!("Proceeding...");
}

Supports password input, default values, and custom validation.

rich-rs can render content in neat columns with equal or optimal width.

use rich_rs::{Console, Columns, Text, Style, SimpleColor, Renderable};

let mut console = Console::new();

let items: Vec<Box<dyn Renderable + Send + Sync>> = (1..=9)
    .map(|i| {
        let color = SimpleColor::Standard((i % 7 + 1) as u8);
        Box::new(Text::styled(&format!("Item {}", i), Style::new().with_color(color)))
            as Box<dyn Renderable + Send + Sync>
    })
    .collect();

let columns = Columns::new(items).with_equal(true);
console.print(&columns, None, None, None, false, "\n").unwrap();

Acknowledgments

• Textualize for creating the original Python Rich library
• syntect for syntax highlighting
• crossterm for cross-platform terminal support
• pulldown-cmark for Markdown parsing

License

MIT License — see LICENSE for details.