Struct Console 

pub struct Console {
    pub file: Box<dyn Write + Send>,
    pub color_system: ColorSystem,
    pub theme: Theme,
    pub options: ConsoleOptions,
    pub quiet: bool,
    pub soft_wrap: bool,
    /* private fields */
}

The main console for rendering rich output.

Fields

file: Box<dyn Write + Send>

The output writer.

color_system: ColorSystem

Detected color system.

theme: Theme

Current theme.

options: ConsoleOptions

Default options.

quiet: bool

If true, suppress all output.

soft_wrap: bool

If true, text wraps at word boundaries.

Implementations

impl Console

pub fn new() -> Self

Create a new Console writing to stdout.

pub fn with_file(file: Box<dyn Write + Send>) -> Self

Create a Console that writes to a file.

pub fn set_width(&mut self, width: usize)

Set the console width (overrides auto-detected terminal width).

pub fn set_height(&mut self, height: usize)

Set the console height.

pub fn width(&self) -> usize

Get the effective width.

pub fn height(&self) -> usize

Get the effective height.

pub fn render_lines( &self, renderable: &dyn Renderable, options: &ConsoleOptions, style: Option<&Style>, _pad: bool, ) -> Vec<Vec<Segment>>

Render a renderable and return the segment lines.

pub fn get_style(&self, name: &str, default: &str) -> Option<Style>

Look up a style by name from the theme.

pub fn render_str(&self, text: &str, style: &str) -> Text

Render a string (with optional style).

pub fn print(&mut self, objects: &[&dyn Renderable], sep: &str, end: &str)

Print one or more renderable objects, separated by sep, ending with end.

pub fn println(&mut self, renderable: &dyn Renderable)

Print a single renderable followed by a newline.

pub fn print_str(&mut self, text: &str)

Print a plain string (supports markup by default when markup is enabled).

pub fn print_json(&mut self, data: &Value)

Print formatted JSON.

pub fn clear(&mut self)

Clear the screen.

pub fn show_cursor(&mut self)

Show the cursor.

pub fn hide_cursor(&mut self)

Hide the cursor.

pub fn set_window_title(&mut self, title: &str)

Set the terminal window title.

pub fn color_ansi(&self, color: &Color) -> String

Get the ANSI escape string for a given color as this console supports.

pub fn render( &self, renderable: &dyn Renderable, options: &ConsoleOptions, ) -> Vec<Segment>

Render a renderable by recursively flattening nested items into segments. This is equivalent to Python Rich’s Console.render(). It handles Group composition and any renderable that yields other renderables.

pub fn measure( &self, renderable: &dyn Renderable, options: &ConsoleOptions, ) -> Measurement

Measure a renderable’s width constraints. Equivalent to Python Rich’s Measurement.get(console, options, renderable).

pub fn rule( &mut self, title: impl Into<String>, characters: Option<&str>, style: Option<Style>, align: Option<AlignMethod>, )

Render a rule with the given title. Equivalent to Console.rule().

pub fn bell(&mut self)

Output a bell character.

pub fn line(&mut self, count: usize)

Output blank lines.

pub fn log(&mut self, objects: &[&dyn Renderable])

Output a log entry with timestamp, caller info.

pub fn push_theme(&mut self, theme: Theme)

Push a theme onto the stack.

pub fn pop_theme(&mut self)

Pop the current theme, restoring the previous one.

pub fn export_html(&self, renderable: &dyn Renderable) -> String

Export the current console output as an HTML document.

Renders the given renderable and wraps it in a styled HTML page.

pub fn save_html( &self, path: impl AsRef<Path>, renderable: &dyn Renderable, ) -> Result<()>

Save rendered output as an HTML file.

pub fn export_svg(&self, renderable: &dyn Renderable) -> String

Export the current console output as an SVG document.

pub fn save_svg( &self, path: impl AsRef<Path>, renderable: &dyn Renderable, ) -> Result<()>

Save rendered output as an SVG file.

pub fn export_text(&self, renderable: &dyn Renderable) -> String

Export the current console output as plain text (strips ANSI).

pub fn save_text( &self, path: impl AsRef<Path>, renderable: &dyn Renderable, ) -> Result<()>

Save rendered output as a plain text file.

pub fn set_quiet(&mut self, quiet: bool)

Set the quiet flag (suppress all output when true).

pub fn quiet(self, quiet: bool) -> Self

Builder-style setter for quiet.

pub fn set_soft_wrap(&mut self, soft_wrap: bool)

Set the soft-wrap flag (wrap text at word boundaries when true).

pub fn soft_wrap(self, soft_wrap: bool) -> Self

Builder-style setter for soft_wrap.

pub fn input(&mut self, prompt: &str, password: bool) -> String

Read a line of input from the user.

Writes prompt to the console, then reads a line from stdin. When password is true, the input is masked with * characters (using raw terminal mode via crossterm).

pub fn screen(&mut self) -> ScreenContext

Create a ScreenContext that enters the alternate screen buffer. The context automatically exits the alternate screen when dropped.

pub fn set_alt_screen(&mut self, enable: bool)

Enter or exit the alternate screen buffer by writing the corresponding escape sequences (\x1b[?1049h / \x1b[?1049l).

pub fn is_terminal(&self) -> bool

Get whether the output is a terminal.

pub fn set_size(&mut self, width: usize, height: usize)

Set the terminal size (overrides auto-detected dimensions).

pub fn on_broken_pipe(&self)

Handle broken pipe errors gracefully.

In Rust, write() returns ErrorKind::BrokenPipe instead of raising SIGPIPE, so broken pipes are not fatal. The Console already uses let _ = write!(...) throughout, which silently discards all write errors including EPIPE. This method is provided for API compatibility with Python Rich and as a documentation point.

impl Console

pub fn begin_capture(&mut self)

Start capturing all output. All subsequent writes to this console are redirected to an internal buffer. Call end_capture to stop capturing and retrieve the captured content.

pub fn end_capture(&mut self) -> Capture

End capture mode and return the Capture containing all output written while capturing was active. The console’s output is restored to its original destination.

pub fn capture<F: FnOnce(&mut Self)>(&mut self, f: F) -> String

Run the given closure with output captured, returning the captured text.

This is the most ergonomic way to capture output in Rust:

let mut console = Console::new();
let output = console.capture(|c| {
    c.print_str("Hello, world!");
});
assert_eq!(output, "Hello, world!");

pub fn pager(&mut self, styles: bool) -> PagerContext

Get a PagerContext. Content rendered while the context is alive is collected and displayed through the system pager ($PAGER or less) when the context is dropped.

styles controls whether ANSI styles are preserved when paging.

pub fn input_renderable(&mut self, prompt: &dyn Renderable) -> String

Display a Renderable prompt and read a line of input from stdin.

The prompt is rendered through the console’s current options and theme.

pub fn print_exception(&mut self, _width: Option<usize>, _extra_lines: usize)

Print the current exception as a rich traceback.

In Rust, this is a best-effort rendering; it captures the current thread’s panic info if available. width overrides the output width, and extra_lines controls how many lines of source context to show around each frame.

pub fn print_json_str(&mut self, json: &str)

Pretty-print a JSON string. Parses the string and renders it with syntax highlighting.

pub fn render_to_lines( &self, renderable: &dyn Renderable, options: &ConsoleOptions, ) -> Vec<Vec<Segment>>

Render a renderable to a vector of segment lines.

This is the lower-level render entry point, returning raw lines instead of an ANSI string. Compare with render which returns flat segments.

pub fn render_ansi(&self, text: &str) -> String

Render a plain string to ANSI text, applying the current theme and styles. Returns the ANSI-formatted string.

pub fn export_svg_opts(&self, options: &ExportSvgOptions) -> String

Export the console output as an SVG document with explicit options.

This delegates to crate::export::export_svg with the given ExportSvgOptions.

pub fn size(&self) -> ConsoleDimensions

Get the terminal size as ConsoleDimensions.

pub fn is_dumb_terminal(&self) -> bool

Check if the terminal is a “dumb” terminal (no color support).

pub fn is_alt_screen(&self) -> bool

Check if the console is currently in the alternate screen buffer.

pub fn set_cursor_visible(&mut self, visible: bool)

Show or hide the cursor based on the boolean parameter.

true shows the cursor, false hides it. Tracks the current state so it can be queried via internal fields.

pub fn use_theme(&mut self, theme: Theme) -> ThemeContext

Temporarily switch to a different theme. Returns a ThemeContext that restores the original theme when dropped.

Example

let mut console = Console::new();
let custom = Theme::new();
{
    let _ctx = console.use_theme(custom);
    // console uses custom theme here
}
// original theme restored here

pub fn clear_live(&mut self)

Clear the live display region. When in alt-screen mode, this clears the entire alternate screen. Otherwise, it’s equivalent to clear.

pub fn set_live(&mut self, _live: &Live)

Set the active live display. Stores a reference to the [Live] renderer for integration with the console’s rendering pipeline.

Note: Live manages its own refresh cycle; this method is primarily for API compatibility with Python Rich.

pub fn update_screen( &mut self, renderable: &dyn Renderable, options: Option<&ConsoleOptions>, )

Update the full screen (enter alt-screen, render content, exit).

Clears the screen and renders the given renderable. If options is None, the console’s current options are used.

pub fn update_screen_lines( &mut self, lines: &[Vec<Segment>], options: Option<&ConsoleOptions>, )

Update the screen from pre-rendered lines of segments.

Takes already-rendered lines and displays them as the full screen content, clearing existing content first.

pub fn push_render_hook(&mut self, hook: RenderHook)

Add a RenderHook to the console. Hooks are applied in order and can modify the rendered lines before they are displayed.

pub fn pop_render_hook(&mut self) -> Option<RenderHook>

Remove and return the most recently added RenderHook, if any.

Trait Implementations

impl Debug for Console

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

Formats the value using the given formatter.

impl Default for Console

fn default() -> Self

Returns the “default value” for a type.