diff --git a/Cargo.toml b/Cargo.toml
index a03c4d24..a7aea7c3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -13,8 +13,6 @@ edition = "2018"
 exclude = ["screenshots/*"]
 
 [dependencies]
-regex = { version = "1.3.1", default-features = false, features = ["std"] }
-once_cell = "1.8.0"
 number_prefix = "0.4"
 console = { version = "0.15.0", default-features = false, features = ["ansi-parsing"] }
 unicode-segmentation = { version = "1.6.0", optional = true }
@@ -23,6 +21,7 @@ rayon = { version = "1.0", optional = true }
 tokio = { version = "1.0", optional = true, features = ["fs", "io-util"] }
 
 [dev-dependencies]
+once_cell = "1.8.0"
 rand = "0.8"
 structopt = "0.3"
 tokio = { version = "1.0", features = ["time", "rt"] }
diff --git a/src/state.rs b/src/state.rs
index 34fb73a2..b51f0afc 100644
--- a/src/state.rs
+++ b/src/state.rs
@@ -50,11 +50,7 @@ impl ProgressState {
     /// Returns the string that should be drawn for the
     /// current spinner string.
     pub fn current_tick_str(&self) -> &str {
-        if self.is_finished() {
-            self.style.get_final_tick_str()
-        } else {
-            self.style.get_tick_str(self.tick)
-        }
+        self.style.current_tick_str(self)
     }
 
     /// Indicates that the progress bar finished.
diff --git a/src/style.rs b/src/style.rs
index ebe6d97e..f9358319 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 use std::collections::HashMap;
+use std::fmt::{self, Write};
+use std::mem;
 
 use console::{measure_text_width, Style};
-use once_cell::sync::Lazy;
-use regex::{Captures, Regex};
 #[cfg(feature = "improved_unicode")]
 use unicode_segmentation::UnicodeSegmentation;
 
@@ -15,7 +15,7 @@ use crate::state::ProgressState;
 pub struct ProgressStyle {
     tick_strings: Vec<Box<str>>,
     progress_chars: Vec<Box<str>>,
-    template: Box<str>,
+    template: Template,
     on_finish: ProgressFinish,
     // how unicode-big each char in progress_chars is
     char_width: usize,
@@ -62,23 +62,15 @@ fn width(c: &[Box<str>]) -> usize {
 impl ProgressStyle {
     /// Returns the default progress bar style for bars
     pub fn default_bar() -> ProgressStyle {
-        let progress_chars = segment("█░");
-        let char_width = width(&progress_chars);
-        ProgressStyle {
-            tick_strings: "⠁⠁⠉⠙⠚⠒⠂⠂⠒⠲⠴⠤⠄⠄⠤⠠⠠⠤⠦⠖⠒⠐⠐⠒⠓⠋⠉⠈⠈ "
-                .chars()
-                .map(|c| c.to_string().into())
-                .collect(),
-            progress_chars,
-            char_width,
-            template: "{wide_bar} {pos}/{len}".into(),
-            on_finish: ProgressFinish::default(),
-            format_map: FormatMap::default(),
-        }
+        Self::new("{wide_bar} {pos}/{len}")
     }
 
     /// Returns the default progress bar style for spinners
-    pub fn default_spinner() -> ProgressStyle {
+    pub fn default_spinner() -> Self {
+        Self::new("{spinner} {msg}")
+    }
+
+    fn new(template: &str) -> Self {
         let progress_chars = segment("█░");
         let char_width = width(&progress_chars);
         ProgressStyle {
@@ -88,7 +80,7 @@ impl ProgressStyle {
                 .collect(),
             progress_chars,
             char_width,
-            template: "{spinner} {msg}".into(),
+            template: Template::from_str(template),
             on_finish: ProgressFinish::default(),
             format_map: FormatMap::default(),
         }
@@ -144,7 +136,7 @@ impl ProgressStyle {
     ///
     /// Review the [list of template keys](./index.html#templates) for more information.
     pub fn template(mut self, s: &str) -> ProgressStyle {
-        self.template = s.into();
+        self.template = Template::from_str(s);
         self
     }
 
@@ -164,10 +156,11 @@ impl ProgressStyle {
         self
     }
 
-    /// Returns the tick char for a given number
-    #[deprecated(since = "0.13.0", note = "Deprecated in favor of get_tick_str")]
-    pub fn get_tick_char(&self, idx: u64) -> char {
-        self.get_tick_str(idx).chars().next().unwrap_or(' ')
+    pub(crate) fn current_tick_str(&self, state: &ProgressState) -> &str {
+        match state.is_finished() {
+            true => self.get_final_tick_str(),
+            false => self.get_tick_str(state.tick),
+        }
     }
 
     /// Returns the tick string for a given number
@@ -175,12 +168,6 @@ impl ProgressStyle {
         &self.tick_strings[(idx as usize) % (self.tick_strings.len() - 1)]
     }
 
-    /// Returns the tick char for the finished state
-    #[deprecated(since = "0.13.0", note = "Deprecated in favor of get_final_tick_str")]
-    pub fn get_final_tick_char(&self) -> char {
-        self.get_final_tick_str().chars().next().unwrap_or(' ')
-    }
-
     /// Returns the tick string for the finished state
     pub fn get_final_tick_str(&self) -> &str {
         &self.tick_strings[self.tick_strings.len() - 1]
@@ -191,7 +178,7 @@ impl ProgressStyle {
         &self.on_finish
     }
 
-    pub(crate) fn format_bar(&self, fract: f32, width: usize, alt_style: Option<&Style>) -> String {
+    fn format_bar(&self, fract: f32, width: usize, alt_style: Option<&Style>) -> BarDisplay<'_> {
         // The number of clusters from progress_chars to write (rounding down).
         let width = width / self.char_width;
         // The number of full clusters (including a fractional component for a partially-full one).
@@ -206,8 +193,6 @@ impl ProgressStyle {
             0
         };
 
-        let pb = self.progress_chars[0].repeat(entirely_filled);
-
         let cur = if head == 1 {
             // Number of fine-grained progress entries in progress_chars.
             let n = self.progress_chars.len().saturating_sub(2);
@@ -220,204 +205,443 @@ impl ProgressStyle {
                 // of fill is 0 to the first one (1) if the fractional part of fill is almost 1.
                 n.saturating_sub((fill.fract() * n as f32) as usize)
             };
-            self.progress_chars[cur_char].to_string()
+            Some(cur_char)
         } else {
-            "".into()
+            None
         };
 
         // Number of entirely empty clusters needed to fill the bar up to `width`.
         let bg = width.saturating_sub(entirely_filled).saturating_sub(head);
-        let rest = self.progress_chars[self.progress_chars.len() - 1].repeat(bg);
-        format!(
-            "{}{}{}",
-            pb,
+        let rest = RepeatedStringDisplay {
+            str: &self.progress_chars[self.progress_chars.len() - 1],
+            num: bg,
+        };
+
+        BarDisplay {
+            chars: &self.progress_chars,
+            filled: entirely_filled,
             cur,
-            alt_style.unwrap_or(&Style::new()).apply_to(rest)
-        )
+            rest: alt_style.unwrap_or(&Style::new()).apply_to(rest),
+        }
     }
 
     pub(crate) fn format_state(&self, state: &ProgressState) -> Vec<String> {
+        let mut cur = String::new();
+        let mut buf = String::new();
         let mut rv = vec![];
-
-        for line in self.template.lines() {
-            let mut wide_element = None;
-
-            let s = expand_template(line, |var| {
-                if let Some(formatter) = self.format_map.0.get(var.key) {
-                    return formatter(state);
-                }
-
-                match var.key {
-                    "wide_bar" => {
-                        wide_element = Some(var.duplicate_for_key("bar"));
-                        "\x00".into()
-                    }
-                    "bar" => self.format_bar(
-                        state.fraction(),
-                        var.width.unwrap_or(20),
-                        var.alt_style.as_ref(),
-                    ),
-                    "spinner" => state.current_tick_str().to_string(),
-                    "wide_msg" => {
-                        wide_element = Some(var.duplicate_for_key("msg"));
-                        "\x00".into()
-                    }
-                    "msg" => state.message().to_string(),
-                    "prefix" => state.prefix().to_string(),
-                    "pos" => state.pos.to_string(),
-                    "len" => state.len.to_string(),
-                    "percent" => format!("{:.*}", 0, state.fraction() * 100f32),
-                    "bytes" => format!("{}", HumanBytes(state.pos)),
-                    "total_bytes" => format!("{}", HumanBytes(state.len)),
-                    "decimal_bytes" => format!("{}", DecimalBytes(state.pos)),
-                    "decimal_total_bytes" => format!("{}", DecimalBytes(state.len)),
-                    "binary_bytes" => format!("{}", BinaryBytes(state.pos)),
-                    "binary_total_bytes" => format!("{}", BinaryBytes(state.len)),
-                    "elapsed_precise" => {
-                        format!("{}", FormattedDuration(state.started.elapsed()))
-                    }
-                    "elapsed" => format!("{:#}", HumanDuration(state.started.elapsed())),
-                    "per_sec" => format!("{:.4}/s", state.per_sec()),
-                    "bytes_per_sec" => format!("{}/s", HumanBytes(state.per_sec() as u64)),
-                    "binary_bytes_per_sec" => {
-                        format!("{}/s", BinaryBytes(state.per_sec() as u64))
+        let mut wide_element = None;
+        for part in &self.template.parts {
+            match part {
+                TemplatePart::Placeholder {
+                    key,
+                    align,
+                    width,
+                    truncate,
+                    style,
+                    alt_style,
+                } => {
+                    buf.clear();
+                    if let Some(formatter) = self.format_map.0.get(key.as_str()) {
+                        buf.push_str(&formatter(state));
+                    } else {
+                        match key.as_str() {
+                            "wide_bar" => {
+                                wide_element = Some((key.as_str(), align, alt_style));
+                                buf.push('\x00');
+                            }
+                            "bar" => buf
+                                .write_fmt(format_args!(
+                                    "{}",
+                                    self.format_bar(
+                                        state.fraction(),
+                                        width.unwrap_or(20) as usize,
+                                        alt_style.as_ref(),
+                                    )
+                                ))
+                                .unwrap(),
+                            "spinner" => buf.push_str(state.current_tick_str()),
+                            "wide_msg" => {
+                                wide_element = Some((key.as_str(), align, alt_style));
+                                buf.push('\x00');
+                            }
+                            "msg" => buf.push_str(state.message()),
+                            "prefix" => buf.push_str(state.prefix()),
+                            "pos" => buf.write_fmt(format_args!("{}", state.pos)).unwrap(),
+                            "len" => buf.write_fmt(format_args!("{}", state.len)).unwrap(),
+                            "percent" => buf
+                                .write_fmt(format_args!("{:.*}", 0, state.fraction() * 100f32))
+                                .unwrap(),
+                            "bytes" => buf
+                                .write_fmt(format_args!("{}", HumanBytes(state.pos)))
+                                .unwrap(),
+                            "total_bytes" => buf
+                                .write_fmt(format_args!("{}", HumanBytes(state.len)))
+                                .unwrap(),
+                            "decimal_bytes" => buf
+                                .write_fmt(format_args!("{}", DecimalBytes(state.pos)))
+                                .unwrap(),
+                            "decimal_total_bytes" => buf
+                                .write_fmt(format_args!("{}", DecimalBytes(state.len)))
+                                .unwrap(),
+                            "binary_bytes" => buf
+                                .write_fmt(format_args!("{}", BinaryBytes(state.pos)))
+                                .unwrap(),
+                            "binary_total_bytes" => buf
+                                .write_fmt(format_args!("{}", BinaryBytes(state.len)))
+                                .unwrap(),
+                            "elapsed_precise" => buf
+                                .write_fmt(format_args!(
+                                    "{}",
+                                    FormattedDuration(state.started.elapsed())
+                                ))
+                                .unwrap(),
+                            "elapsed" => buf
+                                .write_fmt(format_args!(
+                                    "{:#}",
+                                    HumanDuration(state.started.elapsed())
+                                ))
+                                .unwrap(),
+                            "per_sec" => buf
+                                .write_fmt(format_args!("{:.4}/s", state.per_sec()))
+                                .unwrap(),
+                            "bytes_per_sec" => buf
+                                .write_fmt(format_args!("{}/s", HumanBytes(state.per_sec() as u64)))
+                                .unwrap(),
+                            "binary_bytes_per_sec" => buf
+                                .write_fmt(format_args!(
+                                    "{}/s",
+                                    BinaryBytes(state.per_sec() as u64)
+                                ))
+                                .unwrap(),
+                            "eta_precise" => buf
+                                .write_fmt(format_args!("{}", FormattedDuration(state.eta())))
+                                .unwrap(),
+                            "eta" => buf
+                                .write_fmt(format_args!("{:#}", HumanDuration(state.eta())))
+                                .unwrap(),
+                            "duration_precise" => buf
+                                .write_fmt(format_args!("{}", FormattedDuration(state.duration())))
+                                .unwrap(),
+                            "duration" => buf
+                                .write_fmt(format_args!("{:#}", HumanDuration(state.duration())))
+                                .unwrap(),
+                            _ => (),
+                        }
+                    };
+
+                    match width {
+                        Some(width) => {
+                            let padded = PaddedStringDisplay {
+                                str: &buf,
+                                width: *width as usize,
+                                align: *align,
+                                truncate: *truncate,
+                            };
+                            match style {
+                                Some(s) => cur
+                                    .write_fmt(format_args!("{}", s.apply_to(padded)))
+                                    .unwrap(),
+                                None => cur.write_fmt(format_args!("{}", padded)).unwrap(),
+                            }
+                        }
+                        None => match style {
+                            Some(s) => cur.write_fmt(format_args!("{}", s.apply_to(&buf))).unwrap(),
+                            None => cur.push_str(&buf),
+                        },
                     }
-                    "eta_precise" => format!("{}", FormattedDuration(state.eta())),
-                    "eta" => format!("{:#}", HumanDuration(state.eta())),
-                    "duration_precise" => format!("{}", FormattedDuration(state.duration())),
-                    "duration" => format!("{:#}", HumanDuration(state.duration())),
-                    _ => "".into(),
                 }
-            });
-
-            rv.push(if let Some(ref var) = wide_element {
-                let total_width = state.width();
-                if var.key == "bar" {
-                    let bar_width = total_width.saturating_sub(measure_text_width(&s));
-                    s.replace(
-                        "\x00",
-                        &self.format_bar(state.fraction(), bar_width, var.alt_style.as_ref()),
-                    )
-                } else if var.key == "msg" {
-                    let msg_width = total_width.saturating_sub(measure_text_width(&s));
-                    let msg = pad_str(state.message(), msg_width, var.align, true);
-                    s.replace(
-                        "\x00",
-                        if var.last_element {
-                            msg.trim_end()
-                        } else {
-                            &msg
-                        },
-                    )
-                } else {
-                    unreachable!()
+                TemplatePart::Literal(s) => cur.push_str(s),
+                TemplatePart::NewLine => {
+                    rv.push(expand_wide(
+                        mem::take(&mut cur),
+                        wide_element.take(),
+                        self,
+                        state,
+                        &mut buf,
+                    ));
                 }
-            } else {
-                s.to_string()
-            });
+            }
         }
 
+        if !cur.is_empty() {
+            rv.push(expand_wide(
+                mem::take(&mut cur),
+                wide_element.take(),
+                self,
+                state,
+                &mut buf,
+            ));
+        }
         rv
     }
 }
 
-fn expand_template<F: FnMut(&TemplateVar<'_>) -> String>(s: &str, mut f: F) -> Cow<'_, str> {
-    static VAR_RE: Lazy<Regex> = Lazy::new(|| Regex::new(r"(\}\})|\{(\{|[^{}}]+\})").unwrap());
-    static KEY_RE: Lazy<Regex> = Lazy::new(|| {
-        Regex::new(
-            r"(?x)
-                ([^:]+)
-                (?:
-                    :
-                    ([<^>])?
-                    ([0-9]+)?
-                    (!)?
-                    (?:\.([0-9a-z_]+(?:\.[0-9a-z_]+)*))?
-                    (?:/([a-z_]+(?:\.[a-z_]+)*))?
-                )?
-            ",
+fn expand_wide(
+    cur: String,
+    wide: Option<(&str, &Alignment, &Option<Style>)>,
+    style: &ProgressStyle,
+    state: &ProgressState,
+    buf: &mut String,
+) -> String {
+    let (key, align, alt_style) = match wide {
+        Some(x) => x,
+        None => return cur,
+    };
+
+    let left = state.width().saturating_sub(measure_text_width(&cur));
+    if key == "bar" {
+        cur.replace(
+            "\x00",
+            &format!(
+                "{}",
+                style.format_bar(state.fraction(), left, alt_style.as_ref())
+            ),
         )
-        .unwrap()
-    });
-    VAR_RE.replace_all(s, |caps: &Captures<'_>| {
-        if caps.get(1).is_some() {
-            return "}".into();
-        }
-        let key = &caps[2];
-        if key == "{" {
-            return "{".into();
-        }
-        let mut var = TemplateVar {
-            key,
-            align: Alignment::Left,
-            truncate: false,
-            width: None,
-            style: None,
-            alt_style: None,
-            last_element: caps.get(0).unwrap().end() >= s.len(),
-        };
-        if let Some(opt_caps) = KEY_RE.captures(&key[..key.len() - 1]) {
-            if let Some(short_key) = opt_caps.get(1) {
-                var.key = short_key.as_str();
+    } else if key == "msg" {
+        buf.clear();
+        buf.write_fmt(format_args!(
+            "{}",
+            PaddedStringDisplay {
+                str: state.message(),
+                width: left,
+                align: *align,
+                truncate: true,
             }
-            var.align = match opt_caps.get(2).map(|x| x.as_str()) {
-                Some("<") => Alignment::Left,
-                Some("^") => Alignment::Center,
-                Some(">") => Alignment::Right,
-                _ => Alignment::Left,
+        ))
+        .unwrap();
+
+        let trimmed = match cur.as_bytes().last() == Some(&b'\x00') {
+            true => buf.trim_end(),
+            false => buf,
+        };
+
+        cur.replace("\x00", trimmed)
+    } else {
+        cur
+    }
+}
+
+#[derive(Clone, Debug)]
+struct Template {
+    parts: Vec<TemplatePart>,
+}
+
+impl Template {
+    fn from_str(s: &str) -> Self {
+        use State::*;
+        let (mut state, mut parts, mut buf) = (Literal, vec![], String::new());
+        for c in s.chars() {
+            let new = match (state, c) {
+                (Literal, '{') => (MaybeOpen, None),
+                (Literal, '\n') => {
+                    if !buf.is_empty() {
+                        parts.push(TemplatePart::Literal(mem::take(&mut buf)));
+                    }
+                    parts.push(TemplatePart::NewLine);
+                    (Literal, None)
+                }
+                (Literal, '}') => (DoubleClose, Some('}')),
+                (Literal, c) => (Literal, Some(c)),
+                (DoubleClose, '}') => (Literal, None),
+                (MaybeOpen, '{') => (Literal, Some('{')),
+                (MaybeOpen, c) | (Key, c) if c.is_ascii_whitespace() => {
+                    // If we find whitespace where the variable key is supposed to go,
+                    // backtrack and act as if this was a literal.
+                    buf.push(c);
+                    let mut new = String::from("{");
+                    new.push_str(&buf);
+                    buf.clear();
+                    parts.push(TemplatePart::Literal(new));
+                    (Literal, None)
+                }
+                (MaybeOpen, c) if c != '}' && c != ':' => (Key, Some(c)),
+                (Key, c) if c != '}' && c != ':' => (Key, Some(c)),
+                (Key, ':') => (Align, None),
+                (Key, '}') => (Literal, None),
+                (Key, '!') if !buf.is_empty() => {
+                    parts.push(TemplatePart::Placeholder {
+                        key: mem::take(&mut buf),
+                        align: Alignment::Left,
+                        width: None,
+                        truncate: true,
+                        style: None,
+                        alt_style: None,
+                    });
+                    (Width, None)
+                }
+                (Align, c) if c == '<' || c == '^' || c == '>' => {
+                    if let Some(TemplatePart::Placeholder { align, .. }) = parts.last_mut() {
+                        match c {
+                            '<' => *align = Alignment::Left,
+                            '^' => *align = Alignment::Center,
+                            '>' => *align = Alignment::Right,
+                            _ => (),
+                        }
+                    }
+
+                    (Width, None)
+                }
+                (Align, c @ '0'..='9') => (Width, Some(c)),
+                (Align, '!') | (Width, '!') => {
+                    if let Some(TemplatePart::Placeholder { truncate, .. }) = parts.last_mut() {
+                        *truncate = true;
+                    }
+                    (Width, None)
+                }
+                (Align, '.') => (FirstStyle, None),
+                (Align, '}') => (Literal, None),
+                (Width, c @ '0'..='9') => (Width, Some(c)),
+                (Width, '.') => (FirstStyle, None),
+                (Width, '}') => (Literal, None),
+                (FirstStyle, '/') => (AltStyle, None),
+                (FirstStyle, '}') => (Literal, None),
+                (FirstStyle, c) => (FirstStyle, Some(c)),
+                (AltStyle, '}') => (Literal, None),
+                (AltStyle, c) => (AltStyle, Some(c)),
+                (st, c) => panic!("unreachable state: {:?} @ {:?}", c, st),
             };
-            if let Some(width) = opt_caps.get(3) {
-                var.width = Some(width.as_str().parse().unwrap());
-            }
-            if opt_caps.get(4).is_some() {
-                var.truncate = true;
-            }
-            if let Some(style) = opt_caps.get(5) {
-                var.style = Some(Style::from_dotted_str(style.as_str()));
+
+            match (state, new.0) {
+                (MaybeOpen, Key) if !buf.is_empty() => {
+                    parts.push(TemplatePart::Literal(mem::take(&mut buf)))
+                }
+                (Key, Align) | (Key, Literal) if !buf.is_empty() => {
+                    parts.push(TemplatePart::Placeholder {
+                        key: mem::take(&mut buf),
+                        align: Alignment::Left,
+                        width: None,
+                        truncate: false,
+                        style: None,
+                        alt_style: None,
+                    })
+                }
+                (Width, FirstStyle) | (Width, Literal) if !buf.is_empty() => {
+                    if let Some(TemplatePart::Placeholder { width, .. }) = parts.last_mut() {
+                        *width = Some(buf.parse().unwrap());
+                        buf.clear();
+                    }
+                }
+                (FirstStyle, AltStyle) | (FirstStyle, Literal) if !buf.is_empty() => {
+                    if let Some(TemplatePart::Placeholder { style, .. }) = parts.last_mut() {
+                        *style = Some(Style::from_dotted_str(&buf));
+                        buf.clear();
+                    }
+                }
+                (AltStyle, Literal) if !buf.is_empty() => {
+                    if let Some(TemplatePart::Placeholder { alt_style, .. }) = parts.last_mut() {
+                        *alt_style = Some(Style::from_dotted_str(&buf));
+                        buf.clear();
+                    }
+                }
+                (_, _) => (),
             }
-            if let Some(alt_style) = opt_caps.get(6) {
-                var.alt_style = Some(Style::from_dotted_str(alt_style.as_str()));
+
+            state = new.0;
+            if let Some(c) = new.1 {
+                buf.push(c);
             }
         }
-        let mut rv = f(&var);
-        if let Some(width) = var.width {
-            rv = pad_str(&rv, width, var.align, var.truncate).to_string()
+
+        if matches!(state, Literal | DoubleClose) && !buf.is_empty() {
+            parts.push(TemplatePart::Literal(buf));
         }
-        if let Some(s) = var.style {
-            rv = s.apply_to(rv).to_string();
+
+        Self { parts }
+    }
+}
+
+#[derive(Clone, Debug, PartialEq)]
+enum TemplatePart {
+    Literal(String),
+    Placeholder {
+        key: String,
+        align: Alignment,
+        width: Option<u16>,
+        truncate: bool,
+        style: Option<Style>,
+        alt_style: Option<Style>,
+    },
+    NewLine,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+enum State {
+    Literal,
+    MaybeOpen,
+    DoubleClose,
+    Key,
+    Align,
+    Width,
+    FirstStyle,
+    AltStyle,
+}
+
+struct BarDisplay<'a> {
+    chars: &'a [Box<str>],
+    filled: usize,
+    cur: Option<usize>,
+    rest: console::StyledObject<RepeatedStringDisplay<'a>>,
+}
+
+impl<'a> fmt::Display for BarDisplay<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for _ in 0..self.filled {
+            f.write_str(&self.chars[0])?;
         }
-        rv
-    })
+        if let Some(cur) = self.cur {
+            f.write_str(&self.chars[cur])?;
+        }
+        self.rest.fmt(f)
+    }
 }
 
-fn pad_str(s: &str, width: usize, align: Alignment, truncate: bool) -> Cow<'_, str> {
-    let cols = measure_text_width(s);
+struct RepeatedStringDisplay<'a> {
+    str: &'a str,
+    num: usize,
+}
 
-    if cols >= width {
-        return if truncate {
-            Cow::Borrowed(s.get(..width).unwrap_or(s))
-        } else {
-            Cow::Borrowed(s)
-        };
+impl<'a> fmt::Display for RepeatedStringDisplay<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        for _ in 0..self.num {
+            f.write_str(self.str)?;
+        }
+        Ok(())
     }
+}
 
-    let diff = width.saturating_sub(cols);
+struct PaddedStringDisplay<'a> {
+    str: &'a str,
+    width: usize,
+    align: Alignment,
+    truncate: bool,
+}
 
-    let (left_pad, right_pad) = match align {
-        Alignment::Left => (0, diff),
-        Alignment::Right => (diff, 0),
-        Alignment::Center => (diff / 2, diff.saturating_sub(diff / 2)),
-    };
+impl<'a> fmt::Display for PaddedStringDisplay<'a> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let cols = measure_text_width(self.str);
+        if cols >= self.width {
+            return match self.truncate {
+                true => f.write_str(self.str.get(..self.width).unwrap_or(self.str)),
+                false => f.write_str(self.str),
+            };
+        }
 
-    let mut rv = String::new();
-    for _ in 0..left_pad {
-        rv.push(' ');
-    }
-    rv.push_str(s);
-    for _ in 0..right_pad {
-        rv.push(' ');
+        let diff = self.width.saturating_sub(cols);
+        let (left_pad, right_pad) = match self.align {
+            Alignment::Left => (0, diff),
+            Alignment::Right => (diff, 0),
+            Alignment::Center => (diff / 2, diff.saturating_sub(diff / 2)),
+        };
+
+        for _ in 0..left_pad {
+            f.write_char(' ')?;
+        }
+        f.write_str(self.str)?;
+        for _ in 0..right_pad {
+            f.write_char(' ')?;
+        }
+        Ok(())
     }
-    Cow::Owned(rv)
 }
 
 #[derive(Clone, Default)]
@@ -467,31 +691,6 @@ impl Default for ProgressFinish {
     }
 }
 
-#[derive(Debug)]
-struct TemplateVar<'a> {
-    pub key: &'a str,
-    pub align: Alignment,
-    pub truncate: bool,
-    pub width: Option<usize>,
-    pub style: Option<Style>,
-    pub alt_style: Option<Style>,
-    pub last_element: bool,
-}
-
-impl<'a> TemplateVar<'a> {
-    fn duplicate_for_key<'b>(&self, key: &'b str) -> TemplateVar<'b> {
-        TemplateVar {
-            key,
-            align: self.align,
-            truncate: self.truncate,
-            width: self.width,
-            style: self.style.clone(),
-            alt_style: self.alt_style.clone(),
-            last_element: self.last_element,
-        }
-    }
-}
-
 #[derive(PartialEq, Eq, Debug, Copy, Clone)]
 enum Alignment {
     Left,
@@ -502,55 +701,47 @@ enum Alignment {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::draw_target::ProgressDrawTarget;
+    use crate::state::ProgressState;
 
     #[test]
     fn test_expand_template() {
-        let rv = expand_template("{{ {foo} {bar} }}", |var| var.key.to_uppercase());
-        assert_eq!(&rv, "{ FOO BAR }");
-        let rv = expand_template(r#"{ "foo": "{foo}", "bar": {bar} }"#, |var| {
-            var.key.to_uppercase()
-        });
-        assert_eq!(&rv, r#"{ "foo": "FOO", "bar": BAR }"#);
+        let mut style = ProgressStyle::default_bar();
+        style.format_map.0.insert("foo", |_| "FOO".into());
+        style.format_map.0.insert("bar", |_| "BAR".into());
+        let state = ProgressState::new(10, ProgressDrawTarget::stdout());
+
+        style.template = Template::from_str("{{ {foo} {bar} }}");
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], "{ FOO BAR }");
+
+        style.template = Template::from_str(r#"{ "foo": "{foo}", "bar": {bar} }"#);
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], r#"{ "foo": "FOO", "bar": BAR }"#);
     }
 
     #[test]
     fn test_expand_template_flags() {
         use console::set_colors_enabled;
         set_colors_enabled(true);
+        let mut style = ProgressStyle::default_bar();
+        style.format_map.0.insert("foo", |_| "XXX".into());
+        let state = ProgressState::new(10, ProgressDrawTarget::stdout());
+
+        style.template = Template::from_str("{foo:5}");
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], "XXX  ");
+
+        style.template = Template::from_str("{foo:.red.on_blue}");
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], "\u{1b}[31m\u{1b}[44mXXX\u{1b}[0m");
+
+        style.template = Template::from_str("{foo:^5.red.on_blue}");
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
 
-        let rv = expand_template("{foo:5}", |var| {
-            assert_eq!(var.key, "foo");
-            assert_eq!(var.width, Some(5));
-            "XXX".into()
-        });
-        assert_eq!(&rv, "XXX  ");
-
-        let rv = expand_template("{foo:.red.on_blue}", |var| {
-            assert_eq!(var.key, "foo");
-            assert_eq!(var.width, None);
-            assert_eq!(var.align, Alignment::Left);
-            assert_eq!(var.style, Some(Style::new().red().on_blue()));
-            "XXX".into()
-        });
-        assert_eq!(&rv, "\u{1b}[31m\u{1b}[44mXXX\u{1b}[0m");
-
-        let rv = expand_template("{foo:^5.red.on_blue}", |var| {
-            assert_eq!(var.key, "foo");
-            assert_eq!(var.width, Some(5));
-            assert_eq!(var.align, Alignment::Center);
-            assert_eq!(var.style, Some(Style::new().red().on_blue()));
-            "XXX".into()
-        });
-        assert_eq!(&rv, "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
-
-        let rv = expand_template("{foo:^5.red.on_blue/green.on_cyan}", |var| {
-            assert_eq!(var.key, "foo");
-            assert_eq!(var.width, Some(5));
-            assert_eq!(var.align, Alignment::Center);
-            assert_eq!(var.style, Some(Style::new().red().on_blue()));
-            assert_eq!(var.alt_style, Some(Style::new().green().on_cyan()));
-            "XXX".into()
-        });
-        assert_eq!(&rv, "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
+        style.template = Template::from_str("{foo:^5.red.on_blue/green.on_cyan}");
+        let rv = style.format_state(&state);
+        assert_eq!(&rv[0], "\u{1b}[31m\u{1b}[44m XXX \u{1b}[0m");
     }
 }