Crate reedline[][src]

Expand description

reedline \|/

A readline replacement written in Rust

Reedline is a project to create a readline-style crate for Rust that supports many of the modern conveniences of CLIs, including syntax highlighting, completions, multiline support, Unicode support, and more.

Basic example

// Create a default reedline object to handle user input

use reedline::{DefaultPrompt, Reedline, Signal};
use std::io;

 let mut line_editor = Reedline::create()?;
 let prompt = DefaultPrompt::default();

 loop {
     let sig = line_editor.read_line(&prompt);
     match sig {
         Ok(Signal::Success(buffer)) => {
             println!("We processed: {}", buffer);
         Ok(Signal::CtrlD) | Ok(Signal::CtrlC) => {
             let _ = line_editor.print_crlf();
         Ok(Signal::CtrlL) => {
         x => {
             println!("Event: {:?}", x);

Integrate with custom Keybindings

// Configure reedline with custom keybindings

//    [dependencies]
//    crossterm = "*"

use std::io;
use {
  crossterm::event::{KeyCode, KeyModifiers},
  reedline::{default_emacs_keybindings, EditCommand, Reedline, Emacs, ReedlineEvent},

let mut keybindings = default_emacs_keybindings();
let edit_mode = Box::new(Emacs::new(keybindings));

let mut line_editor = Reedline::create()?.with_edit_mode(edit_mode);

Integrate with custom History

// Create a reedline object with history support, including history size limits

use std::io;
use reedline::{FileBackedHistory, Reedline};

let history = Box::new(
    FileBackedHistory::with_file(5, "history.txt".into())
        .expect("Error configuring history with file"),
let mut line_editor = Reedline::create()?
    .expect("Error configuring reedline with history");

Integrate with custom Highlighter

// Create a reedline object with highlighter support

use std::io;
use reedline::{DefaultHighlighter, Reedline};

let commands = vec![
  "hello world".into(),
  "hello world reedline".into(),
  "this is the reedline crate".into(),
let mut line_editor =

Integrate with custom Tab-Handler

// Create a reedline object with tab completions support

use std::io;
use reedline::{DefaultCompleter, DefaultCompletionActionHandler, Reedline};

let commands = vec![
  "hello world".into(),
  "hello world reedline".into(),
  "this is the reedline crate".into(),
let completer = Box::new(DefaultCompleter::new_with_wordlen(commands.clone(), 2));

let mut line_editor = Reedline::create()?.with_completion_action_handler(Box::new(

Integrate with custom Hinter

// Create a reedline object with in-line hint support

//    [dependencies]
//    nu-ansi-term = "*"

use std::io;
use {
  nu_ansi_term::{Color, Style},
  reedline::{DefaultCompleter, DefaultHinter, Reedline},

let commands = vec![
  "hello world".into(),
  "hello world reedline".into(),
  "this is the reedline crate".into(),
let completer = Box::new(DefaultCompleter::new_with_wordlen(commands.clone(), 2));

let mut line_editor = Reedline::create()?.with_hinter(Box::new(
  .with_completer(completer) // or .with_history()
  // .with_inside_line()

Are we prompt yet? (Development status)

This crate is currently under active development in JT’s live-coding streams. If you want to see a feature, jump by the streams, file an issue or contribute a PR!

  • Basic unicode grapheme aware cursor editing.
  • Configurable prompt
  • Basic EMACS-style editing shortcuts.
  • Configurable keybindings.
  • Basic system integration with clipboard or optional stored history file.
  • Content aware highlighting.
  • Autocompletion.
  • Undo support.
  • Multiline aware editing with line completion validation.

For a more detailed roadmap check out TODO.txt.

Join the vision discussion in the vision milestone list by contributing suggestions or voting.


For currently more mature Rust line editing check out:


A default completer that can detect keywords

A simple handler that will do a cycle-based rotation through the options given by the Completer

A simple, example highlighter that shows how to highlight keywords

A default example hinter that use the completions or the history to show a hint to the user

Simple two-line Prompt displaying the current working directory and the time above the entry line.

A default validator which checks for mismatched quotes

This parses the incoming Events like a emacs style-editor

Stateful history that allows up/down-arrow browsing with an internal cursor.

A representation of the history search

Line editor engine

A span of source code, with positions in bytes

A representation of a buffer with styling, used for doing syntax highlighting

This parses incomming input Events like a Vi-Style editor


Editing actions which can be mapped to key bindings.

Modes that the prompt can be in

The current success/failure of the history search

The vi-specific modes that the prompt can be in

Reedline supported actions.

Valid ways how [Reedline::read_line()] can return

Whether or not the validation shows the input was complete


Default size of the FileBackedHistory used when calling FileBackedHistory::default()


The default color for the prompt

The default prompt indicator


The handler for when the user begins a completion action, often using the tab key This handler will then present the options to the user, allowing them to navigate the options and pick the completion they want

A trait that defines how to convert a line and position to a list of potential completions in that position.

Define the style of parsing for the edit events Available default options:

The syntax highlighting trait. Implementers of this trait will take in the current string and then return a StyledText object, which represents the contents of the original line as styled strings

A trait that’s responsible for returning the hint for the current line and position Hints are often shown in-line as part of the buffer, showing the user text they can accept or ignore

The trait that handles history activity, which includes the history buffer and navigating the history

API to provide a custom prompt.

The syntax validation trait. Implementers of this trait will check to see if the current input is incomplete and spans multiple lines


Returns the current default emacs keybindings