Colored Terminal Output

20 min read

How to add color and styling to a command-line tool’s output in Rust, the way you would with chalk or picocolors in Node.js — and, crucially, how to make that color disappear cleanly when output is piped to a file or when the user sets NO_COLOR.

Quick Overview

Color in a terminal is just ANSI escape codes — short byte sequences like \x1b[32m (green on) and \x1b[39m (default foreground) wrapped around your text. In Node.js you reach for chalk, picocolors, or kleur; in Rust the go-to crates are owo-colors (zero-cost styling extension methods), anstream (a smart stdout/stderr that strips color when it shouldn’t be there), anstyle (the style vocabulary clap and Cargo speak), and console (batteries-included, auto-detecting). The single most important thing this page teaches: respect NO_COLOR and don’t emit escape codes into pipes — getting this right is the difference between a polished tool and one that dumps \x1b[32m garbage into log files.

The current stable toolchain is Rust 1.96.0 on the 2024 edition; cargo new selects it automatically.

TypeScript/JavaScript Example

In Node.js, chalk is the household name, though the tiny picocolors has largely won on size and speed. Both auto-detect whether output is a terminal and honor the NO_COLOR / FORCE_COLOR conventions for you.

1
// npm install chalk    (chalk v5 is ESM-only)
2
import chalk from "chalk";
3

4
// Basic colors and styles
5
console.log(chalk.green("Success!"));
6
console.log(chalk.yellow("Warning!"));
7
console.log(chalk.red.bold("Error!"));
8
console.log(`${chalk.blue("INFO")} Server started`);
9

10
// Background colors, combinations, truecolor
11
console.log(chalk.white.bgRed.bold("Alert"));
12
console.log(chalk.dim("dimmed note"));
13
console.log(chalk.underline("underlined"));
14
console.log(chalk.rgb(255, 128, 0)("custom rgb"));
15

16
// A cargo-style diagnostic
17
function report(level: "info" | "warning" | "error", message: string) {
18
  const tag = {
19
    info: chalk.green.bold("info"),
20
    warning: chalk.yellow.bold("warning"),
21
    error: chalk.red.bold("error"),
22
  }[level];
23
  const line = `${tag}: ${message}`;
24
  if (level === "error") console.error(line);
25
  else console.log(line);
26
}
27

28
report("info", "compiling 12 modules");
29
report("error", "could not build");

Chalk decides at runtime whether to emit codes. If you run node app.js | cat, or set NO_COLOR=1, chalk produces plain text automatically. That auto-detection is the behavior we want to reproduce in Rust — and as you’ll see, not every Rust crate does it for you by default.

Rust Equivalent

The idiomatic modern stack is owo-colors for the styling syntax plus anstream for a terminal-aware output stream. owo-colors gives you chalk-like extension methods; anstream’s println! is a drop-in that strips the codes when the destination is not a real terminal or when NO_COLOR is set.

Add the dependencies (in a fresh cargo new project):

1
cargo add owo-colors
2
cargo add anstream

1
use anstream::println; // terminal-aware: strips ANSI when not a TTY / NO_COLOR set
2
use owo_colors::OwoColorize;
3

4
fn main() {
5
    // Basic colors and styles — same vocabulary as chalk
6
    println!("{}", "Success!".green());
7
    println!("{}", "Warning!".yellow());
8
    println!("{}", "Error!".red().bold());
9
    println!("{} {}", "INFO".blue(), "Server started");
10

11
    // Background colors, combinations, truecolor
12
    println!("{}", "Alert".white().on_red().bold());
13
    println!("{}", "dimmed note".dimmed());
14
    println!("{}", "underlined".underline());
15
    println!("{}", "custom rgb".truecolor(255, 128, 0));
16
}

Tip: The split is deliberate. owo-colors only describes the style; anstream decides whether to keep it. You can swap either piece independently — e.g. use owo-colors with a plain std::println! and your own detection, or use anstream with anstyle instead of owo-colors.

Here is the same report helper, written so color is automatically disabled in pipes and under NO_COLOR:

1
use anstream::{eprintln, println};
2
use owo_colors::OwoColorize;
3
use std::fmt::Display;
4

5
enum Level {
6
    Info,
7
    Warn,
8
    Error,
9
}
10

11
impl Level {
12
    fn label(&self) -> String {
13
        match self {
14
            Level::Info => "info".green().bold().to_string(),
15
            Level::Warn => "warning".yellow().bold().to_string(),
16
            Level::Error => "error".red().bold().to_string(),
17
        }
18
    }
19
}
20

21
fn report(level: Level, message: impl Display) {
22
    let line = format!("{}: {}", level.label(), message);
23
    match level {
24
        Level::Error => eprintln!("{line}"),
25
        _ => println!("{line}"),
26
    }
27
}
28

29
fn main() {
30
    report(Level::Info, "compiling 12 crates");
31
    report(Level::Warn, "unused import: `std::env`");
32
    report(Level::Error, "could not compile `app` (bin \"app\")");
33
}

Run through a pipe, the ANSI codes are gone:

1
cargo run -q | cat

1
info: compiling 12 crates
2
warning: unused import: `std::env`

(The error line goes to stderr, so it doesn’t show in the piped stdout — exactly like Cargo.)

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

use owo_colors::OwoColorize; brings a trait into scope that adds methods like .green(), .bold(), and .on_red() to every type that implements Display (and Debug). This is the same ergonomic trick TypeScript devs know from prototype extension, but checked at compile time.

The key subtlety: .green() does not return a String. It returns a tiny wrapper struct — FgColorDisplay<'_, Red, &str> (here Red is shorthand for owo_colors::colors::Red, the fully-qualified path the compiler prints in the Pitfall 1 error below) — that holds a reference to your value and remembers the style. No allocation, no escape codes are produced until the value is actually formatted. When you eventually println!("{}", x.green()), the wrapper’s Display implementation writes \x1b[32m, then your text, then \x1b[39m. This laziness is why chaining (.red().bold()) is free and why owo-colors advertises itself as zero-allocation.

Piping the basic example to a file and inspecting the raw bytes makes the codes visible (here shown as Rust byte-string escapes):

1
"\x1b[32mSuccess!\x1b[39m\n"          // .green()
2
"\x1b[1m\x1b[31mError!\x1b[39m\x1b[0m\n"  // .red().bold()
3
"\x1b[1m\x1b[37;41mAlert\x1b[0m\x1b[0m\n" // .white().on_red().bold()
4
"\x1b[38;2;255;128;0mcustom rgb\x1b[39m\n" // .truecolor(255,128,0)

\x1b[32m turns the foreground green; \x1b[39m resets just the foreground; \x1b[1m is bold and \x1b[0m is a full reset; \x1b[38;2;R;G;Bm is 24-bit truecolor.

The catch: owo-colors styles unconditionally

By default, "x".green() always emits the codes — it does no terminal detection. That is the opposite of chalk’s default. If you println! it straight to a redirected stdout, the escape bytes land in the file. That’s why we pair it with anstream.

anstream: a terminal-aware `println!`

anstream provides anstream::stdout() / anstream::stderr() and the macros anstream::println! / anstream::eprintln!. They wrap the real stream in an adapter that:

Keeps ANSI codes when the stream is a real terminal that supports them.
Strips ANSI codes when the stream is redirected to a file or pipe.
Strips codes when NO_COLOR is set (to a non-empty value).
On legacy Windows consoles without ANSI support, translates codes into the appropriate console API calls.

So you keep styling unconditionally with owo-colors and let anstream make the keep-or-strip decision once, at the output boundary. Running the build-reporter example four ways shows the decision matrix (raw bytes shown):

1
# Piped (stdout is not a terminal) — codes stripped:
2
"info: compiling 12 crates\n"
3

4
# Real terminal, NO_COLOR unset — codes kept:
5
"\x1b[1m\x1b[32minfo\x1b[39m\x1b[0m: compiling 12 crates\n"
6

7
# Real terminal, NO_COLOR=1 — codes stripped:
8
"info: compiling 12 crates\n"
9

10
# Piped but CLICOLOR_FORCE=1 — codes kept (forced on):
11
"\x1b[1m\x1b[32minfo\x1b[39m\x1b[0m: compiling 12 crates\n"

These four behaviors are the entire job of a well-behaved CLI’s color handling, and anstream gives them to you for free.

owo-colors’ built-in detection: `if_supports_color`

If you’d rather not route output through anstream, owo-colors can do the detection itself via if_supports_color. Enable the feature first:

1
cargo add owo-colors --features supports-colors

1
use owo_colors::{OwoColorize, Stream};
2

3
fn main() {
4
    // Styles ONLY when the chosen stream supports color
5
    // (TTY + NO_COLOR honored + terminal capability check).
6
    println!(
7
        "{}",
8
        "conditional".if_supports_color(Stream::Stdout, |t| t.green())
9
    );
10
}

The closure runs (applying the style) only when the stream supports color. Verified across environments (raw bytes):

1
# Piped (not a TTY):                       "conditional\n"
2
# Real terminal, NO_COLOR unset:           "\x1b[32mconditional\x1b[39m\n"
3
# Real terminal, NO_COLOR=1:               "conditional\n"

Under the hood this uses the supports-color crate, which is also what powers the optional feature’s checks for NO_COLOR, CLICOLOR, CLICOLOR_FORCE, and TERM=dumb.

console: the batteries-included, auto-detecting option

The console crate (from the indicatif family — see progress-bars.md) takes the chalk approach: console::style(..) returns a StyledObject that auto-detects by default, so you don’t need a separate stream.

1
cargo add console

1
use console::style;
2

3
fn main() {
4
    // Auto-detects TTY + NO_COLOR/CLICOLOR; only emits ANSI when appropriate.
5
    println!("{}", style("Deploy succeeded").green().bold());
6
    println!("{}", style("Retrying...").yellow());
7

8
    // Override the decision explicitly when you must:
9
    println!("{}", style("always red").red().force_styling(true));
10
}

Piped, the auto-detecting styles vanish but the forced one survives (raw bytes):

1
"Deploy succeeded\nRetrying...\n\x1b[31malways red\x1b[0m\n"

This is the closest one-crate analog to chalk’s behavior.

anstyle: the shared style vocabulary

anstyle is a tiny, dependency-free crate that defines Style, Color, and AnsiColor. It is what clap, Cargo, and anstream use to talk about styles in a neutral way. You rarely reach for it directly unless you’re integrating with clap’s help coloring (see clap-derive.md), but it’s worth recognizing:

1
use anstyle::{AnsiColor, Color, Style};
2

3
fn main() {
4
    let heading = Style::new()
5
        .bold()
6
        .fg_color(Some(Color::Ansi(AnsiColor::Green)));
7

8
    // `{heading}` writes the opening sequence; `{heading:#}` writes the reset.
9
    println!("{heading}Section{heading:#}");
10
    // Equivalent, spelled out:
11
    println!("{}Section{}", heading.render(), heading.render_reset());
12
}

Both lines produce the same bytes — \x1b[1m\x1b[32mSection\x1b[0m. anstyle is just the codes; it has no opinion about detection, which is precisely why higher-level crates build on it.

Key Differences

Concern	TypeScript (chalk / picocolors)	Rust
How styling attaches	Functions wrapping strings	Trait methods (`OwoColorize`) on any `Display` type, or `style(..)` wrappers
Return value of `.green()`	A new `string`	A lazy zero-cost wrapper (owo-colors) or `StyledObject` (console) — not a `String`
Auto terminal detection	Built in, on by default	owo-colors: off by default; console: on; anstream: on at the stream
`NO_COLOR` honored	Yes, automatically	Yes — via anstream, console, or owo-colors’ `supports-colors` feature; not by raw owo-colors
Force color	`FORCE_COLOR=1`	`CLICOLOR_FORCE=1` (anstream/console), or explicit `force_styling(true)` / `set_override(true)`
Output target awareness	One `console.log`	Choose: terminal-aware `anstream::println!` vs raw `std::println!`

The headline conceptual difference: chalk couples styling and detection; the Rust ecosystem deliberately decouples them. owo-colors answers “what does green look like?” while anstream answers “should this stream show green right now?”. This separation is more verbose for a hello-world, but it scales: you set the policy once at the output boundary and never branch on NO_COLOR in business logic. If you want the chalk-style all-in-one feel, reach for console.

Note: NO_COLOR (see https://no-color.org) is a cross-language convention: if the variable is present and non-empty, applications should not emit color. CLICOLOR_FORCE (non-empty) forces color on even when piped. These are the same conventions Cargo, ripgrep, and most modern CLIs follow.

Common Pitfalls

Pitfall 1: Treating a styled value like a `String`

A TypeScript dev expects "error".red() to be a string and tries to +-concatenate it like JavaScript:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let msg = "error".red() + ": something broke"; // does not compile (error[E0369])
5
    println!("{}", msg);
6
}

The real compiler error:

1
error[E0369]: cannot add `&str` to `FgColorDisplay<'_, owo_colors::colors::Red, &str>`
2
 --> src/main.rs:6:29
3
  |
4
6 |     let msg = "error".red() + ": something broke";
5
  |               ------------- ^ ------------------- &str
6
  |               |
7
  |               FgColorDisplay<'_, owo_colors::colors::Red, &str>
8
  |
9
note: the foreign item type `FgColorDisplay<'_, owo_colors::colors::Red, &str>`
10
      doesn't implement `Add<&str>`

.red() returns a lazy display wrapper, not a String. The fix is to format the pieces together rather than add them:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let msg = format!("{}: something broke", "error".red());
5
    println!("{msg}");
6
}

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Because raw owo-colors never detects the terminal, this writes escape bytes into a redirected file:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    // std::println! does NO detection; owo-colors does NO detection.
5
    println!("{}", "result".green()); // leaks \x1b[32m...\x1b[39m into pipes/files
6
}

Run cargo run | cat and you’ll see literal \x1b[32m in the output — the exact garbage-in-logs problem. Fix: import anstream::println (or use console::style, or gate with if_supports_color). One-line change:

1
use anstream::println; // ← decides keep-or-strip per stream
2
use owo_colors::OwoColorize;
3

4
fn main() {
5
    println!("{}", "result".green()); // stripped when piped, kept on a TTY
6
}

Pitfall 3: Padding a value that already contains ANSI bytes

Alignment specifiers count bytes, and ANSI escape sequences are bytes. owo-colors’ lazy wrapper is smart — it forwards the format spec to the inner text, so {:<10} pads correctly. But the moment you render a styled value into a String (with .to_string() or format!) and then try to pad it, the width counts the invisible escape bytes:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    // Pre-rendered into a String — width now counts the escape bytes:
5
    let pre_rendered = "OK".green().to_string();
6
    println!("[{:<10}]", pre_rendered); // NOT padded to 10 visible columns
7
}

Raw bytes: [\x1b[32mOK\x1b[39m] — no padding at all, because the formatter saw a 10-byte-ish string of mostly escape characters. Fix: pad the plain text first, then style the padded result:

1
use owo_colors::OwoColorize;
2

3
fn main() {
4
    let padded = format!("{:<10}", "OK");
5
    println!("[{}]", padded.green()); // visible "OK" + 8 spaces, then colored
6
}

Pitfall 4: Forgetting to enable the `supports-colors` feature

If you write use owo_colors::{OwoColorize, Stream}; and call if_supports_color without the feature, you actually get two errors. First, the unresolved import of Stream (E0432) — and this is the one that carries the “configured out / gated behind supports-colors” note. Second, a separate “method not found” (E0599) for if_supports_color, with no note attached:

1
error[E0432]: unresolved import `owo_colors::Stream`
2
 --> src/main.rs:1:31
3
  |
4
1 | use owo_colors::{OwoColorize, Stream};
5
  |                               ^^^^^^ no `Stream` in the root
6
  |
7
note: found an item that was configured out
8
  |
9
  |       --------------------------- the item is gated behind the `supports-colors` feature
10
...
11
  |     supports_colors::{Stream, SupportsColorsDisplay},
12
  |                       ^^^^^^
13

14
error[E0599]: no method named `if_supports_color` found for reference `&'static str` in the current scope
15
 --> src/main.rs:6:23
16
  |
17
6 |         "conditional".if_supports_color(Stream::Stdout, |t| t.green())
18
  |                       ^^^^^^^^^^^^^^^^^ method not found in `&'static str`

The lesson: the telltale “gated behind the supports-colors feature” note hangs off the Stream import error, not the method error. Fix: cargo add owo-colors --features supports-colors. (Or just use anstream/console, which need no extra feature flags.)

Best Practices

Decide color once, at the output boundary. Route all user-facing output through anstream::stdout()/stderr() (or their macros). Keep your styling code unconditional and free of if NO_COLOR checks.
Respect NO_COLOR and CLICOLOR_FORCE. Don’t roll your own env parsing if you can avoid it — anstream, console, and owo-colors’ supports-colors feature all implement the conventions correctly. The check is: NO_COLOR present and non-empty disables; CLICOLOR_FORCE present and non-empty forces on.
Send errors and diagnostics to stderr, normal output to stdout — and detect each independently. anstream’s stdout() and stderr() evaluate their own stream, so a tool whose stdout is piped but whose stderr is a terminal still colorizes errors.
Prefer named ANSI colors over truecolor for portability. .green() works on virtually every terminal; .truecolor(...) only renders correctly on 24-bit-capable terminals and silently degrades elsewhere.

Give users an explicit --color <auto|always|never> flag, mapping to anstream/owo-colors overrides. This is what Cargo and ripgrep do, and power users expect it. With owo-colors, owo_colors::set_override(true|false) sets a process-wide decision that if_supports_color honors:

1
use owo_colors::{OwoColorize, Stream};
2

3
fn main() {
4
    owo_colors::set_override(false); // e.g. from `--color never`
5
    println!(
6
        "{}",
7
        "forced off".if_supports_color(Stream::Stdout, |t| t.red())
8
    ); // prints plain, even on a TTY
9
}

Don’t hand-write escape codes like "\x1b[32m". They’re error-prone (easy to forget the reset), don’t get stripped automatically, and break on non-ANSI consoles. Let a crate own the bytes.

Warning: A subtle correctness issue: a manual or pre-rendered ANSI string that you later pass through a width/truncation formatter ({:.10}, {:<10}) will miscount, because escape bytes are counted but not displayed. Style after you’ve finished sizing the plain text. See Pitfall 3.

Real-World Example

A small cargo-style diagnostic reporter — the kind of output a linter or build tool emits — that colorizes on a terminal, goes plain in pipes and under NO_COLOR, and sends errors to stderr. This is compile-verified end to end.

Note: This example uses the unconditional-styling pattern (owo-colors always emits codes; anstream strips them at the boundary). With this pattern the user-facing color knobs are the environment variables anstream reads — NO_COLOR and CLICOLOR_FORCE — not owo_colors::set_override. set_override only governs if_supports_color and Style-based rendering (see Exercise 2), neither of which this code uses, so adding a set_override branch here would be a dead no-op. A real --color <auto|always|never> flag must instead be wired into anstream’s ColorChoice (e.g. via anstream::AutoStream constructed with an explicit choice). Exercise 2 shows the override path that does respond to set_override.

Cargo.toml:

1
[dependencies]
2
anstream = "1.0.0"
3
owo-colors = "4.3.0"

src/main.rs:

1
use anstream::{eprintln, println};
2
use owo_colors::OwoColorize;
3
use std::fmt::Display;
4

5
/// A diagnostic severity, like a compiler or linter would emit.
6
enum Level {
7
    Info,
8
    Warn,
9
    Error,
10
}
11

12
impl Level {
13
    /// The styled label. We always apply the style here; `anstream` strips it
14
    /// later if the destination is not a color-capable terminal.
15
    fn label(&self) -> String {
16
        match self {
17
            Level::Info => "info".green().bold().to_string(),
18
            Level::Warn => "warning".yellow().bold().to_string(),
19
            Level::Error => "error".red().bold().to_string(),
20
        }
21
    }
22
}
23

24
/// Print a `level: message` line, routing errors to stderr.
25
fn report(level: Level, message: impl Display) {
26
    let line = format!("{}: {}", level.label(), message);
27
    match level {
28
        Level::Error => eprintln!("{line}"),
29
        _ => println!("{line}"),
30
    }
31
}
32

33
fn main() {
34
    // No per-call color branching: styling is unconditional and `anstream`
35
    // strips it when stdout/stderr isn't a color-capable terminal. The user
36
    // controls color through the environment `anstream` reads — `NO_COLOR`
37
    // disables it, `CLICOLOR_FORCE` forces it on.
38
    report(Level::Info, "compiling 12 crates");
39
    report(
40
        Level::Warn,
41
        format!("unused variable: `{}`", "count".cyan()),
42
    );
43
    report(Level::Error, "could not compile `app` (bin \"app\")");
44
}

Behavior, verified by inspecting raw bytes:

Piped (cargo run -q | cat): every line is plain text; the error line is on stderr.
```
1
info: compiling 12 crates
2
warning: unused variable: `count`
```

On a real terminal (NO_COLOR unset): labels are colored, count is cyan. Raw stdout bytes:

1
"\x1b[1m\x1b[32minfo\x1b[39m\x1b[0m: compiling 12 crates\n"
2
"\x1b[1m\x1b[33mwarning\x1b[39m\x1b[0m: unused variable: `\x1b[36mcount\x1b[39m`\n"

NO_COLOR=1 on a terminal: anstream strips everything; output is identical to the piped case.

This is the whole discipline in one screen: style freely, decide once, route errors correctly, and the conventions take care of themselves.

Exercises

Exercise 1: A leak-proof status line

Difficulty: Easy

Objective: Print a green [ OK ] prefix followed by a message, such that the color disappears when output is piped.

Instructions:

Create a project and cargo add owo-colors anstream.
Write status("Database connected") that prints [ OK ] Database connected with [ OK ] in bold green.
Verify that cargo run -q | cat shows no escape codes, but a real terminal shows green.

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn status(message: &str) {
5
    // TODO: print a bold-green "[ OK ]" prefix, then the message
6
}
7

8
fn main() {
9
    status("Database connected");
10
}

Solution

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn status(message: &str) {
5
    // Style freely; anstream's println! strips codes when not a TTY / NO_COLOR set.
6
    println!("{} {message}", "[ OK ]".green().bold());
7
}
8

9
fn main() {
10
    status("Database connected");
11
}

Piped, this prints exactly [ OK ] Database connected with no escape bytes; on a terminal the prefix is bold green.

Exercise 2: Honor `--color=<auto|always|never>`

Difficulty: Medium

Objective: Add a color policy flag that overrides auto-detection, mirroring Cargo and ripgrep.

Instructions:

Read the first CLI argument. Map --color=always, --color=never, and anything else (auto) to a decision.
Use owo_colors::set_override(..) for always/never; leave it untouched for auto. Enable the supports-colors feature.
Print a line styled via if_supports_color and confirm: --color=always colors even when piped; --color=never is plain even on a TTY; with no flag, it follows the terminal and NO_COLOR.

1
use owo_colors::{OwoColorize, Stream};
2

3
fn main() {
4
    // TODO: parse args[1], set the override, then print a conditional-styled line
5
}

Solution

1
// Cargo.toml:
2
// owo-colors = { version = "4.3.0", features = ["supports-colors"] }
3
use owo_colors::{OwoColorize, Stream, Style};
4

5
fn main() {
6
    match std::env::args().nth(1).as_deref() {
7
        Some("--color=always") => owo_colors::set_override(true),
8
        Some("--color=never") => owo_colors::set_override(false),
9
        _ => {} // auto: if_supports_color does TTY + NO_COLOR detection
10
    }
11

12
    // Build the combined style up front so the closure can apply it in one call.
13
    // (Chaining two methods inside the closure, like `|t| t.green().bold()`,
14
    // fails to compile — the second method would borrow a temporary.)
15
    let style = Style::new().green().bold();
16
    println!(
17
        "{}",
18
        "build finished".if_supports_color(Stream::Stdout, |t| t.style(style))
19
    );
20
}

set_override(true) forces the closure to run (color on) regardless of TTY/NO_COLOR; set_override(false) forces it off; with neither, if_supports_color consults the stream and the NO_COLOR/CLICOLOR environment.

Exercise 3: A padded, colorized two-column report

Difficulty: Hard

Objective: Print an aligned two-column table (label left, value right) with colored labels — without the alignment breaking on the escape bytes.

Instructions:

Given pairs like ("Status", "online") and ("Latency", "12ms"), print each as label left-padded to 12 columns, then the value.
Color labels cyan and the "online" value green. The columns must line up visually.
The catch: you must pad the plain label to width before styling it (recall Pitfall 3). Verify alignment by piping to cat (codes stripped) — columns should still line up.

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn row(label: &str, value: &str) {
5
    // TODO: left-pad `label` to 12 columns of PLAIN text, then color it,
6
    // then print the value (green if "online", else default)
7
}
8

9
fn main() {
10
    row("Status", "online");
11
    row("Latency", "12ms");
12
    row("Region", "us-east-1");
13
}

Solution

1
use anstream::println;
2
use owo_colors::OwoColorize;
3

4
fn row(label: &str, value: &str) {
5
    // 1) Size the PLAIN text first so the width counts visible columns only.
6
    let padded = format!("{label:<12}");
7
    // 2) Style the already-padded label.
8
    let styled_label = padded.cyan();
9
    // 3) Conditionally color the value.
10
    if value == "online" {
11
        println!("{styled_label}{}", value.green().bold());
12
    } else {
13
        println!("{styled_label}{value}");
14
    }
15
}
16

17
fn main() {
18
    row("Status", "online");
19
    row("Latency", "12ms");
20
    row("Region", "us-east-1");
21
}

Piped output (codes stripped by anstream) lines up correctly:

1
Status      online
2
Latency     12ms
3
Region      us-east-1

On a terminal the labels are cyan and online is bold green, with the same alignment. Had we written format!("{:<12}", "Status".cyan()), the lazy owo-colors wrapper would actually still align (it forwards the spec) — but the moment you pre-render with .to_string(), alignment breaks. Padding the plain text first is the robust habit.

Colored Terminal Output

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

The catch: owo-colors styles unconditionally

anstream: a terminal-aware `println!`

owo-colors’ built-in detection: `if_supports_color`

console: the batteries-included, auto-detecting option

anstyle: the shared style vocabulary

Key Differences

Common Pitfalls

Pitfall 1: Treating a styled value like a `String`

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Pitfall 3: Padding a value that already contains ANSI bytes

Pitfall 4: Forgetting to enable the `supports-colors` feature

Best Practices

Real-World Example

Further Reading

Official Documentation

Exercises

Exercise 1: A leak-proof status line

Exercise 2: Honor `--color=<auto|always|never>`

Exercise 3: A padded, colorized two-column report

Colored Terminal Output

Quick Overview

TypeScript/JavaScript Example

Rust Equivalent

Detailed Explanation

owo-colors: zero-cost styling via an extension trait

The catch: owo-colors styles unconditionally

anstream: a terminal-aware println!

owo-colors’ built-in detection: if_supports_color

console: the batteries-included, auto-detecting option

anstyle: the shared style vocabulary

Key Differences

Common Pitfalls

Pitfall 1: Treating a styled value like a String

Pitfall 2: Using std::println! with owo-colors and leaking codes

Pitfall 3: Padding a value that already contains ANSI bytes

Pitfall 4: Forgetting to enable the supports-colors feature

Best Practices

Real-World Example

Further Reading

Official Documentation

Related Sections in This Guide

Exercises

Exercise 1: A leak-proof status line

Exercise 2: Honor --color=<auto|always|never>

Exercise 3: A padded, colorized two-column report

anstream: a terminal-aware `println!`

owo-colors’ built-in detection: `if_supports_color`

Pitfall 1: Treating a styled value like a `String`

Pitfall 2: Using `std::println!` with owo-colors and leaking codes

Pitfall 4: Forgetting to enable the `supports-colors` feature

Exercise 2: Honor `--color=<auto|always|never>`