Enum Color 

pub enum Color {
    Black,
    Red,
    Green,
    Yellow,
    Blue,
    Magenta,
    Cyan,
    White,
    DarkGray,
    LightRed,
    LightGreen,
    LightYellow,
    LightBlue,
    LightMagenta,
    LightCyan,
    LightGray,
    Rgb {
        r: u8,
        g: u8,
        b: u8,
    },
    AnsiValue(u8),
    Reset,
    Transparent,
}

A color that can be displayed in the terminal.

Supports named colors, RGB values, and ANSI color codes.

Variants

Black

Standard black color (ANSI 0)

Red

Standard red color (ANSI 1)

Green

Standard green color (ANSI 2)

Yellow

Standard yellow color (ANSI 3)

Blue

Standard blue color (ANSI 4)

Magenta

Standard magenta color (ANSI 5)

Cyan

Standard cyan color (ANSI 6)

White

Standard white color (ANSI 7)

DarkGray

Bright black/dark gray color (ANSI 8)

LightRed

Bright red color (ANSI 9)

LightGreen

Bright green color (ANSI 10)

LightYellow

Bright yellow color (ANSI 11)

LightBlue

Bright blue color (ANSI 12)

LightMagenta

Bright magenta color (ANSI 13)

LightCyan

Bright cyan color (ANSI 14)

LightGray

Bright white/light gray color (ANSI 15)

Rgb

Custom RGB color with red, green, and blue components (0-255 each)

Fields

r: u8

g: u8

b: u8

AnsiValue(u8)

ANSI color code from the 256-color palette (0-255)

Reset

Terminal’s default foreground color

Transparent

No color change - maintains the current color

Implementations

impl Color

pub const fn rgb(r: u8, g: u8, b: u8) -> Self

Create an RGB color. Each component should be 0-255.

Examples found in repository

examples/custom_colors.rs (line 83)

fn draw_rainbow_gradient(window: &mut dyn Window, start_y: u16, width: u16) -> minui::Result<()> {
    window.write_str(start_y, 0, "Rainbow Gradient:")?;

    let gradient_y = start_y + 1;
    let gradient_width = (width - 2).min(60); // Limit width for better display

    for x in 0..gradient_width {
        // Create a rainbow effect by cycling through hue
        let hue = (x as f32 / gradient_width as f32) * 360.0;
        let (r, g, b) = hsl_to_rgb(hue, 1.0, 0.5);

        let color = ColorPair::new(Color::rgb(r, g, b), Color::Black);
        window.write_str_colored(gradient_y, x + 1, "█", color)?;
    }

    Ok(())
}

fn draw_color_themes(window: &mut dyn Window, start_y: u16) -> minui::Result<()> {
    window.write_str(start_y, 0, "Color Themes:")?;

    // Sunset theme
    window.write_str(start_y + 1, 0, "Sunset: ")?;
    window.write_str_colored(start_y + 1, 8, "█████", SUNSET_ORANGE)?;
    window.write_str_colored(start_y + 1, 13, "█████", SUNSET_RED)?;
    window.write_str_colored(start_y + 1, 18, "█████", SUNSET_PURPLE)?;

    // Ocean theme
    window.write_str(start_y + 2, 0, "Ocean:  ")?;
    window.write_str_colored(start_y + 2, 8, "█████", OCEAN_DEEP)?;
    window.write_str_colored(start_y + 2, 13, "█████", OCEAN_MEDIUM)?;
    window.write_str_colored(start_y + 2, 18, "█████", OCEAN_LIGHT)?;

    // Forest theme
    window.write_str(start_y + 3, 0, "Forest: ")?;
    window.write_str_colored(start_y + 3, 8, "█████", FOREST_DARK)?;
    window.write_str_colored(start_y + 3, 13, "█████", FOREST_BRIGHT)?;

    // Neon theme
    window.write_str(start_y + 4, 0, "Neon:   ")?;
    window.write_str_colored(start_y + 4, 8, "█████", NEON_PINK)?;
    window.write_str_colored(start_y + 4, 13, "█████", NEON_CYAN)?;
    window.write_str_colored(start_y + 4, 18, "█████", NEON_GREEN)?;

    Ok(())
}

fn draw_vertical_gradient(
    window: &mut dyn Window,
    start_y: u16,
    width: u16,
    height: u16,
) -> minui::Result<()> {
    if start_y + 10 > height {
        return Ok(()); // Not enough space
    }

    window.write_str(start_y, 0, "Vertical Blue-to-Red Gradient:")?;

    let gradient_height = (height - start_y - 2).min(8);
    let gradient_width = (width - 2).min(30);

    for y in 0..gradient_height {
        let ratio = y as f32 / gradient_height as f32;

        // Interpolate from blue to red
        let r = (ratio * 255.0) as u8;
        let g = 0;
        let b = ((1.0 - ratio) * 255.0) as u8;

        let color = ColorPair::new(Color::rgb(r, g, b), Color::Black);

        for x in 0..gradient_width {
            window.write_str_colored(start_y + 1 + y, x + 1, "█", color)?;
        }
    }

    Ok(())
}

fn draw_color_blocks(window: &mut dyn Window, height: u16) -> minui::Result<()> {
    let start_y = height.saturating_sub(6);

    window.write_str(start_y, 0, "RGB Color Examples:")?;

    // Show some specific RGB values with labels
    let colors = [
        (Color::rgb(255, 0, 0), "Pure Red (255,0,0)"),
        (Color::rgb(0, 255, 0), "Pure Green (0,255,0)"),
        (Color::rgb(0, 0, 255), "Pure Blue (0,0,255)"),
        (Color::rgb(255, 255, 0), "Yellow (255,255,0)"),
        (Color::rgb(255, 0, 255), "Magenta (255,0,255)"),
        (Color::rgb(0, 255, 255), "Cyan (0,255,255)"),
    ];

    for (i, (color, label)) in colors.iter().enumerate() {
        let y = start_y + 1 + (i as u16 / 3);
        let x = (i % 3) * 25;

        let color_pair = ColorPair::new(*color, Color::Black);
        window.write_str_colored(y, x as u16, "███", color_pair)?;
        window.write_str(y, x as u16 + 4, label)?;
    }

    Ok(())
}

pub const fn ansi(value: u8) -> Self

Create an ANSI color from the 256-color palette (0-255).

pub const fn fg(self) -> ColorPair

Create a ColorPair with this color as foreground and transparent background.

Examples

use minui::{Color, ColorPair};

let red_text = Color::Red.fg();
assert_eq!(red_text, ColorPair::new(Color::Red, Color::Transparent));

Examples found in repository

examples/syntax_profile_demo.rs (line 65)

fn draw_header(window: &mut dyn Window) -> minui::Result<()> {
    window.write_str_colored(
        0,
        0,
        "MinUI syntax + frame profiling demo (press q to quit)",
        Color::LightCyan.fg(),
    )?;
    window.write_str_colored(
        1,
        0,
        "write_spans_colored() is used below for token-based colouring.",
        Color::DarkGray.fg(),
    )?;
    Ok(())
}

fn draw_code(window: &mut dyn Window) -> minui::Result<()> {
    let kw = Color::LightMagenta.fg();
    let ident = Color::LightBlue.fg();
    let punct = Color::LightGray.fg();
    let number = Color::LightYellow.fg();
    let string = Color::LightGreen.fg();
    let comment = Color::DarkGray.fg();
    let plain = Color::White.fg();

    window.write_spans_colored(
        3,
        0,
        &[
            ColoredSpan::new("fn", kw),
            ColoredSpan::new(" ", plain),
            ColoredSpan::new("render_status", ident),
            ColoredSpan::new("(", punct),
            ColoredSpan::new("fps", ident),
            ColoredSpan::new(": ", punct),
            ColoredSpan::new("u32", ident),
            ColoredSpan::new(") {", punct),
        ],
    )?;

    window.write_spans_colored(
        4,
        0,
        &[
            ColoredSpan::new("    ", plain),
            ColoredSpan::new("let", kw),
            ColoredSpan::new(" budget_ms = ", plain),
            ColoredSpan::new("16", number),
            ColoredSpan::new(";", punct),
            ColoredSpan::new(" // ~60 FPS target", comment),
        ],
    )?;

    window.write_spans_colored(
        5,
        0,
        &[
            ColoredSpan::new("    ", plain),
            ColoredSpan::new("println!", ident),
            ColoredSpan::new("(", punct),
            ColoredSpan::new("\"fps={} budget={}ms\"", string),
            ColoredSpan::new(", fps, budget_ms", plain),
            ColoredSpan::new(");", punct),
        ],
    )?;

    window.write_spans_colored(6, 0, &[ColoredSpan::new("}", punct)])?;
    Ok(())
}

fn draw_profile_footer(state: &DemoState, window: &mut dyn Window) -> minui::Result<()> {
    let (w, h) = window.get_size();
    if h == 0 {
        return Ok(());
    }

    let y = h.saturating_sub(1);
    let profile = state.latest_profile.lock().ok().and_then(|g| *g);

    if let Some(p) = profile {
        let colour = if p.over_budget {
            Color::LightRed.fg()
        } else {
            Color::LightGreen.fg()
        };
        let budget_ms = p.budget.map(|d| d.as_millis()).unwrap_or(0);
        let line = format!(
            "frame={} events={} total={}ms input={}ms update={}ms draw={}ms budget={}ms over_budget={}",
            state.frame_count,
            p.events_processed,
            p.frame_time.as_millis(),
            p.input_poll_time.as_millis(),
            p.update_time.as_millis(),
            p.draw_time.as_millis(),
            budget_ms,
            p.over_budget
        );
        let clipped = clip_to_cells(&line, w, TabPolicy::SingleCell);
        window.write_str_colored(y, 0, &clipped, colour)?;
    } else {
        window.write_str_colored(y, 0, "Waiting for frame profile...", Color::DarkGray.fg())?;
    }

    Ok(())
}

pub const fn bg(self) -> ColorPair

Create a ColorPair with this color as background and default foreground.

Examples

use minui::{Color, ColorPair};

let white_bg = Color::White.bg();
assert_eq!(white_bg, ColorPair::new(Color::Reset, Color::White));

pub fn to_crossterm(self) -> CrosstermColor

Converts to crossterm color type (used internally).

Trait Implementations

impl Clone for Color

fn clone(&self) -> Color

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Color

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for Color

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Color

fn eq(&self, other: &Color) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Color

impl Eq for Color

impl StructuralPartialEq for Color