diff --git a/Cargo.lock b/Cargo.lock
index d992443a04..d5d1e70c79 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2,6 +2,15 @@
 # It is not intended for manual editing.
 version = 3
 
+[[package]]
+name = "aho-corasick"
+version = "0.7.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e37cfd5e7657ada45f742d6e99ca5788580b5c529dc78faf11ece6dc702656f"
+dependencies = [
+ "memchr",
+]
+
 [[package]]
 name = "ansi_term"
 version = "0.12.1"
@@ -148,6 +157,7 @@ dependencies = [
  "nu-engine",
  "nu-parser",
  "nu-protocol",
+ "nu-table",
  "pretty_assertions",
  "reedline",
  "tempfile",
@@ -285,6 +295,7 @@ dependencies = [
  "glob",
  "nu-engine",
  "nu-protocol",
+ "nu-table",
 ]
 
 [[package]]
@@ -310,6 +321,15 @@ dependencies = [
  "codespan-reporting",
 ]
 
+[[package]]
+name = "nu-table"
+version = "0.36.0"
+dependencies = [
+ "nu-ansi-term",
+ "regex",
+ "unicode-width",
+]
+
 [[package]]
 name = "num-integer"
 version = "0.1.44"
@@ -494,12 +514,29 @@ dependencies = [
  "unicode-width",
 ]
 
+[[package]]
+name = "regex"
+version = "1.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d07a8629359eb56f1e2fb1652bb04212c072a87ba68546a04065d525673ac461"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
 [[package]]
 name = "regex-automata"
 version = "0.1.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
 
+[[package]]
+name = "regex-syntax"
+version = "0.6.25"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f497285884f3fcff424ffc933e56d7cbca511def0c9831a7f9b5f6153e3cc89b"
+
 [[package]]
 name = "remove_dir_all"
 version = "0.5.3"
diff --git a/Cargo.toml b/Cargo.toml
index 225d8c4f8a..ccbaff85e0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,6 +16,7 @@ nu-command = { path="./crates/nu-command" }
 nu-engine = { path="./crates/nu-engine" }
 nu-parser = { path="./crates/nu-parser" }
 nu-protocol = { path = "./crates/nu-protocol" }
+nu-table = { path = "./crates/nu-table" }
 
 # mimalloc = { version = "*", default-features = false }
 
diff --git a/crates/nu-command/Cargo.toml b/crates/nu-command/Cargo.toml
index 9ff9bd274f..574848b3a8 100644
--- a/crates/nu-command/Cargo.toml
+++ b/crates/nu-command/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2018"
 [dependencies]
 nu-protocol = { path = "../nu-protocol" }
 nu-engine = { path = "../nu-engine" }
+nu-table = { path = "../nu-table" }
 
 # Potential dependencies for extras
 glob = "0.3.0"
\ No newline at end of file
diff --git a/crates/nu-command/src/default_context.rs b/crates/nu-command/src/default_context.rs
index ed0b0fe8c3..f9a61a77b9 100644
--- a/crates/nu-command/src/default_context.rs
+++ b/crates/nu-command/src/default_context.rs
@@ -7,6 +7,7 @@ use nu_protocol::{
 
 use crate::{
     where_::Where, Alias, Benchmark, BuildString, Def, Do, Each, For, If, Length, Let, LetEnv, Ls,
+    Table,
 };
 
 pub fn create_default_context() -> Rc<RefCell<EngineState>> {
@@ -45,6 +46,8 @@ pub fn create_default_context() -> Rc<RefCell<EngineState>> {
 
         working_set.add_decl(Box::new(Ls));
 
+        working_set.add_decl(Box::new(Table));
+
         let sig = Signature::build("exit");
         working_set.add_decl(sig.predeclare());
         let sig = Signature::build("vars");
diff --git a/crates/nu-command/src/lib.rs b/crates/nu-command/src/lib.rs
index a5e036576d..2b7a3cac0a 100644
--- a/crates/nu-command/src/lib.rs
+++ b/crates/nu-command/src/lib.rs
@@ -11,6 +11,7 @@ mod length;
 mod let_;
 mod let_env;
 mod ls;
+mod table;
 mod where_;
 
 pub use alias::Alias;
@@ -26,3 +27,4 @@ pub use length::Length;
 pub use let_::Let;
 pub use let_env::LetEnv;
 pub use ls::Ls;
+pub use table::Table;
diff --git a/crates/nu-command/src/table.rs b/crates/nu-command/src/table.rs
new file mode 100644
index 0000000000..45109cec3f
--- /dev/null
+++ b/crates/nu-command/src/table.rs
@@ -0,0 +1,125 @@
+use std::collections::HashMap;
+
+use nu_protocol::ast::{Call, PathMember};
+use nu_protocol::engine::{Command, EvaluationContext};
+use nu_protocol::{Signature, Span, Value};
+use nu_table::StyledString;
+
+pub struct Table;
+
+//NOTE: this is not a real implementation :D. It's just a simple one to test with until we port the real one.
+impl Command for Table {
+    fn name(&self) -> &str {
+        "table"
+    }
+
+    fn usage(&self) -> &str {
+        "Render the table."
+    }
+
+    fn signature(&self) -> nu_protocol::Signature {
+        Signature::build("table")
+    }
+
+    fn run(
+        &self,
+        _context: &EvaluationContext,
+        call: &Call,
+        input: Value,
+    ) -> Result<nu_protocol::Value, nu_protocol::ShellError> {
+        match input {
+            Value::List { vals, .. } => {
+                let table = convert_to_table(vals);
+
+                if let Some(table) = table {
+                    let result = nu_table::draw_table(&table, 80, &HashMap::new());
+
+                    Ok(Value::String {
+                        val: result,
+                        span: call.head,
+                    })
+                } else {
+                    Ok(Value::Nothing { span: call.head })
+                }
+            }
+            Value::Stream { stream, .. } => {
+                let table = convert_to_table(stream);
+
+                if let Some(table) = table {
+                    let result = nu_table::draw_table(&table, 80, &HashMap::new());
+
+                    Ok(Value::String {
+                        val: result,
+                        span: call.head,
+                    })
+                } else {
+                    Ok(Value::Nothing { span: call.head })
+                }
+            }
+            x => Ok(x),
+        }
+    }
+}
+
+fn convert_to_table(iter: impl IntoIterator<Item = Value>) -> Option<nu_table::Table> {
+    let mut iter = iter.into_iter().peekable();
+
+    if let Some(first) = iter.peek() {
+        let mut headers = first.columns();
+        headers.insert(0, "#".into());
+
+        let mut data = vec![];
+
+        for (row_num, item) in iter.enumerate() {
+            let mut row = vec![row_num.to_string()];
+
+            for header in headers.iter().skip(1) {
+                let result = item.clone().follow_cell_path(&[PathMember::String {
+                    val: header.into(),
+                    span: Span::unknown(),
+                }]);
+
+                match result {
+                    Ok(value) => row.push(value.into_string()),
+                    Err(_) => row.push(String::new()),
+                }
+            }
+
+            data.push(row);
+        }
+
+        Some(nu_table::Table {
+            headers: headers
+                .into_iter()
+                .map(|x| StyledString {
+                    contents: x,
+                    style: nu_table::TextStyle::default_header(),
+                })
+                .collect(),
+            data: data
+                .into_iter()
+                .map(|x| {
+                    x.into_iter()
+                        .enumerate()
+                        .map(|(col, y)| {
+                            if col == 0 {
+                                StyledString {
+                                    contents: y,
+                                    style: nu_table::TextStyle::default_header(),
+                                }
+                            } else {
+                                StyledString {
+                                    contents: y,
+                                    style: nu_table::TextStyle::basic_left(),
+                                }
+                            }
+                        })
+                        .collect::<Vec<StyledString>>()
+                })
+                .collect(),
+            theme: nu_table::Theme::rounded(),
+        })
+    } else {
+        None
+    }
+}
diff --git a/crates/nu-protocol/src/value/mod.rs b/crates/nu-protocol/src/value/mod.rs
index c78e106f51..094ca2d590 100644
--- a/crates/nu-protocol/src/value/mod.rs
+++ b/crates/nu-protocol/src/value/mod.rs
@@ -288,6 +288,13 @@ impl Value {
     pub fn is_true(&self) -> bool {
         matches!(self, Value::Bool { val: true, .. })
     }
+
+    pub fn columns(&self) -> Vec<String> {
+        match self {
+            Value::Record { cols, .. } => cols.clone(),
+            _ => vec![],
+        }
+    }
 }
 
 impl PartialEq for Value {
diff --git a/crates/nu-table/.gitignore b/crates/nu-table/.gitignore
new file mode 100644
index 0000000000..4c234e523b
--- /dev/null
+++ b/crates/nu-table/.gitignore
@@ -0,0 +1,22 @@
+/target
+/scratch
+**/*.rs.bk
+history.txt
+tests/fixtures/nuplayground
+crates/*/target
+
+# Debian/Ubuntu
+debian/.debhelper/
+debian/debhelper-build-stamp
+debian/files
+debian/nu.substvars
+debian/nu/
+
+# macOS junk
+.DS_Store
+
+# JetBrains' IDE items
+.idea/*
+
+# VSCode's IDE items
+.vscode/*
diff --git a/crates/nu-table/Cargo.toml b/crates/nu-table/Cargo.toml
new file mode 100644
index 0000000000..e831ec3f16
--- /dev/null
+++ b/crates/nu-table/Cargo.toml
@@ -0,0 +1,18 @@
+[package]
+authors = ["The Nu Project Contributors"]
+description = "Nushell table printing"
+edition = "2018"
+license = "MIT"
+name = "nu-table"
+version = "0.36.0"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[[bin]]
+name = "table"
+path = "src/main.rs"
+
+[dependencies]
+nu-ansi-term = "0.36.0"
+
+regex = "1.4"
+unicode-width = "0.1.8"
diff --git a/crates/nu-table/src/lib.rs b/crates/nu-table/src/lib.rs
new file mode 100644
index 0000000000..661d7ddde7
--- /dev/null
+++ b/crates/nu-table/src/lib.rs
@@ -0,0 +1,5 @@
+mod table;
+mod wrap;
+
+pub use table::{draw_table, StyledString, Table, TextStyle, Theme};
+pub use wrap::Alignment;
diff --git a/crates/nu-table/src/main.rs b/crates/nu-table/src/main.rs
new file mode 100644
index 0000000000..638582a1fa
--- /dev/null
+++ b/crates/nu-table/src/main.rs
@@ -0,0 +1,86 @@
+use nu_table::{draw_table, StyledString, Table, TextStyle, Theme};
+use std::collections::HashMap;
+
+fn main() {
+    let args: Vec<_> = std::env::args().collect();
+    let mut width = 0;
+
+    if args.len() > 1 {
+        // Width in terminal characters
+        width = args[1].parse::<usize>().expect("Need a width in columns");
+    }
+
+    if width < 4 {
+        println!("Width must be greater than or equal to 4, setting width to 80");
+        width = 80;
+    }
+
+    // The mocked up table data
+    let (table_headers, row_data) = make_table_data();
+    // The table headers
+    let headers = vec_of_str_to_vec_of_styledstr(&table_headers, true);
+    // The table rows
+    let rows = vec_of_str_to_vec_of_styledstr(&row_data, false);
+    // The table itself
+    let table = Table::new(headers, vec![rows; 3], Theme::rounded());
+    // FIXME: Config isn't available from here so just put these here to compile
+    let color_hm: HashMap<String, nu_ansi_term::Style> = HashMap::new();
+    // Capture the table as a string
+    let output_table = draw_table(&table, width, &color_hm);
+    // Draw the table
+    println!("{}", output_table)
+}
+
+fn make_table_data() -> (Vec<&'static str>, Vec<&'static str>) {
+    let table_headers = vec![
+        "category",
+        "description",
+        "emoji",
+        "ios_version",
+        "unicode_version",
+        "aliases",
+        "tags",
+        "category2",
+        "description2",
+        "emoji2",
+        "ios_version2",
+        "unicode_version2",
+        "aliases2",
+        "tags2",
+    ];
+
+    let row_data = vec![
+        "Smileys & Emotion",
+        "grinning face",
+        "😀",
+        "6",
+        "6.1",
+        "grinning",
+        "smile",
+        "Smileys & Emotion",
+        "grinning face",
+        "😀",
+        "6",
+        "6.1",
+        "grinning",
+        "smile",
+    ];
+
+    (table_headers, row_data)
+}
+
+fn vec_of_str_to_vec_of_styledstr(data: &[&str], is_header: bool) -> Vec<StyledString> {
+    let mut v = vec![];
+
+    for x in data {
+        if is_header {
+            v.push(StyledString::new(
+                String::from(*x),
+                TextStyle::default_header(),
+            ))
+        } else {
+            v.push(StyledString::new(String::from(*x), TextStyle::basic_left()))
+        }
+    }
+    v
+}
diff --git a/crates/nu-table/src/table.rs b/crates/nu-table/src/table.rs
new file mode 100644
index 0000000000..817c59ef99
--- /dev/null
+++ b/crates/nu-table/src/table.rs
@@ -0,0 +1,1259 @@
+use crate::wrap::{column_width, split_sublines, wrap, Alignment, Subline, WrappedCell};
+use nu_ansi_term::{Color, Style};
+use std::collections::HashMap;
+use std::fmt::Write;
+
+enum SeparatorPosition {
+    Top,
+    Middle,
+    Bottom,
+}
+
+#[derive(Debug)]
+pub struct Table {
+    pub headers: Vec<StyledString>,
+    pub data: Vec<Vec<StyledString>>,
+    pub theme: Theme,
+}
+
+#[derive(Debug, Clone)]
+pub struct StyledString {
+    pub contents: String,
+    pub style: TextStyle,
+}
+
+impl StyledString {
+    pub fn new(contents: String, style: TextStyle) -> StyledString {
+        StyledString { contents, style }
+    }
+
+    pub fn set_style(&mut self, style: TextStyle) {
+        self.style = style;
+    }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct TextStyle {
+    pub alignment: Alignment,
+    pub color_style: Option<Style>,
+}
+
+impl TextStyle {
+    pub fn new() -> TextStyle {
+        TextStyle {
+            alignment: Alignment::Left,
+            color_style: Some(Style::default()),
+        }
+    }
+
+    pub fn bold(&self, bool_value: Option<bool>) -> TextStyle {
+        let bv = bool_value.unwrap_or(false);
+
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_bold: bv,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_bold(&self) -> bool {
+        self.color_style.unwrap_or_default().is_bold
+    }
+
+    pub fn dimmed(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_dimmed: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_dimmed(&self) -> bool {
+        self.color_style.unwrap_or_default().is_dimmed
+    }
+
+    pub fn italic(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_italic: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_italic(&self) -> bool {
+        self.color_style.unwrap_or_default().is_italic
+    }
+
+    pub fn underline(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_underline: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_underline(&self) -> bool {
+        self.color_style.unwrap_or_default().is_underline
+    }
+
+    pub fn blink(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_blink: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_blink(&self) -> bool {
+        self.color_style.unwrap_or_default().is_blink
+    }
+
+    pub fn reverse(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_reverse: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_reverse(&self) -> bool {
+        self.color_style.unwrap_or_default().is_reverse
+    }
+
+    pub fn hidden(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_hidden: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_hidden(&self) -> bool {
+        self.color_style.unwrap_or_default().is_hidden
+    }
+
+    pub fn strikethrough(&self) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                is_strikethrough: true,
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn is_strikethrough(&self) -> bool {
+        self.color_style.unwrap_or_default().is_strikethrough
+    }
+
+    pub fn fg(&self, foreground: Color) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                foreground: Some(foreground),
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn on(&self, background: Color) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                background: Some(background),
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn bg(&self, background: Color) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                background: Some(background),
+                ..self.color_style.unwrap_or_default()
+            }),
+        }
+    }
+
+    pub fn alignment(&self, align: Alignment) -> TextStyle {
+        TextStyle {
+            alignment: align,
+            color_style: self.color_style,
+        }
+    }
+
+    pub fn style(&self, style: Style) -> TextStyle {
+        TextStyle {
+            alignment: self.alignment,
+            color_style: Some(Style {
+                foreground: style.foreground,
+                background: style.background,
+                is_bold: style.is_bold,
+                is_dimmed: style.is_dimmed,
+                is_italic: style.is_italic,
+                is_underline: style.is_underline,
+                is_blink: style.is_blink,
+                is_reverse: style.is_reverse,
+                is_hidden: style.is_hidden,
+                is_strikethrough: style.is_strikethrough,
+            }),
+        }
+    }
+
+    pub fn basic_center() -> TextStyle {
+        TextStyle::new()
+            .alignment(Alignment::Center)
+            .style(Style::default())
+    }
+
+    pub fn basic_right() -> TextStyle {
+        TextStyle::new()
+            .alignment(Alignment::Right)
+            .style(Style::default())
+    }
+
+    pub fn basic_left() -> TextStyle {
+        TextStyle::new()
+            .alignment(Alignment::Left)
+            .style(Style::default())
+    }
+
+    pub fn default_header() -> TextStyle {
+        TextStyle::new()
+            .alignment(Alignment::Center)
+            .fg(Color::Green)
+            .bold(Some(true))
+    }
+
+    pub fn with_attributes(bo: bool, al: Alignment, co: Color) -> TextStyle {
+        TextStyle::new().alignment(al).fg(co).bold(Some(bo))
+    }
+
+    pub fn with_style(al: Alignment, style: Style) -> TextStyle {
+        TextStyle::new().alignment(al).style(Style {
+            foreground: style.foreground,
+            background: style.background,
+            is_bold: style.is_bold,
+            is_dimmed: style.is_dimmed,
+            is_italic: style.is_italic,
+            is_underline: style.is_underline,
+            is_blink: style.is_blink,
+            is_reverse: style.is_reverse,
+            is_hidden: style.is_hidden,
+            is_strikethrough: style.is_strikethrough,
+        })
+    }
+}
+
+impl Default for TextStyle {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Theme {
+    pub top_left: char,
+    pub middle_left: char,
+    pub bottom_left: char,
+    pub top_center: char,
+    pub center: char,
+    pub bottom_center: char,
+    pub top_right: char,
+    pub middle_right: char,
+    pub bottom_right: char,
+    pub top_horizontal: char,
+    pub middle_horizontal: char,
+    pub bottom_horizontal: char,
+    pub left_vertical: char,
+    pub center_vertical: char,
+    pub right_vertical: char,
+
+    pub separate_header: bool,
+    pub separate_rows: bool,
+
+    pub print_left_border: bool,
+    pub print_right_border: bool,
+    pub print_top_border: bool,
+    pub print_bottom_border: bool,
+}
+
+impl Theme {
+    #[allow(unused)]
+    pub fn basic() -> Theme {
+        Theme {
+            top_left: '+',
+            middle_left: '+',
+            bottom_left: '+',
+            top_center: '+',
+            center: '+',
+            bottom_center: '+',
+            top_right: '+',
+            middle_right: '+',
+            bottom_right: '+',
+            top_horizontal: '-',
+            middle_horizontal: '-',
+            bottom_horizontal: '-',
+            left_vertical: '|',
+            center_vertical: '|',
+            right_vertical: '|',
+
+            separate_header: true,
+            separate_rows: true,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn thin() -> Theme {
+        Theme {
+            top_left: '┌',
+            middle_left: '├',
+            bottom_left: '└',
+            top_center: '┬',
+            center: '┼',
+            bottom_center: '┴',
+            top_right: '┐',
+            middle_right: '┤',
+            bottom_right: '┘',
+
+            top_horizontal: '─',
+            middle_horizontal: '─',
+            bottom_horizontal: '─',
+
+            left_vertical: '│',
+            center_vertical: '│',
+            right_vertical: '│',
+
+            separate_header: true,
+            separate_rows: true,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn light() -> Theme {
+        Theme {
+            top_left: ' ',
+            middle_left: '─',
+            bottom_left: ' ',
+            top_center: ' ',
+            center: '─',
+            bottom_center: ' ',
+            top_right: ' ',
+            middle_right: '─',
+            bottom_right: ' ',
+
+            top_horizontal: ' ',
+            middle_horizontal: '─',
+            bottom_horizontal: ' ',
+
+            left_vertical: ' ',
+            center_vertical: ' ',
+            right_vertical: ' ',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: false,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn compact() -> Theme {
+        Theme {
+            top_left: '─',
+            middle_left: '─',
+            bottom_left: '─',
+            top_center: '┬',
+            center: '┼',
+            bottom_center: '┴',
+            top_right: '─',
+            middle_right: '─',
+            bottom_right: '─',
+            top_horizontal: '─',
+            middle_horizontal: '─',
+            bottom_horizontal: '─',
+
+            left_vertical: ' ',
+            center_vertical: '│',
+            right_vertical: ' ',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: false,
+            print_right_border: false,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn with_love() -> Theme {
+        Theme {
+            top_left: '❤',
+            middle_left: '❤',
+            bottom_left: '❤',
+            top_center: '❤',
+            center: '❤',
+            bottom_center: '❤',
+            top_right: '❤',
+            middle_right: '❤',
+            bottom_right: '❤',
+            top_horizontal: '❤',
+            middle_horizontal: '❤',
+            bottom_horizontal: '❤',
+
+            left_vertical: ' ',
+            center_vertical: '❤',
+            right_vertical: ' ',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: false,
+            print_right_border: false,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn compact_double() -> Theme {
+        Theme {
+            top_left: '═',
+            middle_left: '═',
+            bottom_left: '═',
+            top_center: '╦',
+            center: '╬',
+            bottom_center: '╩',
+            top_right: '═',
+            middle_right: '═',
+            bottom_right: '═',
+            top_horizontal: '═',
+            middle_horizontal: '═',
+            bottom_horizontal: '═',
+
+            left_vertical: ' ',
+            center_vertical: '║',
+            right_vertical: ' ',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: false,
+            print_right_border: false,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn rounded() -> Theme {
+        Theme {
+            top_left: '╭',
+            middle_left: '├',
+            bottom_left: '╰',
+            top_center: '┬',
+            center: '┼',
+            bottom_center: '┴',
+            top_right: '╮',
+            middle_right: '┤',
+            bottom_right: '╯',
+            top_horizontal: '─',
+            middle_horizontal: '─',
+            bottom_horizontal: '─',
+
+            left_vertical: '│',
+            center_vertical: '│',
+            right_vertical: '│',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn reinforced() -> Theme {
+        Theme {
+            top_left: '┏',
+            middle_left: '├',
+            bottom_left: '┗',
+            top_center: '┬',
+            center: '┼',
+            bottom_center: '┴',
+            top_right: '┓',
+            middle_right: '┤',
+            bottom_right: '┛',
+            top_horizontal: '─',
+            middle_horizontal: '─',
+            bottom_horizontal: '─',
+
+            left_vertical: '│',
+            center_vertical: '│',
+            right_vertical: '│',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+
+    #[allow(unused)]
+    pub fn heavy() -> Theme {
+        Theme {
+            top_left: '┏',
+            middle_left: '┣',
+            bottom_left: '┗',
+            top_center: '┳',
+            center: '╋',
+            bottom_center: '┻',
+            top_right: '┓',
+            middle_right: '┫',
+            bottom_right: '┛',
+            top_horizontal: '━',
+            middle_horizontal: '━',
+            bottom_horizontal: '━',
+
+            left_vertical: '┃',
+            center_vertical: '┃',
+            right_vertical: '┃',
+
+            separate_header: true,
+            separate_rows: false,
+
+            print_left_border: true,
+            print_right_border: true,
+            print_top_border: true,
+            print_bottom_border: true,
+        }
+    }
+    #[allow(unused)]
+    pub fn none() -> Theme {
+        Theme {
+            top_left: ' ',
+            middle_left: ' ',
+            bottom_left: ' ',
+            top_center: ' ',
+            center: ' ',
+            bottom_center: ' ',
+            top_right: ' ',
+            middle_right: ' ',
+            bottom_right: ' ',
+
+            top_horizontal: ' ',
+            middle_horizontal: ' ',
+            bottom_horizontal: ' ',
+
+            left_vertical: ' ',
+            center_vertical: ' ',
+            right_vertical: ' ',
+
+            separate_header: false,
+            separate_rows: false,
+
+            print_left_border: false,
+            print_right_border: false,
+            print_top_border: false,
+            print_bottom_border: false,
+        }
+    }
+}
+
+impl Table {
+    pub fn new(headers: Vec<StyledString>, data: Vec<Vec<StyledString>>, theme: Theme) -> Table {
+        Table {
+            headers,
+            data,
+            theme,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct ProcessedTable<'a> {
+    pub headers: Vec<ProcessedCell<'a>>,
+    pub data: Vec<Vec<ProcessedCell<'a>>>,
+    pub theme: Theme,
+}
+
+#[derive(Debug)]
+pub struct ProcessedCell<'a> {
+    pub contents: Vec<Vec<Subline<'a>>>,
+    pub style: TextStyle,
+}
+
+#[derive(Debug)]
+pub struct WrappedTable {
+    pub column_widths: Vec<usize>,
+    pub headers: Vec<WrappedCell>,
+    pub data: Vec<Vec<WrappedCell>>,
+    pub theme: Theme,
+}
+
+impl WrappedTable {
+    fn print_separator(
+        &self,
+        separator_position: SeparatorPosition,
+        color_hm: &HashMap<String, Style>,
+    ) -> String {
+        let column_count = self.column_widths.len();
+        let mut output = String::new();
+        let sep_color = color_hm
+            .get("separator_color")
+            .unwrap_or(&Style::default())
+            .to_owned();
+
+        match separator_position {
+            SeparatorPosition::Top => {
+                for column in self.column_widths.iter().enumerate() {
+                    if column.0 == 0 && self.theme.print_left_border {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.top_left.to_string())
+                                .to_string(),
+                        );
+                    }
+
+                    for _ in 0..*column.1 {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.top_horizontal.to_string())
+                                .to_string(),
+                        );
+                    }
+
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.top_horizontal.to_string())
+                            .to_string(),
+                    );
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.top_horizontal.to_string())
+                            .to_string(),
+                    );
+                    if column.0 == column_count - 1 {
+                        if self.theme.print_right_border {
+                            output.push_str(
+                                &sep_color
+                                    .paint(&self.theme.top_right.to_string())
+                                    .to_string(),
+                            );
+                        }
+                    } else {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.top_center.to_string())
+                                .to_string(),
+                        );
+                    }
+                }
+            }
+            SeparatorPosition::Middle => {
+                for column in self.column_widths.iter().enumerate() {
+                    if column.0 == 0 && self.theme.print_left_border {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.middle_left.to_string())
+                                .to_string(),
+                        );
+                    }
+
+                    for _ in 0..*column.1 {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.middle_horizontal.to_string())
+                                .to_string(),
+                        );
+                    }
+
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.middle_horizontal.to_string())
+                            .to_string(),
+                    );
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.middle_horizontal.to_string())
+                            .to_string(),
+                    );
+
+                    if column.0 == column_count - 1 {
+                        if self.theme.print_right_border {
+                            output.push_str(
+                                &sep_color
+                                    .paint(&self.theme.middle_right.to_string())
+                                    .to_string(),
+                            );
+                        }
+                    } else {
+                        output
+                            .push_str(&sep_color.paint(&self.theme.center.to_string()).to_string());
+                    }
+                }
+            }
+            SeparatorPosition::Bottom => {
+                for column in self.column_widths.iter().enumerate() {
+                    if column.0 == 0 && self.theme.print_left_border {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.bottom_left.to_string())
+                                .to_string(),
+                        );
+                    }
+                    for _ in 0..*column.1 {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.bottom_horizontal.to_string())
+                                .to_string(),
+                        );
+                    }
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.bottom_horizontal.to_string())
+                            .to_string(),
+                    );
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.bottom_horizontal.to_string())
+                            .to_string(),
+                    );
+
+                    if column.0 == column_count - 1 {
+                        if self.theme.print_right_border {
+                            output.push_str(
+                                &sep_color
+                                    .paint(&self.theme.bottom_right.to_string())
+                                    .to_string(),
+                            );
+                        }
+                    } else {
+                        output.push_str(
+                            &sep_color
+                                .paint(&self.theme.bottom_center.to_string())
+                                .to_string(),
+                        );
+                    }
+                }
+            }
+        }
+        output.push('\n');
+        output
+    }
+
+    fn print_cell_contents(
+        &self,
+        cells: &[WrappedCell],
+        color_hm: &HashMap<String, Style>,
+    ) -> String {
+        let sep_color = color_hm
+            .get("separator_color")
+            .unwrap_or(&Style::default())
+            .to_owned();
+
+        let mut total_output = String::new();
+
+        for current_line in 0.. {
+            let mut lines_printed = 0;
+
+            let mut output = String::new();
+            if self.theme.print_left_border {
+                output.push_str(
+                    &sep_color
+                        .paint(&self.theme.left_vertical.to_string())
+                        .to_string(),
+                );
+            }
+
+            for column in cells.iter().enumerate() {
+                if let Some(line) = (column.1).lines.get(current_line) {
+                    let remainder = self.column_widths[column.0] - line.width;
+                    output.push(' ');
+
+                    match column.1.style.alignment {
+                        Alignment::Left => {
+                            if let Some(color) = column.1.style.color_style {
+                                output.push_str(&color.paint(&line.line).to_string());
+                            } else {
+                                output.push_str(&line.line);
+                            }
+                            for _ in 0..remainder {
+                                output.push(' ');
+                            }
+                        }
+                        Alignment::Center => {
+                            for _ in 0..remainder / 2 {
+                                output.push(' ');
+                            }
+                            if let Some(color) = column.1.style.color_style {
+                                output.push_str(&color.paint(&line.line).to_string());
+                            } else {
+                                output.push_str(&line.line);
+                            }
+                            for _ in 0..(remainder / 2 + remainder % 2) {
+                                output.push(' ');
+                            }
+                        }
+                        Alignment::Right => {
+                            for _ in 0..remainder {
+                                output.push(' ');
+                            }
+                            if let Some(color) = column.1.style.color_style {
+                                output.push_str(&color.paint(&line.line).to_string());
+                            } else {
+                                output.push_str(&line.line);
+                            }
+                        }
+                    }
+                    output.push(' ');
+                    lines_printed += 1;
+                } else {
+                    for _ in 0..self.column_widths[column.0] + 2 {
+                        output.push(' ');
+                    }
+                }
+                if column.0 < cells.len() - 1 {
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.center_vertical.to_string())
+                            .to_string(),
+                    );
+                } else if self.theme.print_right_border {
+                    output.push_str(
+                        &sep_color
+                            .paint(&self.theme.right_vertical.to_string())
+                            .to_string(),
+                    );
+                }
+            }
+
+            if lines_printed == 0 {
+                break;
+            }
+
+            writeln!(&mut total_output, "{}", output).unwrap();
+        }
+        total_output
+    }
+
+    fn print_table(&self, color_hm: &HashMap<String, Style>) -> String {
+        let mut output = String::new();
+
+        #[cfg(windows)]
+        {
+            let _ = nu_ansi_term::enable_ansi_support();
+        }
+
+        if self.data.is_empty() {
+            return output;
+        }
+
+        if self.theme.print_top_border {
+            output.push_str(&self.print_separator(SeparatorPosition::Top, color_hm));
+        }
+
+        let skip_headers = (self.headers.len() == 2 && self.headers[1].max_width == 0)
+            || (self.headers.len() == 1 && self.headers[0].max_width == 0);
+
+        if !self.headers.is_empty() && !skip_headers {
+            output.push_str(&self.print_cell_contents(&self.headers, color_hm));
+        }
+
+        let mut first_row = true;
+
+        for row in &self.data {
+            if !first_row {
+                if self.theme.separate_rows {
+                    output.push_str(&self.print_separator(SeparatorPosition::Middle, color_hm));
+                }
+            } else {
+                first_row = false;
+
+                if self.theme.separate_header && !self.headers.is_empty() && !skip_headers {
+                    output.push_str(&self.print_separator(SeparatorPosition::Middle, color_hm));
+                }
+            }
+
+            output.push_str(&self.print_cell_contents(row, color_hm));
+        }
+
+        if self.theme.print_bottom_border {
+            output.push_str(&self.print_separator(SeparatorPosition::Bottom, color_hm));
+        }
+
+        output
+    }
+}
+
+fn process_table(table: &Table) -> ProcessedTable {
+    let mut processed_data = vec![];
+    for row in &table.data {
+        let mut out_row = vec![];
+        for column in row {
+            out_row.push(ProcessedCell {
+                contents: split_sublines(&column.contents),
+                style: column.style,
+            });
+        }
+        processed_data.push(out_row);
+    }
+
+    let mut processed_headers = vec![];
+    for header in &table.headers {
+        processed_headers.push(ProcessedCell {
+            contents: split_sublines(&header.contents),
+            style: header.style,
+        });
+    }
+
+    ProcessedTable {
+        headers: processed_headers,
+        data: processed_data,
+        theme: table.theme.clone(),
+    }
+}
+
+fn get_max_column_widths(processed_table: &ProcessedTable) -> Vec<usize> {
+    use std::cmp::max;
+
+    let mut max_num_columns = 0;
+
+    max_num_columns = max(max_num_columns, processed_table.headers.len());
+
+    for row in &processed_table.data {
+        max_num_columns = max(max_num_columns, row.len());
+    }
+
+    let mut output = vec![0; max_num_columns];
+
+    for column in processed_table.headers.iter().enumerate() {
+        output[column.0] = max(output[column.0], column_width(&column.1.contents));
+    }
+
+    for row in &processed_table.data {
+        for column in row.iter().enumerate() {
+            output[column.0] = max(output[column.0], column_width(&column.1.contents));
+        }
+    }
+
+    output
+}
+
+pub fn maybe_truncate_columns(termwidth: usize, processed_table: &mut ProcessedTable) {
+    // Make sure we have enough space for the columns we have
+    let max_num_of_columns = termwidth / 10;
+
+    // If we have too many columns, truncate the table
+    if max_num_of_columns < processed_table.headers.len() {
+        processed_table.headers.truncate(max_num_of_columns);
+
+        for entry in processed_table.data.iter_mut() {
+            entry.truncate(max_num_of_columns);
+        }
+
+        processed_table.headers.push(ProcessedCell {
+            contents: vec![vec![Subline {
+                subline: "...",
+                width: 3,
+            }]],
+            style: TextStyle::basic_center(),
+        });
+
+        for entry in processed_table.data.iter_mut() {
+            entry.push(ProcessedCell {
+                contents: vec![vec![Subline {
+                    subline: "...",
+                    width: 3,
+                }]],
+                style: TextStyle::basic_center(),
+            }); // ellipsis is centred
+        }
+    }
+}
+
+pub fn draw_table(table: &Table, termwidth: usize, color_hm: &HashMap<String, Style>) -> String {
+    // Remove the edges, if used
+    let termwidth = if table.theme.print_left_border && table.theme.print_right_border {
+        termwidth - 2
+    } else if table.theme.print_left_border || table.theme.print_right_border {
+        termwidth - 1
+    } else {
+        termwidth
+    };
+
+    let mut processed_table = process_table(table);
+
+    let max_per_column = get_max_column_widths(&processed_table);
+
+    maybe_truncate_columns(termwidth, &mut processed_table);
+
+    let headers_len = processed_table.headers.len();
+
+    // fix the length of the table if there are no headers:
+    let headers_len = if headers_len == 0 {
+        if !table.data.is_empty() && !table.data[0].is_empty() {
+            table.data[0].len()
+        } else {
+            return String::new();
+        }
+    } else {
+        headers_len
+    };
+
+    // Measure how big our columns need to be (accounting for separators also)
+    let max_naive_column_width = (termwidth - 3 * (headers_len - 1)) / headers_len;
+
+    let column_space = ColumnSpace::measure(&max_per_column, max_naive_column_width, headers_len);
+
+    // This gives us the max column width
+    let max_column_width = column_space.max_width(termwidth);
+
+    // This width isn't quite right, as we're rounding off some of our space
+    let column_space = column_space.fix_almost_column_width(
+        &max_per_column,
+        max_naive_column_width,
+        max_column_width,
+        headers_len,
+    );
+
+    // This should give us the final max column width
+    let max_column_width = column_space.max_width(termwidth);
+    let re_leading =
+        regex::Regex::new(r"(?P<beginsp>^\s+)").expect("error with leading space regex");
+    let re_trailing =
+        regex::Regex::new(r"(?P<endsp>\s+$)").expect("error with trailing space regex");
+
+    let wrapped_table = wrap_cells(
+        processed_table,
+        max_column_width,
+        color_hm,
+        &re_leading,
+        &re_trailing,
+    );
+
+    wrapped_table.print_table(color_hm)
+}
+
+fn wrap_cells(
+    processed_table: ProcessedTable,
+    max_column_width: usize,
+    color_hm: &HashMap<String, Style>,
+    re_leading: &regex::Regex,
+    re_trailing: &regex::Regex,
+) -> WrappedTable {
+    let mut column_widths = vec![
+        0;
+        std::cmp::max(
+            processed_table.headers.len(),
+            if !processed_table.data.is_empty() {
+                processed_table.data[0].len()
+            } else {
+                0
+            }
+        )
+    ];
+    let mut output_headers = vec![];
+    for header in processed_table.headers.into_iter().enumerate() {
+        let mut wrapped = WrappedCell {
+            lines: vec![],
+            max_width: 0,
+            style: header.1.style,
+        };
+
+        for contents in header.1.contents.into_iter() {
+            let (mut lines, inner_max_width) = wrap(
+                max_column_width,
+                contents.into_iter(),
+                color_hm,
+                re_leading,
+                re_trailing,
+            );
+            wrapped.lines.append(&mut lines);
+            if inner_max_width > wrapped.max_width {
+                wrapped.max_width = inner_max_width;
+            }
+        }
+        if column_widths[header.0] < wrapped.max_width {
+            column_widths[header.0] = wrapped.max_width;
+        }
+        output_headers.push(wrapped);
+    }
+
+    let mut output_data = vec![];
+    for row in processed_table.data.into_iter() {
+        let mut output_row = vec![];
+        for column in row.into_iter().enumerate() {
+            let mut wrapped = WrappedCell {
+                lines: vec![],
+                max_width: 0,
+                style: column.1.style,
+            };
+            for contents in column.1.contents.into_iter() {
+                let (mut lines, inner_max_width) = wrap(
+                    max_column_width,
+                    contents.into_iter(),
+                    color_hm,
+                    re_leading,
+                    re_trailing,
+                );
+                wrapped.lines.append(&mut lines);
+                if inner_max_width > wrapped.max_width {
+                    wrapped.max_width = inner_max_width;
+                }
+            }
+            if column_widths[column.0] < wrapped.max_width {
+                column_widths[column.0] = wrapped.max_width;
+            }
+            output_row.push(wrapped);
+        }
+        output_data.push(output_row);
+    }
+
+    WrappedTable {
+        column_widths,
+        headers: output_headers,
+        data: output_data,
+        theme: processed_table.theme,
+    }
+}
+
+struct ColumnSpace {
+    num_overages: usize,
+    underage_sum: usize,
+    overage_separator_sum: usize,
+}
+
+impl ColumnSpace {
+    /// Measure how much space we have once we subtract off the columns who are small enough
+    fn measure(
+        max_per_column: &[usize],
+        max_naive_column_width: usize,
+        headers_len: usize,
+    ) -> ColumnSpace {
+        let mut num_overages = 0;
+        let mut underage_sum = 0;
+        let mut overage_separator_sum = 0;
+        let iter = max_per_column.iter().enumerate().take(headers_len);
+
+        for (i, &column_max) in iter {
+            if column_max > max_naive_column_width {
+                num_overages += 1;
+                if i != (headers_len - 1) {
+                    overage_separator_sum += 3;
+                }
+                if i == 0 {
+                    overage_separator_sum += 1;
+                }
+            } else {
+                underage_sum += column_max;
+                // if column isn't last, add 3 for its separator
+                if i != (headers_len - 1) {
+                    underage_sum += 3;
+                }
+                if i == 0 {
+                    underage_sum += 1;
+                }
+            }
+        }
+
+        ColumnSpace {
+            num_overages,
+            underage_sum,
+            overage_separator_sum,
+        }
+    }
+
+    fn fix_almost_column_width(
+        self,
+        max_per_column: &[usize],
+        max_naive_column_width: usize,
+        max_column_width: usize,
+        headers_len: usize,
+    ) -> ColumnSpace {
+        let mut num_overages = 0;
+        let mut overage_separator_sum = 0;
+        let mut underage_sum = self.underage_sum;
+        let iter = max_per_column.iter().enumerate().take(headers_len);
+
+        for (i, &column_max) in iter {
+            if column_max > max_naive_column_width {
+                if column_max <= max_column_width {
+                    underage_sum += column_max;
+                    // if column isn't last, add 3 for its separator
+                    if i != (headers_len - 1) {
+                        underage_sum += 3;
+                    }
+                    if i == 0 {
+                        underage_sum += 1;
+                    }
+                } else {
+                    // Column is still too large, so let's count it
+                    num_overages += 1;
+                    if i != (headers_len - 1) {
+                        overage_separator_sum += 3;
+                    }
+                    if i == 0 {
+                        overage_separator_sum += 1;
+                    }
+                }
+            }
+        }
+
+        ColumnSpace {
+            num_overages,
+            underage_sum,
+            overage_separator_sum,
+        }
+    }
+
+    fn max_width(&self, termwidth: usize) -> usize {
+        let ColumnSpace {
+            num_overages,
+            underage_sum,
+            overage_separator_sum,
+        } = self;
+
+        if *num_overages > 0 {
+            (termwidth - 1 - *underage_sum - *overage_separator_sum) / *num_overages
+        } else {
+            99999
+        }
+    }
+}
diff --git a/crates/nu-table/src/wrap.rs b/crates/nu-table/src/wrap.rs
new file mode 100644
index 0000000000..2bdb97edaa
--- /dev/null
+++ b/crates/nu-table/src/wrap.rs
@@ -0,0 +1,274 @@
+use crate::table::TextStyle;
+use nu_ansi_term::Style;
+use std::collections::HashMap;
+use std::{fmt::Display, iter::Iterator};
+use unicode_width::UnicodeWidthStr;
+
+#[derive(Debug, Clone, Copy)]
+pub enum Alignment {
+    Left,
+    Center,
+    Right,
+}
+
+#[derive(Debug)]
+pub struct Subline<'a> {
+    pub subline: &'a str,
+    pub width: usize,
+}
+
+#[derive(Debug)]
+pub struct Line<'a> {
+    pub sublines: Vec<Subline<'a>>,
+    pub width: usize,
+}
+
+#[derive(Debug)]
+pub struct WrappedLine {
+    pub line: String,
+    pub width: usize,
+}
+
+#[derive(Debug)]
+pub struct WrappedCell {
+    pub lines: Vec<WrappedLine>,
+    pub max_width: usize,
+
+    pub style: TextStyle,
+}
+
+impl<'a> Display for Line<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let mut first = true;
+        for subline in &self.sublines {
+            if !first {
+                write!(f, " ")?;
+            } else {
+                first = false;
+            }
+            write!(f, "{}", subline.subline)?;
+        }
+        Ok(())
+    }
+}
+
+pub fn split_sublines(input: &str) -> Vec<Vec<Subline>> {
+    input
+        .split_terminator('\n')
+        .map(|line| {
+            line.split_terminator(' ')
+                .map(|x| Subline {
+                    subline: x,
+                    width: {
+                        // We've tried UnicodeWidthStr::width(x), UnicodeSegmentation::graphemes(x, true).count()
+                        // and x.chars().count() with all types of combinations. Currently, it appears that
+                        // getting the max of char count and Unicode width seems to produce the best layout.
+                        // However, it's not perfect.
+                        let c = x.chars().count();
+                        let u = UnicodeWidthStr::width(x);
+                        std::cmp::max(c, u)
+                    },
+                })
+                .collect::<Vec<_>>()
+        })
+        .collect::<Vec<_>>()
+}
+
+pub fn column_width(input: &[Vec<Subline>]) -> usize {
+    let mut max = 0;
+
+    for line in input {
+        let mut total = 0;
+
+        let mut first = true;
+        for inp in line {
+            if !first {
+                // Account for the space
+                total += 1;
+            } else {
+                first = false;
+            }
+
+            total += inp.width;
+        }
+
+        if total > max {
+            max = total;
+        }
+    }
+
+    max
+}
+
+fn split_word(cell_width: usize, word: &str) -> Vec<Subline> {
+    use unicode_width::UnicodeWidthChar;
+
+    let mut output = vec![];
+    let mut current_width = 0;
+    let mut start_index = 0;
+    let mut end_index;
+
+    for c in word.char_indices() {
+        if let Some(width) = c.1.width() {
+            end_index = c.0;
+            if current_width + width > cell_width {
+                output.push(Subline {
+                    subline: &word[start_index..end_index],
+                    width: current_width,
+                });
+
+                start_index = c.0;
+                current_width = width;
+            } else {
+                current_width += width;
+            }
+        }
+    }
+
+    if start_index != word.len() {
+        output.push(Subline {
+            subline: &word[start_index..],
+            width: current_width,
+        });
+    }
+
+    output
+}
+
+pub fn wrap<'a>(
+    cell_width: usize,
+    mut input: impl Iterator<Item = Subline<'a>>,
+    color_hm: &HashMap<String, Style>,
+    re_leading: &regex::Regex,
+    re_trailing: &regex::Regex,
+) -> (Vec<WrappedLine>, usize) {
+    let mut lines = vec![];
+    let mut current_line: Vec<Subline> = vec![];
+    let mut current_width = 0;
+    let mut first = true;
+    let mut max_width = 0;
+    let lead_trail_space_bg_color = color_hm
+        .get("leading_trailing_space_bg")
+        .unwrap_or(&Style::default())
+        .to_owned();
+
+    loop {
+        match input.next() {
+            Some(item) => {
+                if !first {
+                    current_width += 1;
+                } else {
+                    first = false;
+                }
+
+                if item.width + current_width > cell_width {
+                    // If this is a really long single word, we need to split the word
+                    if current_line.len() == 1 && current_width > cell_width {
+                        max_width = cell_width;
+                        let sublines = split_word(cell_width, current_line[0].subline);
+                        for subline in sublines {
+                            let width = subline.width;
+                            lines.push(Line {
+                                sublines: vec![subline],
+                                width,
+                            });
+                        }
+
+                        first = true;
+
+                        current_width = item.width;
+                        current_line = vec![item];
+                    } else {
+                        if !current_line.is_empty() {
+                            lines.push(Line {
+                                sublines: current_line,
+                                width: current_width,
+                            });
+                        }
+
+                        first = true;
+
+                        current_width = item.width;
+                        current_line = vec![item];
+                        max_width = std::cmp::max(max_width, current_width);
+                    }
+                } else {
+                    current_width += item.width;
+                    current_line.push(item);
+                }
+            }
+            None => {
+                if current_width > cell_width {
+                    // We need to break up the last word
+                    let sublines = split_word(cell_width, current_line[0].subline);
+                    for subline in sublines {
+                        let width = subline.width;
+                        lines.push(Line {
+                            sublines: vec![subline],
+                            width,
+                        });
+                    }
+                } else if current_width > 0 {
+                    lines.push(Line {
+                        sublines: current_line,
+                        width: current_width,
+                    });
+                }
+                break;
+            }
+        }
+    }
+
+    let mut current_max = 0;
+    let mut output = vec![];
+
+    for line in lines {
+        let mut current_line_width = 0;
+        let mut first = true;
+        let mut current_line = String::new();
+
+        for subline in line.sublines {
+            if !first {
+                current_line_width += 1 + subline.width;
+                current_line.push(' ');
+            } else {
+                first = false;
+                current_line_width = subline.width;
+            }
+            current_line.push_str(subline.subline);
+        }
+
+        if current_line_width > current_max {
+            current_max = current_line_width;
+        }
+
+        // highlight leading and trailing spaces so they stand out.
+        let mut bg_color_string = Style::default().prefix().to_string();
+        // right now config settings can only set foreground colors so, in this
+        // instance we take the foreground color and make it a background color
+        if let Some(bg) = lead_trail_space_bg_color.foreground {
+            bg_color_string = Style::default().on(bg).prefix().to_string()
+        };
+
+        if let Some(leading_match) = re_leading.find(&current_line.clone()) {
+            String::insert_str(
+                &mut current_line,
+                leading_match.end(),
+                nu_ansi_term::ansi::RESET,
+            );
+            String::insert_str(&mut current_line, leading_match.start(), &bg_color_string);
+        }
+
+        if let Some(trailing_match) = re_trailing.find(&current_line.clone()) {
+            String::insert_str(&mut current_line, trailing_match.start(), &bg_color_string);
+            current_line += nu_ansi_term::ansi::RESET;
+        }
+
+        output.push(WrappedLine {
+            line: current_line,
+            width: current_line_width,
+        });
+    }
+
+    (output, current_max)
+}