diff --git a/Cargo.toml b/Cargo.toml
index 10d710c..7c26c5a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -2,8 +2,8 @@
 name = "grits"
 authors = ["benjamin.van.nguyen@gmail.com"]
 description = """
-A text line processor that applies regular expressions with named captures
-to input lines and transforms them using a user-generated template.
+A line-text processor that applies regular expressions with named captures to input lines
+and transforms them using a template string. See the long help '--help' for further details and examples.
 """
 version = "0.2.0"
 edition = "2021"
diff --git a/README.md b/README.md
index d7de086..87b8d86 100644
--- a/README.md
+++ b/README.md
@@ -4,210 +4,39 @@
 [![Crates.io](https://img.shields.io/crates/v/grits.svg)](https://crates.io/crates/grits)
 [![Crates.io](https://img.shields.io/crates/d/grits)](https://crates.io/crates/grits)
 
-`grits` is a minimal, simple, and easy-to-use line text-processor that applies regular expressions with named captures to input lines
-and transforms them using a custom template string. It allows for efficient parsing, extracting, and formatting of text,
-including support for colorization and other attributes you'd get using ANSI escape sequences.
+A simple line-text formatter that makes it simple to parse, filter, and format live logs, turning noise into meaningful insights.
 
-The following example demonstrates how to apply `grits` to `tcpdump` to extract a packet's source (`src`) and destination (`dst`) IP address:
+![demo gif](images/log.gif)
 
-```bash
-sudo tcpdump -nn | grits -p '^(?<ts>[^ ]+)' \
-  -p 'IP\w? (?<src>[^ ]+)' \
-  -p '> (?<dst>[^ ]+):' \
-  -t '[{(cyan|bold):ts}] {(green|underlined):"src"}={src} {(yellow|underlined):"dst"}={dst}'
-```
-
-![demo image](images/demo.png)
-The top pane in the above screenshot is the raw output of `tcpdump` while the bottom pane shows the output being piped into `grits`.
-
-## Table of Contents
-
-* [Usage](#usage)
-* [Installation](#installation)
-* [Templating language](#templating-language)
-    - [Indexing](#indexing)
-    - [Default values](#default-values)
-    - [Attributes](#attributes)
-    - [Other examples](#other-examples)
-* [Completions](#completions)
-* [Contributing](#contributing)
-* [Donating](#donating)
-* [FAQ](#faq)
-
-## Usage
-
-```
-A text line processor that applies regular expressions with named captures to input lines
-and transforms them using a user-generated template. See the long help '--help' for further
-details and examples.
-
-Usage: grits [OPTIONS] --template <TEMPLATE> [FILES]...
-
-Arguments:
-  [FILES]...  Input files
-
-Options:
-  -p, --pattern <PATTERN>          A regular expression with named captures. Can be specified multiple times
-  -t, --template <TEMPLATE>        A template string that defines how to transform a line input. See long '--help'
-  -r, --require <REQUIRE>          Name of capture that must have at least one match for the output to show. Can be specified multiple times
-      --line-buffered              Force output to be line-buffered. By default, output is line buffered when stdout is a terminal and block-buffered otherwise
-  -c, --completions <COMPLETIONS>  Produce completions for shell and exit [possible values: bash, elvish, fish, powershell, zsh]
-  -h, --help                       Print help (see more with '--help')
-  -V, --version                    Print version
-```
-
-See the long `--help` description for further details and example from the command-line.
-
-## Installation
-
-### crates.io
+<p align="center">
+  <em>An example of Grits in action: the left pane shows Grits being applied, and the right pane displays the raw logs.</em>
+</p>
 
-```bash
-cargo install grits
-```
-
-### cURL
 
-```bash
-curl --proto '=https' --tlsv1.2 -LsSf https://github.com/solidiquis/grits/releases/download/v0.2.0/grits-installer.sh | sh
-```
+At its core, `grits` applies regular expressions with named captures to input lines. These captures are then available as variables
+(a.k.a. anchors) which can then be used in a `grits` template string. The template string supports text-alignment, colorization,
+as well as other attributes you'd expect using ANSI escape sequences.
 
-### Powershell
+The following example demonstrates how to apply `grits` to `tcpdump` to extract an output line's timestamp (`ts`) and
+a packet's source (`src`) and destination (`dst`) IP address:
 
 ```bash
-powershell -ExecutionPolicy Bypass -c "irm https://github.com/solidiquis/grits/releases/download/v0.2.0/grits-installer.ps1 | iex"
-```
-
-### Manual installation
-
-Check the [releases page](https://github.com/solidiquis/grits/releases) for prebuilt binaries.
-
-## Templating language
-
-`grits` uses a simple templating language to transform text, where templates consist of anchors.
-Anchors are placeholders enclosed within `{...}` that correspond to named capture groups from
-the regular expression applied to the input. Once a match is found, the value from the
-capture group is inserted into the anchor’s position in the template string.
-
-Here's an example:
-```bash
-echo 'level=info msg=foobar path=/baz' | grit -p 'msg=(?<log>[^ ]+)' -t 'transformed={log}'
-```
-
-In this command, we use a regular expression to capture the value associated with the msg field.
-The capture group is named `log`. The template string `transformed={log}` will replace `{log}` with
-the value captured from the input. The output will then be:
-
-```
-transformed=foobar
-```
-
-To summarize:
-- The regular expression `msg=(?<log>[^ ]+)` captures the value `foobar` into the `log` capture group.
-- The template `transformed={log}` uses the value of `log` to generate the output.
-
-The following are additional features of `grits` templating system:
-
-### Indexing
-
-When there are multiple matches for a given named capture group, you can use **indexing**
-to specify which occurrence of the capture to use. The index is placed in square brackets
-immediately after the anchor name.  For example, to access the second match of the `log`
-capture group, you would use:
-
-```
-{log[1]}
-```
-
-### Default values
-
-If a particular anchor doesn't have an associated match, default values can be chained using the `||`
-operator like so:
-
-```
-{log || foo || bar[1] || "NO MATCH"}
-```
-
-The first default value that doesn't produce a blank string will be used. Default values can be
-other anchors or a string literal.
-
-### Attributes
-
-Attributes offer additional means to transform text. Attributes are applied to anchors like so:
-
-```
-{(red|bold):ipaddr_v4}
-```
-
-Here is an example using attributes with default values:
-
-
-```
-{(red|bold):ipaddr_v4 || ipaddr_v6 || "NOMATCH"}
-```
-
-In the above example, `red` and `bold` will be applied the entire anchor.
-
-
-The following attributes are currently available:
-
-- `black` (apply a black foreground)
-- `red` (apply a red foreground)
-- `green` (apply a green foreground)
-- `yellow` (apply a yellow foreground)
-- `blue` (apply a blue foreground)
-- `magenta` (apply a magenta foreground)
-- `cyan` (apply a cyan foreground)
-- `white` (apply a white foreground)
-- `bg_black` (apply a black background)
-- `bg_red` (apply a red background)
-- `bg_green` (apply a green background)
-- `bg_yellow` (apply a yellow background)
-- `bg_blue` (apply a blue background)
-- `bg_magenta` (apply a magenta background)
-- `bg_cyan` (apply a cyan background)
-- `bg_white` (apply a white background)
-- `bold` (make text bold)
-- `underlined` (underline text)
-- `reverse` (reverse text)
-- `crossed_out` (crossout text)
-
-### Other examples
-
-1. Multi-file processing:
-
-```bash
-grits -p 'sysctl=(?<sysctl>.*)'` -t 'sysctl output: {sysctl}' file1 file2
-```
-
-2. Piping:
-
-```bash
-docker logs -f 93670ea0964c | grits -p 'log_level=info(?<log>.*)' -t 'INFO LOG: {log}'
-```
-
-3. Attributes, default values, and multiple regular expressions:
-
-```bash
-kubectl logs -f -n foo -l app=bar | grits \
-     -p '^kernel:(?<kern>.*)' \
-     -p '^sysctl:(?<sys>.*)' \
-     -t 'kernel={(cyan):kern || \"NONE\"} sysctl={(magenta):sys || \"NONE\"}'
+tcpdump -nn | grits -- \
+  -p '^(?<ts>[^ ]+)' \
+  -p 'IP\w? (?<src>[^ ]+)' \
+  -p '> (?<dst>[^ ]+):' \
+  -t '[{(cyan|bold):ts}] {(green|underlined):"src"}={(lalign(45)):src} {(yellow|underlined):"dst"}={dst}'
 ```
 
-## Completions
-
-Completions for supported shells can be generated using `grits --completions <SHELl>`. Consult your shell's documentation
-for how to setup completions. For `zsh`, completions are bootstrapped like so:
+![demo image](images/demo.png)
+<p align="center">
+  <em>The top pane in the above screenshot is the raw output of tcpdump while the bottom pane shows the output being piped into grits.</em>
+</p>
 
-```bash
-grits --completions zsh > ~/.oh-my-zsh/completions/_grits
-```
 
-## Colorization
+## Documentation
 
-`grits` follows the informal [NO_COLOR](https://no-color.org/) standard. Setting `NO_COLOR` to a non-blank value will disable output colorization.
-If stdout is not a terminal, colorization is automatically disabled.
+The documentation for `grits` can be found [here](./docs/help.md). It is also available in the CLI via `--help`.
 
 ## Contributing
 
diff --git a/docs/help.md b/docs/help.md
new file mode 100644
index 0000000..be51f56
--- /dev/null
+++ b/docs/help.md
@@ -0,0 +1,250 @@
+# Grits Documentation
+
+* [Usage](#usage)
+* [Installation](#installation)
+* [Templating language](#templating-language)
+    - [Indexing](#indexing)
+    - [Default values](#default-values)
+    - [Attributes](#attributes)
+    - [Conditional attributes](#conditional-attributes)
+    - [Filtering](#filtering)
+    - [Other examples](#other-examples)
+* [Completions](#completions)
+* [Colorization](#colorization)
+
+## Usage
+
+```
+A text line processor that applies regular expressions with named captures to input lines
+and transforms them using a user-generated template. See the long help '--help' for further
+details and examples.
+
+Usage: grits [OPTIONS] [FILES]...
+
+Arguments:
+  [FILES]...  Input files
+
+Options:
+  -p, --pattern <PATTERN>            A regular expression with named captures. Can be specified multiple times
+  -t, --template <TEMPLATE>          A template string that defines how to transform a line input using times. Can be specified multiple times. See long '--help'
+  -s, --separator <SEPARATOR>        Separator used to join results of transforming each template if multiple are specified [default: ]
+  -r, --require <REQUIRE>            Comma-separated capture names that must have a match for a given input line to be processed; otherwise it is ignored
+      --require-mode <REQUIRE_MODE>  Modify '-r, --require' to require matching on all specified capture names or any [default: all] [possible values: all, any]
+      --line-buffered                Force output to be line-buffered. By default, output is line buffered when stdout is a terminal and block-buffered otherwise
+  -c, --completions <COMPLETIONS>    Produce completions for shell and exit [possible values: bash, elvish, fish, powershell, zsh]
+  -h, --help                         Print help (see more with '--help')
+  -V, --version                      Print version
+```
+
+See the long `--help` description for further details and example from the command-line.
+
+## Installation
+
+### crates.io
+
+```bash
+cargo install grits
+```
+
+### cURL
+
+```bash
+curl --proto '=https' --tlsv1.2 -LsSf https://github.com/solidiquis/grits/releases/download/v0.2.0/grits-installer.sh | sh
+```
+
+### Powershell
+
+```bash
+powershell -ExecutionPolicy Bypass -c "irm https://github.com/solidiquis/grits/releases/download/v0.2.0/grits-installer.ps1 | iex"
+```
+
+### Manual installation
+
+Check the [releases page](https://github.com/solidiquis/grits/releases) for prebuilt binaries.
+
+## Templating language
+
+`grits` uses a simple templating language to transform text. Templates consist of anchors.
+Anchors are placeholders enclosed within `{...}` that correspond to named capture groups from
+the regular expression applied to the input. Once a match is found, the value from the
+capture group is inserted into the anchor’s position in the template string.
+
+Here's an example:
+```bash
+echo 'level=info msg=foobar path=/baz' | grit -p 'msg=(?<log>[^ ]+)' -t 'transformed={log}'
+```
+
+In this command, we use a regular expression to capture the value associated with the msg field.
+The capture group is named `log`. The template string `transformed={log}` will replace `{log}` with
+the value captured from the input. The output will then be:
+
+```
+transformed=foobar
+```
+
+To summarize:
+- The regular expression `msg=(?<log>[^ ]+)` captures the value `foobar` into the `log` capture group.
+- The template `transformed={log}` uses the value of `log` to generate the output.
+
+The following are additional features of `grits` templating system:
+
+### Indexing
+
+When there are multiple matches for a given named capture group, you can use **indexing**
+to specify which occurrence of the capture to use. The index is placed in square brackets
+immediately after the anchor name.  For example, to access the second match of the `log`
+capture group, you would use:
+
+```
+{log[1]}
+```
+
+### Default values
+
+If a particular anchor doesn't have an associated match, default values can be chained using the `||`
+operator like so:
+
+```
+{log || foo || bar[1] || "NO MATCH"}
+```
+
+The first default value that doesn't produce a blank string will be used. Default values can be
+other anchors or a string literal.
+
+### Attributes
+
+Attributes offer additional means to transform text. Attributes are applied to anchors like so:
+
+```
+{(red|bold):ipaddr_v4}
+```
+
+Here is an example using attributes with default values:
+
+
+```
+{(red|bold):ipaddr_v4 || ipaddr_v6 || "NOMATCH"}
+```
+
+In the above example, `red` and `bold` will be applied the entire anchor.
+
+
+The following attributes are currently available:
+
+- `black` (apply a black foreground)
+- `red` (apply a red foreground)
+- `green` (apply a green foreground)
+- `yellow` (apply a yellow foreground)
+- `blue` (apply a blue foreground)
+- `magenta` (apply a magenta foreground)
+- `cyan` (apply a cyan foreground)
+- `white` (apply a white foreground)
+- `bg_black` (apply a black background)
+- `bg_red` (apply a red background)
+- `bg_green` (apply a green background)
+- `bg_yellow` (apply a yellow background)
+- `bg_blue` (apply a blue background)
+- `bg_magenta` (apply a magenta background)
+- `bg_cyan` (apply a cyan background)
+- `bg_white` (apply a white background)
+- `bold` (make text bold)
+- `underlined` (underline text)
+- `reverse` (reverse text)
+- `crossed_out` (crossout text)
+- `lalign(number)` (left aligns text using specified argument as the width and an empty space, `' '` as the fill character)
+- `ralign(number)` (right aligns text using specified argument as the width and an empty space, `' '` as the fill character)
+- `calign(number)` (center aligns text using specified argument as the width and an empty space, `' '` as the fill character)
+
+### Conditional attributes
+
+Say you have these logs:
+
+```
+level=INFO msg="some info"
+level=ERROR msg="some error"
+```
+
+You use the following capture group to grab the log severity level:
+
+```
+'^level=(?<lvl>\w+)'
+```
+
+Depending on if it's `ERROR` or `INFO`, we may want to apply different colors. To achieve this affect, we can apply a `?` operator like so:
+
+```bash
+grits -p '^level=(?<lvl>\w+)' -t '${(?red("ERROR")|?cyan("INFO")):lvl}'
+```
+
+This will ensure that `ERROR` is printed with a red foreground while `INFO` is printed with a cyan foreground. The `?` operator modifies attributes
+such that its first argument is a regular expression. If it's first argument matches the result of the capture group, then that attribute is applied.
+
+The `?` operator is always prepended onto the attribute name like so: `?red`, `?cyan`, etc..
+
+Here is another example of conditional attributes being applied in a case-insensitive manner using a regular expression instead of a string literal:
+
+```bash
+grits -p '^level=(?<lvl>\w+)' -t '${(?red("(?i)error")|?cyan("(?i)info")):lvl}'
+```
+
+### Filtering
+
+If you want the result of a template transformation to show only if certain anchors have a corresponding match, then you can make use of the `!` operator
+which is always placed immediate after the opening `{` of an anchor.
+
+Say you have the following log lines:
+
+```
+level=INFO msg="some info"
+level=ERROR msg="some error"
+```
+
+Let's say you want to filter only the `INFO` logs, everything else should be ignored. You can accomplish this using the operator `!` like so:
+
+```bash
+grits -p '^level=(?<lvl>INFO)' -t '${!lvl}'
+```
+
+What this effectively accomplishes is that only logs that have a match for the `lvl` capture group will be transformed. Here is what filtering
+looks like with attributes:
+
+```bash
+grits -p '^level=(?<lvl>INFO)' -t '${!(red|bold):lvl}'
+```
+
+### Other examples
+
+1. Multi-file processing:
+
+```bash
+grits -p 'sysctl=(?<sysctl>.*)'` -t 'sysctl output: {sysctl}' file1 file2
+```
+
+2. Piping:
+
+```bash
+docker logs -f 93670ea0964c | grits -p 'log_level=info(?<log>.*)' -t 'INFO LOG: {log}'
+```
+
+3. Attributes, default values, and multiple regular expressions:
+
+```bash
+kubectl logs -f -n foo -l app=bar | grits \
+     -p '^kernel:(?<kern>.*)' \
+     -p '^sysctl:(?<sys>.*)' \
+     -t 'kernel={(cyan):kern || \"NONE\"} sysctl={(magenta):sys || \"NONE\"}'
+```
+
+## Completions
+
+Completions for supported shells can be generated using `grits --completions <SHELl>`. Consult your shell's documentation
+for how to setup completions. For `zsh`, completions are bootstrapped like so:
+
+```bash
+grits --completions zsh > ~/.oh-my-zsh/completions/_grits
+```
+
+## Colorization
+
+`grits` follows the informal [NO_COLOR](https://no-color.org/) standard. Setting `NO_COLOR` to a non-blank value will disable output colorization.
+If stdout is not a terminal, colorization is automatically disabled.
diff --git a/images/demo.png b/images/demo.png
index 88798af..a88c294 100644
Binary files a/images/demo.png and b/images/demo.png differ
diff --git a/images/log.gif b/images/log.gif
new file mode 100644
index 0000000..0fa0f9e
Binary files /dev/null and b/images/log.gif differ
diff --git a/src/cli.rs b/src/cli.rs
index f5d1937..6bc8195 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -10,148 +10,8 @@ use std::{env, fmt, str::FromStr};
     about = "
 A text line processor that applies regular expressions with named captures to input lines
 and transforms them using a user-generated template. See the long help '--help' for further
-details and examples.",
-    long_about = "
-Sections:
-    - INTRODUCTION
-    - COLORIZATION
-    - OUTPUT TEMPLATE
-    - ATTRIBUTES
-    - EXAMPLES
-
-------------------
----INTRODUCTION---
-------------------
-Grits is a line processor that applies regular expression containing named captures to
-input lines and transforms them using a custom template string. For example, say we had
-the following input line which is stored in `$LINE`:
-
-    kernel=Memory: 125312k/129720k available (1540k kernel code sysctl=NONE
-
-All we're really interested in is how much memory is left, the rest can be considered noise.
-We'll apply the following regular expression against the input line to extract the remaining
-memory:
-
-    Memory: (?<mem>[^ ]+)
-
-The remaining memory is stored in a capture called 'mem'. Now to transform the input line into
-our desired output, we'll use the following template string:
-
-    Remaining memory: {mem}
-
-Putting everything together the following command:
-
-    $ echo $LINE | grits -p 'Memory: (?<mem>[^ ]+)' -o 'Remaining memory: {mem}'
-
-Gets us the following output:
-
-    Remaining memory: 125312k/129720k
-
-------------------------
-------COLORIZATION------
-------------------------
-
-Colorization is disabled under two circumstances:
-
-    1. If the `NO_COLOR` environment variable is set and not blank.
-    2. Standard output is not a terminal.
-
-An example of how to disable color:
-
-    $ NO_COLOR=1 grits -p 'Memory: (?<mem>[^ ]+)' -o 'Remaining memory: {mem}' file
-
-------------------------
-----OUTPUT TEMPLATE-----
-------------------------
-The output template which is specified using `-o, --output-template` is a format string
-that defines how to transform a line input and ultimately produce an output. The output
-template contains constructs called anchors which looks like the following:
-    
-    {log}
-
-This anchor, which begins with '{' and ends with '}', is a reference to a named capture
-from a regular expression that a user provides. If, for a given input line, there is a
-match for the `log` capture, then the value associated with the `log` capture will be used
-to interpolate the output string at the `log` anchor. For example:
-
-    $ echo 'level=info msg=foobar path=/baz' | grit -p 'msg=(?<log>[^ ]+)' -o 'transformed={log}'
-
-Will get you the following output:
-
-    transformed=foobar
-
-Anchors come with a handful of other features as well:
-
-1. Indexing in the case of multiple matches for a given a single named capture group:
-
-    ${log[1]}
-
-2. Chain default values, which can be another anchor or a string literal. The first non-blank
-value will be used in the output (ultimately falls back to an empty string):
-
-    {log || foo || bar[1] || \"NO MATCH\"}
-
-3. Apply to an anchor like so:
-
-    {(red|bold):foo}
-
-4. Apply ANSI-escape sequences to literals:
-
-    {(cyan|underlined):\"foo\"}
-
-5. Escape characters with special meaning such as '{' with '\\':
-
-    USD: \\{foo\\} {amount}
-
-----------------
----ATTRIBUTES---
-----------------
-As mentioned in the section prior, attributes are available to stylize the result of processing
-the anchors. Multiple attributes may be used together like so:
-
-    {(red|bold|underlined):foo}
-
-The following attributes are currently available:
-
-- black (apply a black foreground)
-- red (apply a red foreground)
-- green (apply a green foreground)
-- yellow (apply a yellow foreground)
-- blue (apply a blue foreground)
-- magenta (apply a magenta foreground)
-- cyan (apply a cyan foreground)
-- white (apply a white foreground)
-- bg_black (apply a black background)
-- bg_red (apply a red background)
-- bg_green (apply a green background)
-- bg_yellow (apply a yellow background)
-- bg_blue (apply a blue background)
-- bg_magenta (apply a magenta background)
-- bg_cyan (apply a cyan background)
-- bg_white (apply a white background)
-- bold (make text bold)
-- underlined (underline text)
-- reverse (reverse text)
-- crossed_out (crossout text)
-
-----------------
-----EXAMPLES----
-----------------
-1. Multi-file processing:
-
-    $ grits -p 'sysctl=(?<sysctl>.*)'` -p 'sysctl output: {sysctl}' file1 file2
-
-2. Piping:
-
-    $ docker logs -f 93670ea0964c | grits -p 'log_level=info(?<log>.*)' -o 'INFO LOG: {log}'
-
-3. Attributes, default values, and multiple regular expressions:
-
-    $ kubectl logs -f -n foo -l app=bar | grits \\
-         -p '^kernel:(?<kern>.*)' \\
-         -p '^sysctl:(?<sys>.*)' \\
-         -o kernel=${(cyan):kern || \"NONE\"} sysctl={(magenta):sys || \"NONE\"}
-"
+details and examples or visit the 'https://github.com/solidiquis/grits' repository.",
+    long_about = include_str!("../docs/help.md"),
 )]
 pub struct Cli {
     /// A regular expression with named captures. Can be specified multiple times.
@@ -175,8 +35,7 @@ pub struct Cli {
     #[arg(short, long, group = "req")]
     pub require: Option<String>,
 
-    /// Modify behavior of '-r, --require' to require matching on all specified capture names or
-    /// any.
+    /// Modify '-r, --require' to require matching on all specified capture names or any.
     #[arg(long, requires = "req", default_value_t = RequireMode::default())]
     pub require_mode: RequireMode,
 
diff --git a/src/line.rs b/src/line.rs
index 50586a3..6c12c01 100644
--- a/src/line.rs
+++ b/src/line.rs
@@ -110,6 +110,9 @@ pub fn process_lines(tty: &mut TtyContext, args: &Cli) -> Result<()> {
             .collect::<Vec<String>>()
             .join(separator);
 
+        if output.is_empty() {
+            continue;
+        }
         writer.writeln(&output)?;
     }
     Ok(())
diff --git a/src/template/error.rs b/src/template/error.rs
index 8952f61..dbe838d 100644
--- a/src/template/error.rs
+++ b/src/template/error.rs
@@ -109,6 +109,14 @@ impl ParseError {
         }
     }
 
+    pub fn string_parameter_missing_closing_quote(char_index: usize, chars: &[char]) -> Self {
+        ParseError {
+            char_index,
+            partial_template: chars.iter().collect(),
+            message: String::from("Attribute's string parameter is missing a closing quote."),
+        }
+    }
+
     pub fn default_parsing_disallowed_char(char_index: usize, chars: &[char]) -> Self {
         ParseError {
             char_index,
@@ -162,14 +170,6 @@ impl ParseError {
             ),
         }
     }
-
-    pub fn attribute_invalid_char(char_index: usize, chars: &[char]) -> Self {
-        ParseError {
-            char_index,
-            partial_template: chars.iter().collect(),
-            message: String::from("Invalid syntax: unrecognized character in attributes"),
-        }
-    }
 }
 
 #[test]
diff --git a/src/template/mod.rs b/src/template/mod.rs
index 0349fd7..bcfc893 100644
--- a/src/template/mod.rs
+++ b/src/template/mod.rs
@@ -82,7 +82,7 @@ impl OutputTemplate {
                             out.push_str(val);
                         } else {
                             let stylized = Attribute::apply(val, &anchor.attributes);
-                            out.push_str(&format!("{stylized}"));
+                            out.push_str(&stylized);
                         }
                         continue;
                     }
@@ -99,7 +99,7 @@ impl OutputTemplate {
                                     out.push_str(val);
                                 } else {
                                     let stylized = Attribute::apply(val, &anchor.attributes);
-                                    out.push_str(&format!("{stylized}"));
+                                    out.push_str(&stylized);
                                 }
                                 break;
                             }
@@ -111,7 +111,7 @@ impl OutputTemplate {
                                         out.push_str(val);
                                     } else {
                                         let stylized = Attribute::apply(val, &anchor.attributes);
-                                        out.push_str(&format!("{stylized}"));
+                                        out.push_str(&stylized);
                                     }
                                     break;
                                 }
diff --git a/src/template/parse/attr.rs b/src/template/parse/attr.rs
index 6091111..dc1dba5 100644
--- a/src/template/parse/attr.rs
+++ b/src/template/parse/attr.rs
@@ -1,10 +1,17 @@
-use anyhow::{format_err, Error};
-use crossterm::style::{StyledContent, Stylize};
-use std::str::FromStr;
+use super::super::token::{LITERAL_DOUBLE_QUOTE, LITERAL_SINGLE_QUOTE, PARAM_DELIMETER};
+use anyhow::{format_err, Context, Result};
+use crossterm::style::Stylize;
+use regex::Regex;
+
+#[derive(Debug, Clone)]
+pub struct Attribute {
+    pub kind: AttributeKind,
+    pub must_match: Option<Regex>,
+}
 
 /// Attributes that can be applied to an anchor.
 #[derive(Debug, Clone, Copy, Eq, PartialEq)]
-pub enum Attribute {
+pub enum AttributeKind {
     Black,
     Red,
     Green,
@@ -25,66 +32,168 @@ pub enum Attribute {
     Underlined,
     Reverse,
     CrossedOut,
+
+    /// Comes in three flavors:
+    /// - `lalign` (left align)
+    /// - `ralign` (right align)
+    /// - `calign` (center align)
+    ///
+    /// First and only argument is the width
+    /// - `lalign(10)`
+    Align {
+        direction: Alignment,
+        width: usize,
+    },
+}
+
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum Alignment {
+    Left,
+    Right,
+    Center,
 }
 
 impl Attribute {
-    /// Applies select attributes to a given text data.
-    pub fn apply<'a>(txt: &'a str, attributes: &[Self]) -> StyledContent<&'a str> {
-        let mut val = txt.stylize();
-        for attribute in attributes {
-            val = match attribute {
-                Self::Black => val.black(),
-                Self::Red => val.red(),
-                Self::Green => val.green(),
-                Self::Yellow => val.yellow(),
-                Self::Blue => val.blue(),
-                Self::Magenta => val.magenta(),
-                Self::Cyan => val.cyan(),
-                Self::White => val.white(),
-                Self::Bold => val.bold(),
-                Self::Underlined => val.underlined(),
-                Self::Reverse => val.reverse(),
-                Self::CrossedOut => val.crossed_out(),
-                Self::BgBlack => val.on_black(),
-                Self::BgRed => val.on_red(),
-                Self::BgGreen => val.on_green(),
-                Self::BgYellow => val.on_yellow(),
-                Self::BgBlue => val.on_blue(),
-                Self::BgMagenta => val.on_magenta(),
-                Self::BgCyan => val.on_cyan(),
-                Self::BgWhite => val.on_white(),
-            };
+    /// TODO: Clean this up
+    pub fn parse(val: String, raw_args: Option<String>) -> Result<Self> {
+        let mut conditional = false;
+
+        let attr_name = if let Some(stripped) = val.strip_prefix("?") {
+            conditional = true;
+            stripped.to_lowercase()
+        } else {
+            val.to_lowercase()
+        };
+
+        let args = raw_args.map_or_else(Vec::new, |rarg| {
+            rarg.split(PARAM_DELIMETER)
+                .map(|raws| {
+                    raws.trim()
+                        .trim_start_matches(LITERAL_SINGLE_QUOTE)
+                        .trim_start_matches(LITERAL_DOUBLE_QUOTE)
+                        .trim_end_matches(LITERAL_SINGLE_QUOTE)
+                        .trim_end_matches(LITERAL_DOUBLE_QUOTE)
+                        .to_string()
+                })
+                .collect::<Vec<String>>()
+        });
+        let mut args_iter = args.iter();
+        let mut must_match = None;
+
+        if conditional {
+            if let Some(pattern) = args_iter.next() {
+                let re = Regex::new(pattern).with_context(|| {
+                    format!(
+                        "expected first argument of conditional attribute to be a valid regular expression: {pattern}"
+                    )
+                })?;
+                must_match = Some(re);
+            } else {
+                return Err(format_err!(
+                    "Expected conditional attribute to have at least 1 argument."
+                ));
+            }
         }
-        val
-    }
-}
 
-impl FromStr for Attribute {
-    type Err = Error;
+        let kind = match attr_name.as_str() {
+            "black" => AttributeKind::Black,
+            "red" => AttributeKind::Red,
+            "green" => AttributeKind::Green,
+            "yellow" => AttributeKind::Yellow,
+            "blue" => AttributeKind::Blue,
+            "magenta" => AttributeKind::Magenta,
+            "cyan" => AttributeKind::Cyan,
+            "white" => AttributeKind::White,
+            "bg_black" | "bg-black" => AttributeKind::BgBlack,
+            "bg_red" | "bg-red" => AttributeKind::BgRed,
+            "bg_green" | "bg-green" => AttributeKind::BgGreen,
+            "bg_yellow" | "bg-yellow" => AttributeKind::BgYellow,
+            "bg_blue" | "bg-blue" => AttributeKind::BgBlue,
+            "bg_magenta" | "bg-magenta" => AttributeKind::BgMagenta,
+            "bg_cyan" | "bg-cyan" => AttributeKind::BgCyan,
+            "bg_white" | "bg-white" => AttributeKind::BgWhite,
+            "bold" => AttributeKind::Bold,
+            "underlined" => AttributeKind::Underlined,
+            "reverse" => AttributeKind::Reverse,
+            "crossedout" | "crossed_out" | "crossed-out" => AttributeKind::CrossedOut,
+            "lalign" | "calign" | "ralign" => {
+                let width = args_iter
+                    .next()
+                    .map(|w| {
+                        w.parse::<usize>().map_err(|err| {
+                            format_err!("expected first argument to '{attr_name}' to be a number: {err}")
+                        })
+                    })
+                    .ok_or_else(|| format_err!("expected at least one argument for '{attr_name}'"))??;
+
+                match attr_name.as_str() {
+                    "lalign" => AttributeKind::Align {
+                        direction: Alignment::Left,
+                        width,
+                    },
+                    "calign" => AttributeKind::Align {
+                        direction: Alignment::Center,
+                        width,
+                    },
+                    "ralign" => AttributeKind::Align {
+                        direction: Alignment::Right,
+                        width,
+                    },
+                    _ => unreachable!(),
+                }
+            }
+            _ => return Err(format_err!("unrecognized attribute '{val}'")),
+        };
 
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "black" => Ok(Attribute::Black),
-            "red" => Ok(Attribute::Red),
-            "green" => Ok(Attribute::Green),
-            "yellow" => Ok(Attribute::Yellow),
-            "blue" => Ok(Attribute::Blue),
-            "magenta" => Ok(Attribute::Magenta),
-            "cyan" => Ok(Attribute::Cyan),
-            "white" => Ok(Attribute::White),
-            "bg_black" | "bg-black" => Ok(Attribute::BgBlack),
-            "bg_red" | "bg-red" => Ok(Attribute::BgRed),
-            "bg_green" | "bg-green" => Ok(Attribute::BgGreen),
-            "bg_yellow" | "bg-yellow" => Ok(Attribute::BgYellow),
-            "bg_blue" | "bg-blue" => Ok(Attribute::BgBlue),
-            "bg_magenta" | "bg-magenta" => Ok(Attribute::BgMagenta),
-            "bg_cyan" | "bg-cyan" => Ok(Attribute::BgCyan),
-            "bg_white" | "bg-white" => Ok(Attribute::BgWhite),
-            "bold" => Ok(Attribute::Bold),
-            "underlined" => Ok(Attribute::Underlined),
-            "reverse" => Ok(Attribute::Reverse),
-            "crossedout" | "crossed_out" | "crossed-out" => Ok(Attribute::CrossedOut),
-            _ => Err(format_err!("unrecognized attribute '{s}'")),
+        Ok(Self { kind, must_match })
+    }
+
+    /// Applies select attributes to a given text data.
+    pub fn apply(txt: &str, attributes: &[Self]) -> String {
+        let mut val = txt.to_string().stylize();
+        for attribute in attributes {
+            if let Some(re) = attribute.must_match.as_ref() {
+                if !re.is_match(txt) {
+                    continue;
+                }
+            }
+            val = match attribute.kind {
+                AttributeKind::Black => val.black(),
+                AttributeKind::Red => val.red(),
+                AttributeKind::Green => val.green(),
+                AttributeKind::Yellow => val.yellow(),
+                AttributeKind::Blue => val.blue(),
+                AttributeKind::Magenta => val.magenta(),
+                AttributeKind::Cyan => val.cyan(),
+                AttributeKind::White => val.white(),
+                AttributeKind::Bold => val.bold(),
+                AttributeKind::Underlined => val.underlined(),
+                AttributeKind::Reverse => val.reverse(),
+                AttributeKind::CrossedOut => val.crossed_out(),
+                AttributeKind::BgBlack => val.on_black(),
+                AttributeKind::BgRed => val.on_red(),
+                AttributeKind::BgGreen => val.on_green(),
+                AttributeKind::BgYellow => val.on_yellow(),
+                AttributeKind::BgBlue => val.on_blue(),
+                AttributeKind::BgMagenta => val.on_magenta(),
+                AttributeKind::BgCyan => val.on_cyan(),
+                AttributeKind::BgWhite => val.on_white(),
+                AttributeKind::Align { direction, width } => match direction {
+                    Alignment::Left => {
+                        let val = val.to_string();
+                        format!("{val:<width$}", width = width).stylize()
+                    }
+                    Alignment::Right => {
+                        let val = val.to_string();
+                        format!("{val:>width$}", width = width).stylize()
+                    }
+                    Alignment::Center => {
+                        let val = val.to_string();
+                        format!("{val:^width$}", width = width).stylize()
+                    }
+                },
+            };
         }
+        val.to_string()
     }
 }
diff --git a/src/template/parse/mod.rs b/src/template/parse/mod.rs
index 297de78..687bc5e 100644
--- a/src/template/parse/mod.rs
+++ b/src/template/parse/mod.rs
@@ -2,18 +2,18 @@ use super::{
     error::ParseError,
     token::{
         ANCHOR_CLOSE, ANCHOR_OPEN, ATTRIBUTE_CLOSE, ATTRIBUTE_DELIMETER, ATTRIBUTE_END, ATTRIBUTE_OPEN, DEFAULT_PIPE,
-        ESCAPE, INDEX_CLOSE, INDEX_OPEN, LITERAL_DOUBLE_QUOTE, LITERAL_SINGLE_QUOTE, REQUIRED,
+        ESCAPE, INDEX_CLOSE, INDEX_OPEN, LITERAL_DOUBLE_QUOTE, LITERAL_SINGLE_QUOTE, PARAM_CLOSE, PARAM_OPEN, REQUIRED,
     },
 };
 use anyhow::{format_err, Result};
 use std::{
+    cmp::Ordering,
     fmt::{self, Debug},
-    str::FromStr,
 };
 
 /// Concerned with ANSI-escape sequences that can be applied to anchors.
 pub mod attr;
-pub use attr::Attribute;
+pub use attr::{Attribute, AttributeKind};
 
 /// Concerned with validating certain properties that are computed during parsing
 /// such as anchor name.
@@ -116,13 +116,13 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
         ParseStateMode::Base => {
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
-                let Some(ch) = mode.tokens.get(i).copied() else {
+                let Some(token) = mode.tokens.get(i).copied() else {
                     return Ok(());
                 };
-                if ch == ESCAPE {
+                if token == ESCAPE {
                     mode.mode = ParseStateMode::Escaping;
                     return parse_impl(mode, anchors, rules);
-                } else if ch == ANCHOR_OPEN {
+                } else if token == ANCHOR_OPEN {
                     mode.mode = ParseStateMode::AnchorBegin;
                     mode.bound_anchor = Some(Anchor {
                         start: mode.cursor,
@@ -147,13 +147,17 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
         ParseStateMode::AnchorBegin => {
             mode.cursor += 1;
             for i in mode.cursor..mode.tokens.len() {
-                if mode.tokens.get(mode.cursor).is_some_and(|ch| ch.is_ascii_whitespace()) {
+                if mode
+                    .tokens
+                    .get(mode.cursor)
+                    .is_some_and(|token| token.is_ascii_whitespace())
+                {
                     mode.cursor = i;
                     break;
                 }
                 continue;
             }
-            if mode.tokens.get(mode.cursor).is_some_and(|ch| *ch == REQUIRED) {
+            if mode.tokens.get(mode.cursor).is_some_and(|token| *token == REQUIRED) {
                 let Some(anchor) = mode.bound_anchor.as_mut() else {
                     log::error!("expected mode.bound_anchor to be `Some` while in `AnchorParseBegin`");
                     return Err(format_err!(
@@ -163,7 +167,11 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
                 anchor.required = true;
                 mode.cursor += 1;
             }
-            if mode.tokens.get(mode.cursor).is_some_and(|ch| *ch == ATTRIBUTE_OPEN) {
+            if mode
+                .tokens
+                .get(mode.cursor)
+                .is_some_and(|token| *token == ATTRIBUTE_OPEN)
+            {
                 mode.mode = ParseStateMode::AttributeParse;
             } else {
                 mode.mode = ParseStateMode::AnchorParseBase;
@@ -184,15 +192,15 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
 
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
-                let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                     return Err(ParseError::unclosed_anchor(mode.cursor - 1, &mode.tokens).into());
                 };
-                if ch == INDEX_OPEN {
-                    for ch in &mode.tokens[begin..end] {
-                        if ch.is_ascii_whitespace() {
+                if token == INDEX_OPEN {
+                    for token in &mode.tokens[begin..end] {
+                        if token.is_ascii_whitespace() {
                             continue;
                         }
-                        anchor.name.push(*ch)
+                        anchor.name.push(*token)
                     }
                     let prev_token = mode.tokens.get(mode.cursor - 1).copied();
 
@@ -201,12 +209,12 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
                     }
                     mode.mode = ParseStateMode::AnchorParseIndex;
                     break;
-                } else if ch == ANCHOR_CLOSE {
-                    for ch in &mode.tokens[begin..end] {
-                        if ch.is_ascii_whitespace() {
+                } else if token == ANCHOR_CLOSE {
+                    for token in &mode.tokens[begin..end] {
+                        if token.is_ascii_whitespace() {
                             continue;
                         }
-                        anchor.name.push(*ch)
+                        anchor.name.push(*token)
                     }
                     if (anchor.name.is_empty() || !rules.name_is_valid(&anchor.name)) && anchor.defaults.is_empty() {
                         return Err(ParseError::invalid_anchor_name(mode.cursor - 1, &mode.tokens).into());
@@ -222,22 +230,22 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
                     anchor.end = mode.cursor + 1;
                     anchors.push(anchor);
                     break;
-                } else if ch == DEFAULT_PIPE {
-                    for ch in &mode.tokens[begin..end] {
-                        if ch.is_ascii_whitespace() {
+                } else if token == DEFAULT_PIPE {
+                    for token in &mode.tokens[begin..end] {
+                        if token.is_ascii_whitespace() {
                             continue;
                         }
-                        anchor.name.push(*ch)
+                        anchor.name.push(*token)
                     }
                     mode.cursor += 1;
-                    let next_token_is_pipe = mode.tokens.get(mode.cursor).is_some_and(|ch| *ch == DEFAULT_PIPE);
+                    let next_token_is_pipe = mode.tokens.get(mode.cursor).is_some_and(|token| *token == DEFAULT_PIPE);
 
                     if anchor.name.is_empty() || !next_token_is_pipe {
                         return Err(ParseError::invalid_default_value_operation(mode.cursor - 1, &mode.tokens).into());
                     }
                     mode.mode = ParseStateMode::AnchorParseDefaultValue;
                     break;
-                } else if ch == LITERAL_DOUBLE_QUOTE || ch == LITERAL_SINGLE_QUOTE {
+                } else if token == LITERAL_DOUBLE_QUOTE || token == LITERAL_SINGLE_QUOTE {
                     mode.mode = ParseStateMode::AnchorParseDefaultLiteral;
                     break;
                 }
@@ -259,7 +267,7 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             };
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
-                if mode.tokens.get(i).is_some_and(|ch| *ch == INDEX_CLOSE) {
+                if mode.tokens.get(i).is_some_and(|token| *token == INDEX_CLOSE) {
                     mode.cursor += 1;
                     break;
                 }
@@ -285,16 +293,16 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
 
-                let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                     break;
                 };
-                if ch.is_ascii_whitespace() {
+                if token.is_ascii_whitespace() {
                     continue;
-                } else if ch == LITERAL_SINGLE_QUOTE || ch == LITERAL_DOUBLE_QUOTE {
+                } else if token == LITERAL_SINGLE_QUOTE || token == LITERAL_DOUBLE_QUOTE {
                     mode.cursor -= 1;
                     mode.mode = ParseStateMode::AnchorParseDefaultLiteral;
                     return parse_impl(mode, anchors, rules);
-                } else if rules.name_is_valid(&ch.to_string()) {
+                } else if rules.name_is_valid(&token.to_string()) {
                     mode.cursor -= 1;
                     mode.mode = ParseStateMode::AnchorParseDefaultAnchor;
                     return parse_impl(mode, anchors, rules);
@@ -308,7 +316,12 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
         ParseStateMode::AnchorParseDefaultLiteral => {
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
-                if mode.tokens.get(i).copied().is_some_and(|ch| ch.is_ascii_whitespace()) {
+                if mode
+                    .tokens
+                    .get(i)
+                    .copied()
+                    .is_some_and(|token| token.is_ascii_whitespace())
+                {
                     continue;
                 }
                 break;
@@ -327,13 +340,13 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             for _ in mode.cursor..mode.tokens.len() {
                 mode.cursor += 1;
 
-                let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                     break;
                 };
-                if ch == ESCAPE {
+                if token == ESCAPE {
                     mode.cursor += 1;
                     continue;
-                } else if ch == opening_quote {
+                } else if token == opening_quote {
                     let Some(bound_anchor) = mode.bound_anchor.as_mut() else {
                         log::error!("expected mode.bound_anchor to be `Some` during `AnchorParseDefaultLiteral`");
                         return Err(format_err!(
@@ -355,7 +368,12 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             mode.cursor += 1;
             for i in mode.cursor..mode.tokens.len() {
                 mode.cursor = i;
-                if mode.tokens.get(i).copied().is_some_and(|ch| ch.is_ascii_whitespace()) {
+                if mode
+                    .tokens
+                    .get(i)
+                    .copied()
+                    .is_some_and(|token| token.is_ascii_whitespace())
+                {
                     continue;
                 }
                 break;
@@ -367,10 +385,10 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             while mode.cursor < mode.tokens.len() {
                 mode.cursor += 1;
 
-                let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                     break;
                 };
-                if index.is_some() || ch.is_ascii_whitespace() || ch == DEFAULT_PIPE || ch == ANCHOR_CLOSE {
+                if index.is_some() || token.is_ascii_whitespace() || token == DEFAULT_PIPE || token == ANCHOR_CLOSE {
                     let name: String = mode.tokens[begin..end].iter().collect();
                     if !rules.name_is_valid(&name) {
                         return Err(ParseError::invalid_anchor_name(mode.cursor - 1, &mode.tokens).into());
@@ -384,17 +402,17 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
                     anchor.defaults.push(DefaultValue::Anchor { name, index });
                     mode.mode = ParseStateMode::AnchorParseBase;
                     return parse_impl(mode, anchors, rules);
-                } else if ch == INDEX_OPEN {
+                } else if token == INDEX_OPEN {
                     mode.cursor += 1;
                     let index_begin = mode.cursor;
                     let mut index_end = index_begin + 1;
 
                     for _ in mode.cursor..mode.tokens.len() {
                         mode.cursor += 1;
-                        let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                        let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                             return Err(ParseError::index_parsing_eol(mode.cursor - 1, &mode.tokens).into());
                         };
-                        if ch == INDEX_CLOSE {
+                        if token == INDEX_CLOSE {
                             break;
                         }
                         index_end += 1;
@@ -414,21 +432,67 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
 
         ParseStateMode::AttributeParse => {
             mode.cursor += 1;
-            let start = mode.cursor;
-            let mut end = mode.cursor;
+            let mut start = mode.cursor;
             let mut closed = false;
 
-            for _ in mode.cursor..mode.tokens.len() {
+            let mut raw_attrs: Vec<(String, Option<String>)> = Vec::new();
+
+            while mode.cursor < mode.tokens.len() {
                 mode.cursor += 1;
-                let Some(ch) = mode.tokens.get(mode.cursor).copied() else {
+                let Some(token) = mode.tokens.get(mode.cursor).copied() else {
                     continue;
                 };
-                if ch == ATTRIBUTE_CLOSE {
+                if token == ATTRIBUTE_CLOSE {
+                    if mode.cursor - start > 1 {
+                        let attr = mode.tokens[start..mode.cursor].iter().collect::<String>();
+                        raw_attrs.push((attr, None));
+                    }
                     closed = true;
-                    end = mode.cursor;
                     break;
-                } else if !rules.in_attr_string_charset(ch) {
-                    return Err(ParseError::attribute_invalid_char(mode.cursor, &mode.tokens).into());
+                } else if token == ATTRIBUTE_DELIMETER || token == PARAM_OPEN {
+                    if mode.cursor - start <= 1 {
+                        start = mode.cursor + 1;
+                        continue;
+                    }
+                    let attr = mode.tokens[start..mode.cursor].iter().collect::<String>();
+                    let mut args = None;
+                    start = mode.cursor + 1;
+
+                    if token == PARAM_OPEN {
+                        mode.cursor += 1;
+
+                        let params_start = mode.cursor;
+                        let mut params_end = mode.cursor;
+                        let mut current_token = mode.tokens.get(mode.cursor).copied();
+                        let mut open_quote: Option<char> = None;
+
+                        while let Some(token) = current_token {
+                            if token == PARAM_CLOSE && open_quote.is_none() {
+                                start = mode.cursor;
+                                break;
+                            } else if token == ESCAPE {
+                                mode.cursor += 1
+                            } else if token == LITERAL_SINGLE_QUOTE || token == LITERAL_DOUBLE_QUOTE {
+                                if let Some(quote) = open_quote {
+                                    if token != quote {
+                                        return Err(ParseError::string_parameter_missing_closing_quote(
+                                            start,
+                                            &mode.tokens,
+                                        )
+                                        .into());
+                                    }
+                                    open_quote = None;
+                                } else {
+                                    open_quote = Some(token);
+                                }
+                            }
+                            mode.cursor += 1;
+                            params_end += 1;
+                            current_token = mode.tokens.get(mode.cursor).copied();
+                        }
+                        args = Some(mode.tokens[params_start..params_end].iter().collect::<String>());
+                    }
+                    raw_attrs.push((attr, args));
                 }
             }
             if !closed {
@@ -436,21 +500,27 @@ fn parse_impl(mode: &mut ParseState, anchors: &mut Vec<Anchor>, rules: &Rules) -
             }
             mode.cursor += 1;
 
-            if mode.tokens.get(mode.cursor).is_none_or(|ch| *ch != ATTRIBUTE_END) {
+            if mode.tokens.get(mode.cursor).is_none_or(|token| *token != ATTRIBUTE_END) {
                 return Err(ParseError::attribute_end(mode.cursor - 1, &mode.tokens).into());
             }
-            let attr_string = mode.tokens[start..end].iter().collect::<String>();
-
-            let raw_attributes = attr_string
-                .split(ATTRIBUTE_DELIMETER)
-                .map(|attr| attr.trim())
-                .collect::<Vec<&str>>();
 
-            let mut attrs = Vec::with_capacity(raw_attributes.len());
-            for raw_attr in raw_attributes {
-                let attr = Attribute::from_str(raw_attr)?;
+            let mut attrs = Vec::with_capacity(raw_attrs.len());
+            for (name, args) in raw_attrs {
+                let attr = Attribute::parse(name, args)?;
                 attrs.push(attr);
             }
+
+            // Alignment always comes first due to ANSI-escape sequences messing with string length
+            attrs.sort_by(|a, b| {
+                if let AttributeKind::Align { .. } = a.kind {
+                    Ordering::Less
+                } else if let AttributeKind::Align { .. } = b.kind {
+                    Ordering::Greater
+                } else {
+                    Ordering::Equal
+                }
+            });
+
             if let Some(anchor) = mode.bound_anchor.as_mut() {
                 anchor.attributes = attrs;
             } else {
diff --git a/src/template/parse/rules.rs b/src/template/parse/rules.rs
index 9c02ceb..e3ab6b7 100644
--- a/src/template/parse/rules.rs
+++ b/src/template/parse/rules.rs
@@ -1,4 +1,3 @@
-use super::super::token::ATTRIBUTE_DELIMETER;
 use regex::Regex;
 
 /// Defines a valid anchor name
@@ -21,10 +20,4 @@ impl Rules {
     pub fn name_is_valid(&self, name: &str) -> bool {
         self.valid_anchor_name.is_match(name)
     }
-
-    /// Determines if the attribute string i.e. `(red|bold)` in `${(red|bold):foo}`
-    /// is valid during parsing.
-    pub fn in_attr_string_charset(&self, ch: char) -> bool {
-        ch.is_ascii_alphabetic() || ch == ATTRIBUTE_DELIMETER
-    }
 }
diff --git a/src/template/parse/test.rs b/src/template/parse/test.rs
index 261bf6f..6970322 100644
--- a/src/template/parse/test.rs
+++ b/src/template/parse/test.rs
@@ -1,4 +1,7 @@
-use super::{attr::Attribute, parse, DefaultValue};
+use super::{
+    attr::{Alignment, AttributeKind},
+    parse, DefaultValue,
+};
 
 #[test]
 fn test_parse_plain() {
@@ -215,8 +218,16 @@ fn test_attribute() {
     let anchors = parse(template_string).unwrap();
     let anchor = &anchors[0];
     assert_eq!("{(red|bold):foo}", &template_string[anchor.start..anchor.end]);
-    assert!(anchor.attributes.iter().find(|a| a == &&Attribute::Red).is_some());
-    assert!(anchor.attributes.iter().find(|a| a == &&Attribute::Bold).is_some());
+    assert!(anchor
+        .attributes
+        .iter()
+        .find(|a| a.kind == AttributeKind::Red)
+        .is_some());
+    assert!(anchor
+        .attributes
+        .iter()
+        .find(|a| a.kind == AttributeKind::Bold)
+        .is_some());
 }
 
 #[test]
@@ -246,8 +257,16 @@ fn test_literal_anchor_with_attributes() {
     assert!(anchor.attributes.len() > 0);
 
     assert_eq!("{(red|bold):\"foo\"}", &template_string[anchor.start..anchor.end]);
-    assert!(anchor.attributes.iter().find(|a| a == &&Attribute::Red).is_some());
-    assert!(anchor.attributes.iter().find(|a| a == &&Attribute::Bold).is_some());
+    assert!(anchor
+        .attributes
+        .iter()
+        .find(|a| a.kind == AttributeKind::Red)
+        .is_some());
+    assert!(anchor
+        .attributes
+        .iter()
+        .find(|a| a.kind == AttributeKind::Bold)
+        .is_some());
 }
 
 #[test]
@@ -295,3 +314,111 @@ fn test_required_anchor_no_defaults() {
     let anchors = parse(template_string);
     assert!(anchors.is_ok());
 }
+
+#[test]
+fn test_attr_conditional() {
+    let template_string = "output={(?red('INFO')):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!("{(?red('INFO')):foo}", &template_string[anchor.start..anchor.end]);
+    assert_eq!(anchor.attributes.len(), 1);
+    let attr = &anchor.attributes[0];
+    assert_eq!(attr.kind, AttributeKind::Red);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("INFO"));
+}
+
+#[test]
+fn test_attr_conditional_regex() {
+    let template_string = "output={(?red('(?i)INFO')):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!("{(?red('(?i)INFO')):foo}", &template_string[anchor.start..anchor.end]);
+    assert_eq!(anchor.attributes.len(), 1);
+    let attr = &anchor.attributes[0];
+    assert_eq!(attr.kind, AttributeKind::Red);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("INFO"));
+    assert!(attr.must_match.as_ref().unwrap().is_match("info"));
+}
+
+#[test]
+fn test_attr_conditional_escape() {
+    let template_string = r"output={(?red('(?i)O\'Conner')):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!(
+        r"{(?red('(?i)O\'Conner')):foo}",
+        &template_string[anchor.start..anchor.end]
+    );
+    assert_eq!(anchor.attributes.len(), 1);
+    let attr = &anchor.attributes[0];
+    assert_eq!(attr.kind, AttributeKind::Red);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("o'conner"));
+}
+
+#[test]
+fn test_attr_conditional_multiple() {
+    let template_string = "output={(?red('ERROR')|?cyan('INFO')|bold):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!(
+        "{(?red('ERROR')|?cyan('INFO')|bold):foo}",
+        &template_string[anchor.start..anchor.end]
+    );
+    assert_eq!(anchor.attributes.len(), 3);
+
+    let attr = &anchor.attributes[0];
+    assert_eq!(attr.kind, AttributeKind::Red);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("ERROR"));
+
+    let attr = &anchor.attributes[1];
+    assert_eq!(attr.kind, AttributeKind::Cyan);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("INFO"));
+
+    let attr = &anchor.attributes[2];
+    assert_eq!(attr.kind, AttributeKind::Bold);
+    assert!(attr.must_match.is_none());
+
+    let template_string = "output={(?red('ERROR')|bold|?cyan('INFO')):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!(
+        "{(?red('ERROR')|bold|?cyan('INFO')):foo}",
+        &template_string[anchor.start..anchor.end]
+    );
+    assert_eq!(anchor.attributes.len(), 3);
+
+    let attr = &anchor.attributes[0];
+    assert_eq!(attr.kind, AttributeKind::Red);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("ERROR"));
+
+    let attr = &anchor.attributes[1];
+    assert_eq!(attr.kind, AttributeKind::Bold);
+    assert!(attr.must_match.is_none());
+
+    let attr = &anchor.attributes[2];
+    assert_eq!(attr.kind, AttributeKind::Cyan);
+    assert!(attr.must_match.is_some());
+    assert!(attr.must_match.as_ref().unwrap().is_match("INFO"));
+}
+
+#[test]
+fn test_attr_alignment() {
+    let template_string = "output={(lalign(9)):foo}";
+    let anchors = parse(template_string).unwrap();
+    let anchor = &anchors[0];
+    assert_eq!("{(lalign(9)):foo}", &template_string[anchor.start..anchor.end]);
+    assert_eq!(anchor.attributes.len(), 1);
+    let attr = &anchor.attributes[0];
+
+    let AttributeKind::Align { direction, width } = attr.kind else {
+        panic!("expected align attribute");
+    };
+    assert_eq!(width, 9);
+    assert_eq!(direction, Alignment::Left)
+}
diff --git a/src/template/test.rs b/src/template/test.rs
index d958a3e..d68ba8a 100644
--- a/src/template/test.rs
+++ b/src/template/test.rs
@@ -1,4 +1,8 @@
-use super::{Attribute, OutputTemplate};
+use super::{
+    parse::attr::{Attribute, AttributeKind},
+    OutputTemplate,
+};
+use crossterm::style::Stylize;
 use std::collections::HashMap;
 
 #[test]
@@ -81,7 +85,19 @@ fn test_output_template_attributes() {
     interpolation_map.insert("bar", vec!["bar_value_1", "bar_value_2"]);
 
     let resultant = out.transform(&interpolation_map);
-    let expected = Attribute::apply("bar_value_2", &[Attribute::Red, Attribute::Bold]);
+    let expected = Attribute::apply(
+        "bar_value_2",
+        &[
+            Attribute {
+                kind: AttributeKind::Red,
+                must_match: None,
+            },
+            Attribute {
+                kind: AttributeKind::Bold,
+                must_match: None,
+            },
+        ],
+    );
     assert_eq!(resultant, format!("{expected}"));
 }
 
@@ -101,3 +117,84 @@ fn test_output_template_required() {
         "foo doesn't have any matches so string should come back empty"
     );
 }
+
+#[test]
+fn test_output_template_required_with_attributes() {
+    let template = "log={!(red):foo} out={bar} baz";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 5);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("foo", vec![]);
+    interpolation_map.insert("bar", vec!["bar_value"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(
+        resultant, "",
+        "foo doesn't have any matches so string should come back empty"
+    );
+
+    let template = "log={!(red):foo}";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 2);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("foo", vec!["foo_value"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(
+        resultant,
+        format!("log={}", "foo_value".red()),
+        "foo doesn't have any matches so string should come back empty"
+    );
+}
+
+#[test]
+fn test_output_template_conditional_attr() {
+    let template = "severity={(?red('(?i)error')|?cyan('(?i)info')):lvl}";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 2);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("lvl", vec!["INFO"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(resultant, format!("severity={}", "INFO".cyan()));
+
+    interpolation_map.insert("lvl", vec!["ERROR"]);
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(resultant, format!("severity={}", "ERROR".red()));
+}
+
+#[test]
+fn test_output_template_alignment() {
+    let template = "{(lalign(9)):foo}";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 1);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("foo", vec!["bar"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(resultant, "bar      ");
+
+    let template = "{(lalign(9)|red):foo}";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 1);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("foo", vec!["bar"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(resultant, "bar      ".red().to_string());
+
+    let template = "{(red|lalign(9)):foo}";
+    let out = OutputTemplate::parse(template).unwrap();
+    assert_eq!(out.targets.len(), 1);
+
+    let mut interpolation_map = HashMap::new();
+    interpolation_map.insert("foo", vec!["bar"]);
+
+    let resultant = out.transform(&interpolation_map);
+    assert_eq!(resultant, "bar      ".red().to_string());
+}
diff --git a/src/template/token.rs b/src/template/token.rs
index da272fd..0f02207 100644
--- a/src/template/token.rs
+++ b/src/template/token.rs
@@ -8,6 +8,9 @@ pub const LITERAL_DOUBLE_QUOTE: char = '"';
 pub const LITERAL_SINGLE_QUOTE: char = '\'';
 pub const ATTRIBUTE_OPEN: char = '(';
 pub const ATTRIBUTE_CLOSE: char = ')';
+pub const PARAM_OPEN: char = '(';
+pub const PARAM_CLOSE: char = ')';
+pub const PARAM_DELIMETER: char = ',';
 pub const ATTRIBUTE_DELIMETER: char = '|';
 pub const ATTRIBUTE_END: char = ':';
 pub const REQUIRED: char = '!';