🎨 make_colors

A simple, powerful, and cross-platform Rust library for adding colors to your terminal output with support for hex colors, RGB values, and rich text attributes.

✨ Features

• 🎨 Standard terminal colors - 16 ANSI colors with light variants
• 🌈 Hex color support - Use colors like #00FFFF, #FF5500
• 🎯 RGB color support - Full 24-bit color with RGB values (0-255)
• 🎭 16.7 Million Colors - True Color (24-bit) support like Python's rich
• 📝 Simple API - Easy to use functions and builder pattern
• 🖋 Text attributes - Bold, italic, underline, dim, blink, and more
• 🔧 Flexible notation - Full names, abbreviations, multiple formats
• 🚀 Zero dependencies - Lightweight and fast
• 🖥️ Cross-platform - Works on Windows, Linux, and macOS

📸 Screenshots

Basic Colors Example

Hex Colors & Gradients

Screenshots show output from cargo run --example basic and cargo run --example hex_test

📦 Installation

Add this to your Cargo.toml:

[dependencies]
make_colors = "0.1"

🚀 Quick Start

use make_colors::*;

fn main() {
    // Simple colored text
    println!("{}", make_colors("Hello World!", "red", None));

    // Text with background
    println!("{}", make_colors("Important Message", "white", Some("red")));

    // Using shortcuts
    println!("{}", make_colors("Quick and easy", "r", Some("bl")));

    // Hex colors (24-bit True Color)
    println!("{}", make_colors_hex("Cyan text", "#00FFFF", None).unwrap());

    // RGB colors (16.7 Million colors)
    println!("{}", make_colors_rgb("Custom color", (255, 100, 50), None));

    // With attributes
    println!("{}", make_colors_with_attrs("Bold text", "red", None, &["bold"]));

    // Builder pattern
    let colored = ColorBuilder::new("Styled text")
        .fg("green")
        .bold()
        .underline()
        .build();
    println!("{}", colored);
}

🎨 Color Reference

Available Colors

Color Preview

// Standard colors
println!("{}", make_colors("■ Black text", "black", None));
println!("{}", make_colors("■ Red text", "red", None));
println!("{}", make_colors("■ Green text", "green", None));
println!("{}", make_colors("■ Yellow text", "yellow", None));
println!("{}", make_colors("■ Blue text", "blue", None));
println!("{}", make_colors("■ Magenta text", "magenta", None));
println!("{}", make_colors("■ Cyan text", "cyan", None));
println!("{}", make_colors("■ White text", "white", None));

// Light variants
println!("{}", make_colors("■ Light Red", "lightred", None));
println!("{}", make_colors("■ Light Green", "lightgreen", None));
println!("{}", make_colors("■ Light Blue", "lightblue", None));
println!("{}", make_colors("■ Light Yellow", "lightyellow", None));

💡 Usage Examples

Basic Usage

use make_colors::*;

// Full color names
println!("{}", make_colors("Error", "red", Some("white")));

// Using shortcuts
println!("{}", make_colors("Success", "g", None));

// Mixed notation
println!("{}", make_colors("Warning", "yellow", Some("b")));

Hex Colors (24-bit True Color)

// Basic hex color
println!("{}", make_colors_hex("Cyan text", "#00FFFF", None).unwrap());

// Hex with background
println!("{}", make_colors_hex("Custom", "#FF5500", Some("#001122")).unwrap());

// Various hex colors
println!("{}", make_colors_hex("Orange", "#FF8800", None).unwrap());
println!("{}", make_colors_hex("Pink", "#FF1493", None).unwrap());
println!("{}", make_colors_hex("Purple", "#9932CC", None).unwrap());

// Material Design colors
println!("{}", make_colors_hex("Material Red", "#F44336", None).unwrap());
println!("{}", make_colors_hex("Material Blue", "#2196F3", None).unwrap());
println!("{}", make_colors_hex("Material Green", "#4CAF50", None).unwrap());

RGB Colors (16.7 Million Colors)

// Basic RGB
println!("{}", make_colors_rgb("Orange", (255, 165, 0), None));

// RGB with background
println!("{}", make_colors_rgb("Custom", (255, 100, 50), Some((0, 0, 0))));

// Various RGB colors
println!("{}", make_colors_rgb("Teal", (0, 128, 128), None));
println!("{}", make_colors_rgb("Gold", (255, 215, 0), None));
println!("{}", make_colors_rgb("Coral", (255, 127, 80), None));

// Create gradients
for i in 0..=10 {
    let r = 255 - (i * 25);
    let g = 0;
    let b = i * 25;
    print!("{}", make_colors_rgb("█", (r, g, b), None));
}
println!();

Text Attributes

// Single attribute
println!("{}", make_colors_with_attrs("Bold text", "red", None, &["bold"]));
println!("{}", make_colors_with_attrs("Underlined", "blue", None, &["underline"]));
println!("{}", make_colors_with_attrs("Italic", "green", None, &["italic"]));

// Multiple attributes
println!("{}", make_colors_with_attrs(
    "Bold + Underline", 
    "yellow", 
    None, 
    &["bold", "underline"]
));

// Available attributes: bold, dim, italic, underline, blink, reverse, hidden, strikethrough

ColorBuilder Pattern

// Basic builder
let text = ColorBuilder::new("Styled text")
    .fg("red")
    .bold()
    .build();
println!("{}", text);

// Builder with hex colors
let text = ColorBuilder::new("Hex styled")
    .fg_hex("#00FFFF").unwrap()
    .bg_hex("#000000").unwrap()
    .underline()
    .build();
println!("{}", text);

// Builder with RGB
let text = ColorBuilder::new("RGB styled")
    .fg_rgb(255, 100, 50)
    .bg_rgb(0, 0, 0)
    .bold()
    .italic()
    .build();
println!("{}", text);

// Chaining multiple attributes
let text = ColorBuilder::new("Multiple styles")
    .fg("green")
    .bg("black")
    .bold()
    .underline()
    .italic()
    .build();
println!("{}", text);

Macros

// Simple macro usage
println!("{}", color!("red", "Error message"));
println!("{}", color!("white", "red", "Important notice"));

// Hex color macro
println!("{}", color_hex!("#00FFFF", "Cyan text"));
println!("{}", color_hex!("#FF5500", "#000000", "Custom colors"));

Practical Examples

Status Messages

fn show_status(service: &str, status: &str) -> String {
    match status {
        "running" => make_colors(&format!("[✓] {}", service), "lightgreen", None),
        "stopped" => make_colors(&format!("[✗] {}", service), "lightred", None),
        _ => make_colors(&format!("[?] {}", service), "lightyellow", None),
    }
}

println!("{}", show_status("Web Server", "running"));
println!("{}", show_status("Database", "stopped"));
println!("{}", show_status("Cache", "unknown"));

Log Levels

fn log_message(level: &str, message: &str) -> String {
    let (fg, bg) = match level {
        "ERROR" => ("white", Some("red")),
        "WARN" => ("black", Some("yellow")),
        "INFO" => ("white", Some("blue")),
        "DEBUG" => ("white", Some("black")),
        _ => ("white", None),
    };
    
    format!(
        "{} {}", 
        make_colors(&format!(" {} ", level), fg, bg),
        message
    )
}

println!("{}", log_message("ERROR", "Connection failed"));
println!("{}", log_message("WARN", "Deprecated method"));
println!("{}", log_message("INFO", "Server started"));
println!("{}", log_message("DEBUG", "Variable value: 42"));

Progress Bar

fn progress_bar(current: usize, total: usize, width: usize) -> String {
    let percentage = current as f32 / total as f32;
    let filled = (width as f32 * percentage) as usize;
    let bar = "█".repeat(filled) + &"░".repeat(width - filled);
    
    let color = if percentage < 0.5 {
        "red"
    } else if percentage < 0.8 {
        "yellow"
    } else {
        "green"
    };
    
    make_colors(
        &format!("[{}] {}/{} ({:.1}%)", bar, current, total, percentage * 100.0),
        color,
        None
    )
}

// Usage
for i in (0..=100).step_by(10) {
    println!("{}", progress_bar(i, 100, 30));
}

Menu System

fn create_menu() {
    let options = vec![
        ("1", "Start Application", "green"),
        ("2", "Settings", "yellow"),
        ("3", "Help", "blue"),
        ("4", "Exit", "red"),
    ];
    
    println!("{}", make_colors(" 🎯 Main Menu ", "white", Some("blue")));
    println!();
    
    for (key, option, color) in options {
        println!("  {} {}", 
            make_colors(key, "white", Some(color)),
            option
        );
    }
    println!();
}

create_menu();

Gradient Generator

// Horizontal gradient
fn gradient_horizontal(text: &str, from_hex: &str, to_hex: &str) {
    let (r1, g1, b1) = hex_to_rgb(from_hex).unwrap();
    let (r2, g2, b2) = hex_to_rgb(to_hex).unwrap();
    
    let len = text.len();
    for (i, ch) in text.chars().enumerate() {
        let ratio = i as f32 / len as f32;
        let r = (r1 as f32 + (r2 as f32 - r1 as f32) * ratio) as u8;
        let g = (g1 as f32 + (g2 as f32 - g1 as f32) * ratio) as u8;
        let b = (b1 as f32 + (b2 as f32 - b1 as f32) * ratio) as u8;
        print!("{}", make_colors_rgb(&ch.to_string(), (r, g, b), None));
    }
    println!();
}

gradient_horizontal("GRADIENT TEXT", "#FF0000", "#0000FF");

🔧 API Reference

Functions

make_colors(text: &str, fg: &str, bg: Option<&str>) -> String

Main function to colorize text with named colors.

make_colors_with_attrs(text: &str, fg: &str, bg: Option<&str>, attrs: &[&str]) -> String

Colorize text with attributes (bold, italic, etc.).

make_colors_hex(text: &str, fg_hex: &str, bg_hex: Option<&str>) -> Result<String, MakeColorsError>

Colorize text using hex color codes (#RRGGBB).

make_colors_hex_with_attrs(text: &str, fg_hex: &str, bg_hex: Option<&str>, attrs: &[&str]) -> Result<String, MakeColorsError>

Colorize text using hex colors with attributes.

make_colors_rgb(text: &str, fg_rgb: (u8, u8, u8), bg_rgb: Option<(u8, u8, u8)>) -> String

Colorize text using RGB values.

make_colors_rgb_with_attrs(text: &str, fg_rgb: (u8, u8, u8), bg_rgb: Option<(u8, u8, u8)>, attrs: &[&str]) -> String

Colorize text using RGB values with attributes.

hex_to_rgb(hex: &str) -> Result<(u8, u8, u8), MakeColorsError>

Convert hex color string to RGB tuple.

ColorBuilder

Builder pattern for creating colored text:

ColorBuilder::new(text: &str)
    .fg(color: &str)                    // Set foreground color by name
    .bg(color: &str)                    // Set background color by name
    .fg_hex(hex: &str)                  // Set foreground by hex
    .bg_hex(hex: &str)                  // Set background by hex
    .fg_rgb(r: u8, g: u8, b: u8)        // Set foreground by RGB
    .bg_rgb(r: u8, g: u8, b: u8)        // Set background by RGB
    .bold()                             // Add bold attribute
    .italic()                           // Add italic attribute
    .underline()                        // Add underline attribute
    .dim()                              // Add dim attribute
    .blink()                            // Add blink attribute
    .reverse()                          // Add reverse attribute
    .attr(attr: &str)                   // Add custom attribute
    .build()                            // Build the colored string

Macros

color!(fg, text)                        // Simple colored text
color!(fg, bg, text)                    // Text with background
color_hex!(hex, text)                   // Hex colored text
color_hex!(fg_hex, bg_hex, text)        // Hex text with background

🖥️ Platform Support

Windows

• ✅ Windows 10+ (full ANSI support with 24-bit color)
• ✅ Windows Terminal - Excellent True Color support
• ✅ PowerShell 7+ - Full support
• ⚠️ CMD - Basic support (may need Windows Terminal for best results)
• ⚠️ Older Windows may require ANSICON

Linux/Unix

• ✅ Most modern terminals (xterm, gnome-terminal, konsole, etc.)
• ✅ Tmux/Screen - Full True Color support
• ✅ SSH sessions - Supported when terminal supports colors
• ✅ 24-bit True Color in most modern terminals

macOS

• ✅ Terminal.app - Full support
• ✅ iTerm2 - Excellent True Color support
• ✅ Other terminals - Generally well supported

True Color Support

This library uses 24-bit True Color (16.7 million colors) via ANSI escape sequences:

• \x1b[38;2;R;G;Bm for foreground colors
• \x1b[48;2;R;G;Bm for background colors

For best results, use a terminal that supports True Color:

• Windows Terminal ✅
• iTerm2 (macOS) ✅
• Gnome Terminal ✅
• Konsole ✅
• VSCode integrated terminal ✅

🎯 Best Practices

1. Use hex or RGB for precise colors - When you need exact brand colors or gradients
2. Use named colors for common cases - Simpler and more readable code
3. Test on target terminals - Ensure colors display correctly
4. Provide fallbacks - Handle environments without color support gracefully
5. Use attributes sparingly - Too many can reduce readability
6. Check True Color support - Not all terminals support 24-bit color

📚 Examples

Run the included examples:

# Basic colors and features
cargo run --example basic

# Full hex color test with gradients
cargo run --example hex_test

🧪 Testing

Run the test suite:

cargo test

Build documentation:

cargo doc --open

🆚 Comparison with Other Libraries

🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add some amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📝 Changelog

Version 0.1.0

• Initial release
• Support for 16 standard ANSI colors
• Hex color support (#RRGGBB)
• RGB color support (24-bit True Color)
• Text attributes (bold, italic, underline, etc.)
• Builder pattern
• Convenience macros
• Zero dependencies

📄 License

Licensed under the MIT License. See LICENSE for details.

👨‍💻 Author

Hadi Cahyadi 📧 cumulus13@gmail.com
🔗 GitHub: https://github.com/cumulus13
🔗 Repository: https://github.com/cumulus13/make_colors_rust

Support me on Patreon

🙏 Acknowledgments

Inspired by:

• make_colors (Python) - Original Python library
• rich (Python) - Python's rich text library
• colored (Rust) - Rust colored library

🌟 Related Projects

• make_colors (Python) - Python version with similar API

✨ Made with ❤️ for colorful Rust terminal experiences!

Support 16,777,216 colors ! 🎨🌈