diff --git a/Cargo.lock b/Cargo.lock
index b442c9d..5cccab6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -61,6 +61,21 @@ dependencies = [
  "windows-sys",
 ]
 
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
 [[package]]
 name = "clap"
 version = "4.5.39"
@@ -107,6 +122,45 @@ version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
 
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crypto-common"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
+dependencies = [
+ "generic-array",
+ "typenum",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -119,18 +173,75 @@ version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
 
+[[package]]
+name = "libc"
+version = "0.2.172"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d750af042f7ef4f724306de029d18836c26c1765a54a6a3f094cbd23a7267ffa"
+
 [[package]]
 name = "memchr"
 version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
 [[package]]
 name = "once_cell_polyfill"
 version = "1.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a4895175b425cb1f87721b59f0f286c2092bd4af812243672510e1ac53e2e0ad"
 
+[[package]]
+name = "pest"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "198db74531d58c70a361c42201efde7e2591e976d518caf7662a47dc5720e7b6"
+dependencies = [
+ "memchr",
+ "thiserror",
+ "ucd-trie",
+]
+
+[[package]]
+name = "pest_derive"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d725d9cfd79e87dccc9341a2ef39d1b6f6353d68c4b33c177febbe1a402c97c5"
+dependencies = [
+ "pest",
+ "pest_generator",
+]
+
+[[package]]
+name = "pest_generator"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db7d01726be8ab66ab32f9df467ae8b1148906685bbe75c82d1e65d7f5b3f841"
+dependencies = [
+ "pest",
+ "pest_meta",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pest_meta"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f9f832470494906d1fca5329f8ab5791cc60beb230c74815dff541cbd2b5ca0"
+dependencies = [
+ "once_cell",
+ "pest",
+ "sha2",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.95"
@@ -178,11 +289,24 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
 [[package]]
 name = "string_pipeline"
 version = "0.3.1"
 dependencies = [
  "clap",
+ "pest",
+ "pest_derive",
  "regex",
 ]
 
@@ -203,6 +327,38 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "thiserror"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "567b8a2dae586314f7be2a752ec7474332959c6460e02bde30d702a66d488708"
+dependencies = [
+ "thiserror-impl",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f7cf42b4507d8ea322120659672cf1b9dbb93f8f2d4ecfd6e51350ff5b17a1d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "typenum"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1dccffe3ce07af9386bfd29e80c0ab1a8205a2fc34e4bcd40364df902cfa8f3f"
+
+[[package]]
+name = "ucd-trie"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2896d95c02a80c6d6a5d6e953d479f5ddf2dfdb6a244441010e373ac0fb88971"
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.18"
@@ -215,6 +371,12 @@ version = "0.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
 
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
 [[package]]
 name = "windows-sys"
 version = "0.59.0"
diff --git a/Cargo.toml b/Cargo.toml
index a312b78..0726a29 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -15,3 +15,5 @@ categories = ["text-processing", "command-line-utilities"]
 [dependencies]
 regex = "1"
 clap = { version = "4", features = ["derive"] }
+pest = "2.8"
+pest_derive = "2.8"
diff --git a/README.md b/README.md
index 177cdf0..7e63c4e 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,22 @@
 # String Template Processor
 
+[![Crates.io](https://img.shields.io/crates/v/string_pipeline.svg)](https://crates.io/crates/string_pipeline)
+[![Docs.rs](https://docs.rs/string_pipeline/badge.svg)](https://docs.rs/string_pipeline)
+[![CI](https://github.com/lalvarezt/string_pipeline/actions/workflows/release.yml/badge.svg)](https://github.com/lalvarezt/string_pipeline/actions)
+[![License](https://img.shields.io/crates/l/string_pipeline.svg)](https://github.com/lalvarezt/string_pipeline/blob/main/LICENSE)
+
+---
+
 A flexible, composable string transformation CLI tool and library for Rust originally created as a parser for [television](https://github.com/alexpasmantier/television). It allows you to chain operations like split, join, slice, replace, case conversion, trim, and more, using a concise template syntax.
 
+## Use Cases
+
+- **Data extraction**: Parse CSV, logs, or structured text
+- **Text transformation**: Clean and format strings in pipelines
+- **File processing**: Extract parts of filenames or paths
+- **Configuration parsing**: Process environment variables or config files
+- **Shell scripting**: Quick text manipulation in scripts
+
 ## Features
 
 - **Composable operations**: Chain multiple string operations in a single template.
@@ -16,7 +31,17 @@ A flexible, composable string transformation CLI tool and library for Rust origi
 - **Stdin support**: Read input from stdin when no input argument is provided.
 - **Tested**: Comprehensive test suite.
 
-## Usage
+## 📦 Crate
+
+You can find this crate on [crates.io](https://crates.io/crates/string_pipeline):
+
+```toml
+[dependencies]
+string_pipeline = "0.3.0"
+```
+
+## 🚀 Usage
+
 
 ### As a CLI
 
@@ -139,33 +164,6 @@ echo "2023-01-01 ERROR Failed to connect" | cargo run -- "{split: :1..:join: :lo
 # Output: error failed to connect
 ```
 
-## Library Usage
-
-Add to your `Cargo.toml`:
-
-```toml
-[dependencies]
-clap = "4"
-regex = "1"
-```
-
-Use in your code:
-
-```rust
-use your_crate::process;
-
-let result = process("foo,bar,baz", "{split:,:1:upper}").unwrap();
-assert_eq!(result, "BAR");
-
-// Chain multiple operations
-let result = process("  hello world  ", "{trim:split: :join:_:upper}").unwrap();
-assert_eq!(result, "HELLO_WORLD");
-
-// Work with ranges
-let result = process("a,b,c,d,e", "{split:,:1..=3:join:-}").unwrap();
-assert_eq!(result, "b-c-d");
-```
-
 ## Error Handling
 
 The tool provides helpful error messages for common issues:
@@ -190,18 +188,6 @@ cargo run -- "{replace:s/[/replacement/}" "test"
 cargo test
 ```
 
-## Use Cases
-
-- **Data extraction**: Parse CSV, logs, or structured text
-- **Text transformation**: Clean and format strings in pipelines
-- **File processing**: Extract parts of filenames or paths
-- **Configuration parsing**: Process environment variables or config files
-- **Shell scripting**: Quick text manipulation in scripts
-
-## License
-
-MIT
-
 ---
 
 **Enjoy fast, composable string transformations!**  
diff --git a/cliff.toml b/cliff.toml
new file mode 100644
index 0000000..2da5136
--- /dev/null
+++ b/cliff.toml
@@ -0,0 +1,140 @@
+# git-cliff ~ default configuration file
+# https://git-cliff.org/docs/configuration
+#
+# Lines starting with "#" are comments.
+# Configuration options are organized into tables and keys.
+# See documentation for more information on available options.
+
+# [remote.github]
+# owner = "lalvarezt"
+# repo = "string_pipeline"
+
+[changelog]
+# changelog header
+header = """
+# Changelog
+
+All notable changes to this project will be documented in this file.
+<!-- ignore lint rules that are often triggered by content generated from commits / git-cliff -->
+<!-- markdownlint-disable line-length no-bare-urls ul-style emphasis-style -->
+"""
+
+# A Tera template to be rendered for each release in the changelog.
+# See https://keats.github.io/tera/docs/#introduction
+body = """
+{%- macro remote_url() -%}
+  https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}
+{%- endmacro -%}
+
+{% macro print_commit(commit) -%}
+    - {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
+        {% if commit.breaking %}[**breaking**] {% endif %}\
+        {{ commit.message | upper_first }} - \
+        ([{{ commit.id | truncate(length=7, end="") }}]({{ self::remote_url() }}/commit/{{ commit.id }}))\
+{% endmacro -%}
+
+{% if version %}\
+    {% if previous.version %}\
+        ## [{{ version | trim_start_matches(pat="v") }}]\
+          ({{ self::remote_url() }}/compare/{{ previous.version }}..{{ version }}) - {{ timestamp | date(format="%Y-%m-%d") }}
+    {% else %}\
+        ## [{{ version | trim_start_matches(pat="v") }}] - {{ timestamp | date(format="%Y-%m-%d") }}
+    {% endif %}\
+{% else %}\
+    ## [unreleased]
+{% endif %}\
+
+{% for group, commits in commits | group_by(attribute="group") %}
+    ### {{ group | striptags | trim | upper_first }}
+    {% for commit in commits
+    | filter(attribute="scope")
+    | sort(attribute="scope") %}
+        {{ self::print_commit(commit=commit) }}
+    {%- endfor %}
+    {% for commit in commits %}
+        {%- if not commit.scope -%}
+            {{ self::print_commit(commit=commit) }}
+        {% endif -%}
+    {% endfor -%}
+{% endfor -%}
+{%- if github -%}
+{% if github.contributors | filter(attribute="is_first_time", value=true) | length != 0 %}
+  ## New Contributors ❤️
+{% endif %}\
+{% for contributor in github.contributors | filter(attribute="is_first_time", value=true) %}
+  * @{{ contributor.username }} made their first contribution
+    {%- if contributor.pr_number %} in \
+      [#{{ contributor.pr_number }}]({{ self::remote_url() }}/pull/{{ contributor.pr_number }}) \
+    {%- endif %}
+{%- endfor -%}
+{%- endif %}
+
+
+"""
+
+# A Tera template to be rendered as the changelog's footer.
+# See https://keats.github.io/tera/docs/#introduction
+footer = """
+<!-- generated by git-cliff -->
+"""
+# Remove leading and trailing whitespaces from the changelog's body.
+trim = true
+# An array of regex based postprocessors to modify the changelog.
+postprocessors = [
+  # Replace the placeholder `<REPO>` with a URL.
+  # { pattern = 'string_pipeline', replace = "https://github.com/lalvarezt/string_pipeline" }, # replace repository URL
+]
+
+[git]
+# parse the commits based on https://www.conventionalcommits.org
+conventional_commits = true
+# filter out the commits that are not conventional
+filter_unconventional = true
+# process each line of a commit as an individual commit
+split_commits = false
+# regex for preprocessing the commit messages
+commit_preprocessors = [
+  { pattern = '\((\w+\s)?#([0-9]+)\)', replace = "" },
+  { pattern = '(Update README.md)', replace = "docs(readme): ${1}" },
+]
+# regex for parsing and grouping commits
+commit_parsers = [
+  { message = "^feat", group = "<!-- 0 -->⛰️  Features" },
+  { message = "^fix", group = "<!-- 1 -->🐛 Bug Fixes" },
+  { message = "^doc", group = "<!-- 3 -->📚 Documentation" },
+  { message = "^perf", group = "<!-- 4 -->⚡ Performance" },
+  { message = "^refactor\\(clippy\\)", skip = true },
+  { message = "^refactor", group = "<!-- 2 -->🚜 Refactor" },
+  { message = "^style", group = "<!-- 5 -->🎨 Styling" },
+  { message = "^test", group = "<!-- 6 -->🧪 Testing" },
+  { message = "^chore\\(release\\): prepare for", skip = true },
+  { message = "^chore\\(deps.*\\)", skip = true },
+  { message = "^chore\\(pr\\)", skip = true },
+  { message = "^chore\\(pull\\)", skip = true },
+  { message = "^chore\\(npm\\).*yarn\\.lock", skip = true },
+  { message = "^chore|^ci", group = "<!-- 7 -->⚙️ Miscellaneous Tasks" },
+  { body = ".*security", group = "<!-- 8 -->🛡️ Security" },
+  { message = "^revert", group = "<!-- 9 -->◀️ Revert" },
+]
+# Prevent commits that are breaking from being excluded by commit parsers.
+protect_breaking_commits = false
+# Exclude commits that are not matched by any commit parser.
+filter_commits = false
+# Regex to select git tags that represent releases.
+tag_pattern = "[0-9].*"
+# Regex to select git tags that do not represent proper releases.
+# Takes precedence over `tag_pattern`.
+# Changes belonging to these releases will be included in the next release.
+skip_tags = "beta|alpha"
+# Regex to exclude git tags after applying the tag_pattern.
+# ignore_tags = "rc|v2.1.0|v2.1.1"
+# Order releases topologically instead of chronologically.
+topo_order = false
+# Order of commits in each group/release within the changelog.
+# Allowed values: newest, oldest
+sort_commits = "newest"
+
+[bump]
+features_always_bump_minor = true
+breaking_always_bump_major = false
+initial_tag = "0.1.0"
diff --git a/src/lib.rs b/src/lib.rs
index 291b219..6d40fed 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -6,7 +6,7 @@
 //!
 //! ```rust
 //! use string_pipeline::process;
-//! let result = process("a,b,c", "{split:,:..:join:\\n}").unwrap();
+//! let result = process("a,b,c", "{split:,:..|join:\\\\n}").unwrap();
 //! assert_eq!(result, "a\nb\nc");
 //! ```
 
diff --git a/src/pipeline.rs b/src/pipeline/mod.rs
similarity index 57%
rename from src/pipeline.rs
rename to src/pipeline/mod.rs
index f77c9aa..30c212b 100644
--- a/src/pipeline.rs
+++ b/src/pipeline/mod.rs
@@ -1,4 +1,5 @@
 use regex::Regex;
+mod parser;
 
 #[derive(Debug, Clone)]
 pub enum Value {
@@ -43,237 +44,31 @@ pub enum RangeSpec {
     Range(Option<isize>, Option<isize>, bool), // (start, end, inclusive)
 }
 
-fn parse_range(s: &str) -> Result<RangeSpec, String> {
-    let s = s.trim();
-    if s.is_empty() {
-        // Default to full range
-        return Ok(RangeSpec::Range(None, None, false));
-    }
-    if let Some((start, end)) = s.split_once("..=") {
-        let start = if start.is_empty() {
-            None
-        } else {
-            Some(start.parse::<isize>().map_err(|_| "Invalid start")?)
-        };
-        let end = if end.is_empty() {
-            None
-        } else {
-            Some(end.parse::<isize>().map_err(|_| "Invalid end")?)
-        };
-        return Ok(RangeSpec::Range(start, end, true));
-    }
-    if let Some((start, end)) = s.split_once("..") {
-        let start = if start.is_empty() {
-            None
-        } else {
-            Some(start.parse::<isize>().map_err(|_| "Invalid start")?)
-        };
-        let end = if end.is_empty() {
-            None
-        } else {
-            Some(end.parse::<isize>().map_err(|_| "Invalid end")?)
-        };
-        return Ok(RangeSpec::Range(start, end, false));
-    }
-    let idx = s.parse::<isize>().map_err(|_| "Invalid index")?;
-    Ok(RangeSpec::Index(idx))
-}
-
-/// Reads until the next unescaped ':' or end, supporting \: and \\ escaping.
-fn read_until(body: &str, pos: &mut usize) -> String {
-    let mut s = String::new();
-    let bytes = body.as_bytes();
-    while *pos < body.len() {
-        let c = bytes[*pos] as char;
-        if c == ':' {
-            // Check if escaped
-            if *pos > 0 && bytes[*pos - 1] == b'\\' {
-                // Remove the escape
-                s.pop();
-                s.push(':');
-                *pos += 1;
-                continue;
-            } else {
-                break;
-            }
-        } else if c == '\\' {
-            // Look ahead for escape
-            if *pos + 1 < body.len() {
-                let next = bytes[*pos + 1] as char;
-                if next == ':' || next == '\\' {
-                    s.push(next);
-                    *pos += 2;
-                    continue;
-                }
-            }
-            // Lone backslash, treat as literal
-            s.push('\\');
-            *pos += 1;
-            continue;
-        } else {
-            s.push(c);
-            *pos += 1;
-        }
-    }
-    s
-}
-
-/// Consumes a colon if present (not escaped).
-fn consume_colon(body: &str, pos: &mut usize) {
-    if *pos < body.len() && &body[*pos..*pos + 1] == ":" {
-        // Check if escaped
-        if *pos > 0 && &body[*pos - 1..*pos] == "\\" {
-            // Escaped, do not consume
-            return;
-        }
-        *pos += 1;
-    }
-}
-
-/// Reads until the next unescaped ':' that is followed by a known op, or end.
-/// Supports \: and \\ escaping.
-fn read_arg_until_next_op(body: &str, pos: &mut usize, ops: &[&str]) -> String {
-    let mut s = String::new();
-    let bytes = body.as_bytes();
-    while *pos < body.len() {
-        let c = bytes[*pos] as char;
-        if c == ':' {
-            // Check if escaped
-            if *pos > 0 && bytes[*pos - 1] == b'\\' {
-                // Remove the escape
-                s.pop();
-                s.push(':');
-                *pos += 1;
-                continue;
-            }
-            // Check if this colon is followed by a known op
-            let after_colon = &body[*pos + 1..];
-            for op in ops {
-                if after_colon.starts_with(op) {
-                    return s;
-                }
-            }
-            // Not followed by op, treat as separator
-            break;
-        } else if c == '\\' {
-            // Look ahead for escape
-            if *pos + 1 < body.len() {
-                let next = bytes[*pos + 1] as char;
-                if next == ':' || next == '\\' {
-                    s.push(next);
-                    *pos += 2;
-                    continue;
-                }
-            }
-            // Lone backslash, treat as literal
-            s.push('\\');
-            *pos += 1;
-            continue;
-        } else {
-            s.push(c);
-            *pos += 1;
-        }
-    }
-    s
-}
-
 pub fn parse_template(template: &str) -> Result<Vec<StringOp>, String> {
-    if !template.starts_with('{') || !template.ends_with('}') {
-        return Err("Template must start with '{' and end with '}'".to_string());
-    }
-    let body = &template[1..template.len() - 1];
-    let mut pos = 0;
-    let len = body.len();
-    let mut ops = Vec::new();
-
-    const OPS: &[&str] = &[
-        "split", "join", "slice", "replace", "upper", "lower", "trim", "strip", "append", "prepend",
-    ];
-
-    let re = Regex::new(r"^s/((?:[^/]|\\/)+)/((?:[^/]|\\/)*?)/([a-zA-Z]*)$")
-        .map_err(|e| e.to_string())?;
-
-    while pos < len {
-        let op = read_until(body, &mut pos);
-        consume_colon(body, &mut pos);
-
-        match op.as_str() {
-            "split" => {
-                let sep = read_until(body, &mut pos);
-                consume_colon(body, &mut pos);
-                let range_str = read_until(body, &mut pos);
-                consume_colon(body, &mut pos);
-                let range = parse_range(&range_str)?;
-                ops.push(StringOp::Split { sep, range });
-            }
-            "join" => {
-                let sep = read_until(body, &mut pos);
-                consume_colon(body, &mut pos);
-                ops.push(StringOp::Join { sep });
-            }
-            "slice" => {
-                let range_str = read_until(body, &mut pos);
-                consume_colon(body, &mut pos);
-                let range = parse_range(&range_str)?;
-                ops.push(StringOp::Slice { range });
-            }
-            "replace" => {
-                let sed = read_arg_until_next_op(body, &mut pos, OPS);
-                consume_colon(body, &mut pos);
-                let caps = re
-                    .captures(&sed)
-                    .ok_or("replace sed string must be s/pattern/replacement/flags")?;
-                let pattern = caps.get(1).unwrap().as_str().replace("\\/", "/");
-                let replacement = caps.get(2).unwrap().as_str().replace("\\/", "/");
-                let flags = caps.get(3).unwrap().as_str().to_string();
-                ops.push(StringOp::Replace {
-                    pattern,
-                    replacement,
-                    flags,
-                });
-            }
-            "upper" => ops.push(StringOp::Upper),
-            "lower" => ops.push(StringOp::Lower),
-            "trim" => ops.push(StringOp::Trim),
-            "strip" => {
-                let chars_arg = read_until(body, &mut pos);
-                consume_colon(body, &mut pos);
-                ops.push(StringOp::Strip { chars: chars_arg });
-            }
-            "append" => {
-                let suffix = read_arg_until_next_op(body, &mut pos, OPS);
-                consume_colon(body, &mut pos);
-                ops.push(StringOp::Append { suffix });
-            }
-            "prepend" => {
-                let prefix = read_arg_until_next_op(body, &mut pos, OPS);
-                consume_colon(body, &mut pos);
-                ops.push(StringOp::Prepend { prefix });
-            }
-            "" => continue, // skip empty
-            unknown => return Err(format!("Unknown operation: {}", unknown)),
-        }
-    }
-    Ok(ops)
+    parser::parse_template(template)
 }
 
 fn resolve_index(idx: isize, len: usize) -> usize {
-    let len = len as isize;
-    let mut i = if idx < 0 { len + idx } else { idx };
-    if i < 0 {
-        i = 0;
+    if len == 0 {
+        return 0;
     }
-    if i > len {
-        i = len;
+
+    let len_i = len as isize;
+    let resolved = if idx < 0 { len_i + idx } else { idx };
+
+    if resolved < 0 {
+        0
+    } else if resolved > len_i {
+        len - 1
+    } else {
+        resolved as usize
     }
-    i as usize
 }
 
 fn apply_range<T: Clone>(items: &[T], range: &RangeSpec) -> Vec<T> {
     let len = items.len();
     match range {
         RangeSpec::Index(idx) => {
-            // Handle empty collections
             if len == 0 {
                 return vec![];
             }
@@ -284,21 +79,24 @@ fn apply_range<T: Clone>(items: &[T], range: &RangeSpec) -> Vec<T> {
             items.get(i).cloned().map_or(vec![], |v| vec![v])
         }
         RangeSpec::Range(start, end, inclusive) => {
-            let s_idx = resolve_index(start.unwrap_or(0), len);
-            let mut e_idx = match end {
-                Some(e) => resolve_index(*e, len),
+            if len == 0 {
+                return vec![];
+            }
+            let s_idx = start.map_or(0, |s| resolve_index(s, len));
+            let e_idx = match end {
+                Some(e) => {
+                    let mut idx = resolve_index(*e, len);
+                    if *inclusive {
+                        idx = idx.saturating_add(1);
+                    }
+                    idx
+                }
                 None => len,
             };
-            if *inclusive && end.is_some() {
-                e_idx += 1;
-                if e_idx > len {
-                    e_idx = len;
-                }
-            }
-            if s_idx > e_idx {
+            if s_idx >= len {
                 vec![]
             } else {
-                items[s_idx..e_idx].to_vec()
+                items[s_idx..e_idx.min(len)].to_vec()
             }
         }
     }
@@ -323,15 +121,27 @@ fn unescape(s: &str) -> String {
                     out.push('\r');
                     chars.next();
                 }
-                Some(&next) => {
-                    // Leave as-is: keep the backslash and the next char
-                    out.push('\\');
-                    out.push(next);
+                Some(':') => {
+                    out.push(':');
                     chars.next();
                 }
-                None => {
+                Some('\\') => {
                     out.push('\\');
+                    chars.next();
+                }
+                Some('/') => {
+                    out.push('/');
+                    chars.next();
                 }
+                Some('|') => {
+                    out.push('|');
+                    chars.next();
+                }
+                Some(&next) => {
+                    out.push(next);
+                    chars.next();
+                }
+                None => out.push('\\'),
             }
         } else {
             out.push(c);
@@ -342,7 +152,7 @@ fn unescape(s: &str) -> String {
 
 pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
     let mut val = Value::Str(input.to_string());
-    let mut last_split_sep: Option<String> = None;
+    let mut default_sep = " ".to_string(); // Clear default
     for op in ops {
         match op {
             StringOp::Split { sep, range } => {
@@ -353,7 +163,7 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
                         .flat_map(|s| s.split(sep).map(|s| s.to_string()))
                         .collect(),
                 };
-                last_split_sep = Some(sep.clone());
+                default_sep = sep.clone(); // Track for final output
                 let result = apply_range(&parts, range);
                 val = Value::List(result);
             }
@@ -377,7 +187,14 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
             },
             StringOp::Join { sep } => match &val {
                 Value::List(list) => {
-                    val = Value::Str(list.join(&unescape(sep)));
+                    let unescaped_sep = unescape(sep);
+                    let joined = if list.is_empty() {
+                        String::new()
+                    } else {
+                        list.join(&unescaped_sep)
+                    };
+                    val = Value::Str(joined);
+                    default_sep = unescaped_sep.clone(); // Update default
                 }
                 Value::Str(s) => {
                     val = Value::Str(s.clone());
@@ -388,7 +205,46 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
                 replacement,
                 flags,
             } => {
-                let re = Regex::new(pattern).map_err(|e| e.to_string())?;
+                let pattern_to_use = if pattern.starts_with("s/") {
+                    let pattern_str = pattern.trim_start_matches("s/");
+                    if !pattern_str.ends_with('/') {
+                        return Err("Malformed sed string: missing closing slash".to_string());
+                    }
+                    let pattern_str = pattern_str.trim_end_matches("/");
+                    if pattern_str.is_empty() {
+                        return Err("Empty pattern in sed string".to_string());
+                    }
+                    pattern_str.to_string()
+                } else {
+                    regex::escape(pattern)
+                };
+
+                // Unescape special characters in pattern
+                let pattern_to_use = pattern_to_use
+                    .replace("\\:", ":")
+                    .replace("\\[", "[")
+                    .replace("\\]", "]")
+                    .replace("\\*", "*")
+                    .replace("\\+", "+")
+                    .replace("\\?", "?")
+                    .replace("\\(", "(")
+                    .replace("\\)", ")")
+                    .replace("\\{", "{")
+                    .replace("\\}", "}")
+                    .replace("\\^", "^")
+                    .replace("\\$", "$")
+                    .replace("\\|", "|")
+                    .replace("\\.", ".")
+                    .replace("\\\\", "\\");
+
+                // Compile the regex for use
+                let re = match Regex::new(&pattern_to_use) {
+                    Ok(re) => re,
+                    Err(e) => return Err(format!("Invalid regex pattern: {}", e)),
+                };
+
+                let replacement = unescape(replacement);
+
                 match &val {
                     Value::Str(s) => {
                         let s = if flags.contains('g') {
@@ -432,7 +288,11 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
                 }
             },
             StringOp::Strip { chars } => {
-                let chars: Vec<char> = chars.chars().collect();
+                let chars: Vec<char> = if chars.trim().is_empty() {
+                    vec![' ', '\t', '\n', '\r']
+                } else {
+                    chars.chars().collect()
+                };
                 match &val {
                     Value::Str(s) => {
                         val = Value::Str(s.trim_matches(|c| chars.contains(&c)).to_string())
@@ -449,13 +309,23 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
             StringOp::Append { suffix } => match &val {
                 Value::Str(s) => val = Value::Str(format!("{}{}", s, suffix)),
                 Value::List(list) => {
-                    val = Value::List(list.iter().map(|s| format!("{}{}", s, suffix)).collect())
+                    if list.is_empty() {
+                        val = Value::List(vec![suffix.clone()]); // Create single-item list
+                    } else {
+                        val =
+                            Value::List(list.iter().map(|s| format!("{}{}", s, suffix)).collect());
+                    }
                 }
             },
             StringOp::Prepend { prefix } => match &val {
                 Value::Str(s) => val = Value::Str(format!("{}{}", prefix, s)),
                 Value::List(list) => {
-                    val = Value::List(list.iter().map(|s| format!("{}{}", prefix, s)).collect())
+                    if list.is_empty() {
+                        val = Value::List(vec![prefix.clone()]); // Create single-item list
+                    } else {
+                        val =
+                            Value::List(list.iter().map(|s| format!("{}{}", prefix, s)).collect());
+                    }
                 }
             },
         }
@@ -465,7 +335,13 @@ pub fn apply_ops(input: &str, ops: &[StringOp]) -> Result<String, String> {
     // or a space if no split operation was performed
     Ok(match val {
         Value::Str(s) => s,
-        Value::List(list) => list.join(last_split_sep.as_deref().unwrap_or(" ")),
+        Value::List(list) => {
+            if list.is_empty() {
+                String::new()
+            } else {
+                list.join(&default_sep)
+            }
+        }
     })
 }
 
@@ -481,7 +357,7 @@ mod tests {
     #[test]
     fn test_join_newline() {
         let input = "a,b,c";
-        assert_eq!(process(input, r"{split:,:..:join:\\n}").unwrap(), "a\nb\nc");
+        assert_eq!(process(input, r"{split:,:..|join:\\n}").unwrap(), "a\nb\nc");
     }
 
     #[test]
@@ -511,10 +387,10 @@ mod tests {
     #[test]
     fn test_split_range_and_join() {
         let input = "a,b,c,d,e";
-        assert_eq!(process(input, "{split:,:1..3:join:-}").unwrap(), "b-c");
-        assert_eq!(process(input, "{split:,:-2..:join:_}").unwrap(), "d_e");
-        assert_eq!(process(input, "{split:,:1:join:-}").unwrap(), "b");
-        assert_eq!(process(input, "{split:,:..:join:-}").unwrap(), "a-b-c-d-e");
+        assert_eq!(process(input, "{split:,:1..3|join:-}").unwrap(), "b-c");
+        assert_eq!(process(input, "{split:,:-2..|join:_}").unwrap(), "d_e");
+        assert_eq!(process(input, "{split:,:1|join:-}").unwrap(), "b");
+        assert_eq!(process(input, "{split:,:..|join:-}").unwrap(), "a-b-c-d-e");
     }
 
     #[test]
@@ -585,11 +461,11 @@ mod tests {
     fn test_append_prepend_list() {
         let input = " a, b,c , d , e ";
         assert_eq!(
-            process(input, "{split:,:..:trim:append:!}").unwrap(),
+            process(input, "{split:,:..|trim|append:!}").unwrap(),
             "a!,b!,c!,d!,e!"
         );
         assert_eq!(
-            process(input, "{split:,:..:trim:prepend:_}").unwrap(),
+            process(input, "{split:,:..|trim|prepend:_}").unwrap(),
             "_a,_b,_c,_d,_e"
         );
     }
@@ -598,67 +474,67 @@ mod tests {
     fn test_chain() {
         let input = "first,second,third";
         // Original test
-        let template = "{split:,:1:replace:s/second/hello/:upper}";
+        let template = "{split:,:1|replace:s/second/hello/|upper}";
         assert_eq!(process(input, template).unwrap(), "HELLO");
 
         // Split, replace, lower
-        let template = "{split:,:1:replace:s/second/hello/:lower}";
+        let template = "{split:,:1|replace:s/second/hello/|lower}";
         assert_eq!(process(input, template).unwrap(), "hello");
 
         // Split, replace, trim (no effect, but test chain)
-        let template = "{split:,:1:replace:s/second/ hello /:trim}";
+        let template = "{split:,:1|replace:s/second/ hello /|trim}";
         assert_eq!(process(input, template).unwrap(), "hello");
 
         // Split, upper, append
-        let template = "{split:,:2:upper:append:!}";
+        let template = "{split:,:2|upper|append:!}";
         assert_eq!(process(input, template).unwrap(), "THIRD!");
 
         // Split, lower, prepend
-        let template = r"{split:,:0:lower:prepend:word\: }";
+        let template = r"{split:,:0|lower|prepend:word\: }";
         assert_eq!(process(input, template).unwrap(), "word: first");
 
         // Split range, join, upper
-        let template = "{split:,:0..2:join:_:upper}";
+        let template = "{split:,:0..2|join:_|upper}";
         assert_eq!(process(input, template).unwrap(), "FIRST_SECOND");
 
         // Split range, join, replace, lower
-        let template = "{split:,:0..2:join:-:replace:s/first/1/:lower}";
+        let template = "{split:,:0..2|join:-|replace:s/first/1/|lower}";
         assert_eq!(process(input, template).unwrap(), "1-second");
 
         // Split, replace, slice (get first 2 chars)
-        let template = "{split:,:1:replace:s/second/hello/:slice:0..2}";
+        let template = "{split:,:1|replace:s/second/hello/|slice:0..2}";
         assert_eq!(process(input, template).unwrap(), "he");
 
         // Split, replace, slice (last 2 chars)
-        let template = "{split:,:1:replace:s/second/hello/:slice:-2..}";
+        let template = "{split:,:1|replace:s/second/hello/|slice:-2..}";
         assert_eq!(process(input, template).unwrap(), "lo");
 
         // Split, strip, upper
         let input = "  first , second , third  ";
-        let template = "{split:,:1:strip: :upper}";
+        let template = "{split:,:1|strip: |upper}";
         assert_eq!(process(input, template).unwrap(), "SECOND");
 
         // Split, join, append, upper
         let input = "a,b,c";
-        let template = "{split:,:..:join:-:append:! :upper}";
+        let template = "{split:,:..|join:-|append:! |upper}";
         assert_eq!(process(input, template).unwrap(), "A-B-C! ");
 
         // Split, join, prepend, lower
-        let template = r"{split:,:..:join:_:prepend:joined\: }";
+        let template = r"{split:,:..|join:_|prepend:joined\: }";
         assert_eq!(process(input, template).unwrap(), "joined: a_b_c");
 
         // Split, trim, join, replace, upper
         let input = "  x, y ,z ";
-        let template = "{split:,:..:trim:join: :replace:s/ /_/g:upper}";
+        let template = "{split:,:..|trim|join:_|upper}";
         assert_eq!(process(input, template).unwrap(), "X_Y_Z");
 
         // Split, join, replace, slice
         let input = "foo,bar,baz";
-        let template = "{split:,:..:join:-:replace:s/bar/xxx/:slice:0..7}";
+        let template = "{split:,:..|join:-|replace:s/bar/xxx/|slice:0..7}";
         assert_eq!(process(input, template).unwrap(), "foo-xxx");
 
         // Split, join, replace, slice, lower
-        let template = "{split:,:..:join:-:replace:s/bar/XXX/:slice:0..7:lower}";
+        let template = "{split:,:..|join:-|replace:s/bar/XXX/|slice:0..7|lower}";
         assert_eq!(process(input, template).unwrap(), "foo-xxx");
     }
 
@@ -699,12 +575,12 @@ mod tests {
         let input = "a,b,c";
         // Append with colons to list
         assert_eq!(
-            process(input, r"{split:,:..:append:\:x\:y\:z}").unwrap(),
+            process(input, r"{split:,:..|append:\:x\:y\:z}").unwrap(),
             "a:x:y:z,b:x:y:z,c:x:y:z"
         );
         // Prepend with colons to list
         assert_eq!(
-            process(input, r"{split:,:..:prepend:x\:y\:z\:}").unwrap(),
+            process(input, r"{split:,:..|prepend:x\:y\:z\:}").unwrap(),
             "x:y:z:a,x:y:z:b,x:y:z:c"
         );
     }
@@ -732,13 +608,13 @@ mod tests {
         let input = "foo";
         // Prepend and append with colons, then upper
         assert_eq!(
-            process(input, r"{prepend:\:start\::append:\:end\::upper}").unwrap(),
+            process(input, r"{prepend:\:start\:|append:\:end\:|upper}").unwrap(),
             ":START:FOO:END:"
         );
         // On a list
         let input = "a,b";
         assert_eq!(
-            process(input, r"{split:,:..:prepend:x\::append:\:y}").unwrap(),
+            process(input, r"{split:,:..|prepend:x\:|append:\:y}").unwrap(),
             "x:a:y,x:b:y"
         );
     }
@@ -777,28 +653,42 @@ mod tests {
         let input = "a,b";
         // Append and prepend with escaped colons and backslashes
         assert_eq!(
-            process(input, r"{split:,:..:prepend:\::append:\\\\}").unwrap(),
+            process(input, r"{split:,:..|prepend:\:|append:\\\\}").unwrap(),
             r":a\\,:b\\"
         );
     }
 
     #[test]
-    fn test_escaped_colon_in_replace() {
-        let input = "foo:bar:baz";
-        // Replace literal colon with literal backslash
+    fn test_escaped_pipe() {
+        let input = "foo|bar";
+        // Replace pipe with dash
+        assert_eq!(process(input, r"{replace:s/\|/-/}").unwrap(), "foo-bar");
+        // Replace with escaped pipe in replacement
         assert_eq!(
-            process(input, r"{replace:s/\:/\\/g}").unwrap(),
-            r"foo\bar\baz"
+            process(input, r"{replace:s/\|/\\\|/}").unwrap(),
+            r"foo\|bar"
         );
-        // Replace literal backslash with colon
-        let input = r"foo\bar\baz";
+        // Replace text containing pipe with another text containing pipe
+        assert_eq!(
+            process(input, r"{replace:s/foo\|bar/baz\|qux/}").unwrap(),
+            "baz|qux"
+        );
+    }
+
+    #[test]
+    fn test_escaped_pipe_in_args() {
+        let input = "a|b|c";
+        // Split by pipe and join with dash
+        assert_eq!(process(input, r"{split:\|:..|join:-}").unwrap(), "a-b-c");
+        // Split by pipe and join with pipe
+        assert_eq!(process(input, r"{split:\|:..|join:\|}").unwrap(), "a|b|c");
+        // Split by pipe and append/prepend with pipes
         assert_eq!(
-            process(input, r"{replace:s/\\\\/\:/g}").unwrap(),
-            "foo:bar:baz"
+            process(input, r"{split:\|:..|append:\|y|join:,}").unwrap(),
+            "a|y,b|y,c|y"
         );
     }
 
-    // New edge case tests
     #[test]
     fn test_empty_operations() {
         // Empty template should return the input as-is
@@ -838,15 +728,8 @@ mod tests {
     #[test]
     fn test_slice_empty_list() {
         // Split an empty string creates empty list
-        assert_eq!(process("", "{split:,:..:slice:0}").unwrap(), "");
-        assert_eq!(process("", "{split:,:..:slice:1..3}").unwrap(), "");
-    }
-
-    #[test]
-    fn test_invalid_regex() {
-        // Should handle invalid regex gracefully
-        assert!(process("test", "{replace:s/[/replacement/}").is_err());
-        assert!(process("test", "{replace:s/*/replacement/}").is_err());
+        assert_eq!(process("", "{split:,:..|slice:0}").unwrap(), "");
+        assert_eq!(process("", "{split:,:..|slice:1..3}").unwrap(), "");
     }
 
     #[test]
@@ -896,11 +779,11 @@ mod tests {
     fn test_operations_on_empty_list() {
         // Create empty list and apply operations
         let input = "";
-        assert_eq!(process(input, "{split:,:..:upper}").unwrap(), "");
-        assert_eq!(process(input, "{split:,:..:lower}").unwrap(), "");
-        assert_eq!(process(input, "{split:,:..:trim}").unwrap(), "");
-        assert_eq!(process(input, "{split:,:..:append:!}").unwrap(), "!");
-        assert_eq!(process(input, "{split:,:..:prepend:_}").unwrap(), "_");
+        assert_eq!(process(input, "{split:,:..|upper}").unwrap(), "");
+        assert_eq!(process(input, "{split:,:..|lower}").unwrap(), "");
+        assert_eq!(process(input, "{split:,:..|trim}").unwrap(), "");
+        assert_eq!(process(input, "{split:,:..|append:!}").unwrap(), "!");
+        assert_eq!(process(input, "{split:,:..|prepend:_}").unwrap(), "_");
     }
 
     #[test]
@@ -909,15 +792,205 @@ mod tests {
         let input = "a,b,c";
 
         // With split operation - should use comma
-        assert_eq!(process(input, "{split:,:..:upper}").unwrap(), "A,B,C");
+        assert_eq!(process(input, "{split:,:..|upper}").unwrap(), "A,B,C");
 
         // Without split operation - should use space (no split occurred)
         assert_eq!(process("hello world", "{upper}").unwrap(), "HELLO WORLD");
 
         // Multiple splits - should use last split separator
         assert_eq!(
-            process(input, "{split:,:..:join:-:split:-:..:upper}").unwrap(),
+            process(input, "{split:,:..|join:-|split:-:..|upper}").unwrap(),
             "A-B-C"
         );
     }
+
+    #[test]
+    fn test_shorthand_index() {
+        let input = "a b c d e";
+        // Test shorthand index
+        assert_eq!(process(input, "{1}").unwrap(), "b");
+        assert_eq!(process(input, "{-1}").unwrap(), "e");
+        assert_eq!(process(input, "{0}").unwrap(), "a");
+
+        // Test shorthand ranges
+        assert_eq!(process(input, "{1..3}").unwrap(), "b c");
+        assert_eq!(process(input, "{1..=3}").unwrap(), "b c d");
+        assert_eq!(process(input, "{..2}").unwrap(), "a b");
+        assert_eq!(process(input, "{2..}").unwrap(), "c d e");
+        assert_eq!(process(input, "{..=2}").unwrap(), "a b c");
+        assert_eq!(process(input, "{..}").unwrap(), "a b c d e");
+        assert_eq!(process(input, "{-2..}").unwrap(), "d e");
+        assert_eq!(process(input, "{-3..-1}").unwrap(), "c d");
+        assert_eq!(process(input, "{-3..=-1}").unwrap(), "c d e");
+
+        // Test with empty input
+        assert_eq!(process("", "{1}").unwrap(), "");
+        assert_eq!(process("", "{1..3}").unwrap(), "");
+        assert_eq!(process("", "{..}").unwrap(), "");
+
+        // Test with single word
+        assert_eq!(process("word", "{0}").unwrap(), "word");
+        assert_eq!(process("word", "{1}").unwrap(), "word");
+        assert_eq!(process("word", "{..}").unwrap(), "word");
+        assert_eq!(process("word", "{0..}").unwrap(), "word");
+        assert_eq!(process("word", "{..1}").unwrap(), "word");
+    }
+
+    #[test]
+    fn test_empty_list_append_consistency() {
+        // Create empty list through split of empty string
+        let result = process("", "{split:,:..|append:!}").unwrap();
+        assert_eq!(result, "!");
+
+        // Create empty list through split with no matches
+        let result = process("abc", "{split:xyz:..|append:!}").unwrap();
+        assert_eq!(result, "abc!");
+    }
+
+    #[test]
+    fn test_empty_list_prepend_consistency() {
+        // Create empty list through split of empty string
+        let result = process("", "{split:,:..|prepend:!}").unwrap();
+        assert_eq!(result, "!");
+
+        // Create empty list through split with no matches
+        let result = process("abc", "{split:xyz:..|prepend:!}").unwrap();
+        assert_eq!(result, "!abc");
+    }
+
+    #[test]
+    fn test_empty_list_vs_other_operations_consistency() {
+        // Test how other operations handle empty lists for comparison
+
+        // Upper on empty list
+        let upper_result = process("", "{split:,:..|upper}").unwrap();
+        assert_eq!(upper_result, ""); // Consistent: empty string
+
+        // Lower on empty list
+        let lower_result = process("", "{split:,:..|lower}").unwrap();
+        assert_eq!(lower_result, ""); // Consistent: empty string
+
+        // Trim on empty list
+        let trim_result = process("", "{split:,:..|trim}").unwrap();
+        assert_eq!(trim_result, ""); // Consistent: empty string
+
+        // Strip on empty list
+        let strip_result = process("", "{split:,:..|strip:x}").unwrap();
+        assert_eq!(strip_result, ""); // Consistent: empty string
+
+        // Replace on empty list
+        let replace_result = process("", "{split:,:..|replace:s/a/b/}").unwrap();
+        assert_eq!(replace_result, ""); // Consistent: empty string
+
+        // Slice on empty list
+        let slice_result = process("", "{split:,:..|slice:0..1}").unwrap();
+        assert_eq!(slice_result, ""); // Consistent: empty string
+    }
+
+    #[test]
+    fn test_empty_list_chain_with_append_prepend() {
+        // Test chaining operations after append/prepend on empty list
+
+        // Chain after append on empty list
+        let chain_after_append = process("", "{split:,:..|append:!|upper}").unwrap();
+        assert_eq!(chain_after_append, "!");
+
+        // Chain after prepend on empty list
+        let chain_after_prepend = process("", "{split:,:..|prepend:_|lower}").unwrap();
+        assert_eq!(chain_after_prepend, "_");
+
+        // But what if we try to split again after append/prepend?
+        let split_after_append = process("", "{split:,:..|append:a,b|split:,:..|join:-}").unwrap();
+        assert_eq!(split_after_append, "a-b");
+    }
+
+    #[test]
+    fn test_empty_list_multiple_appends_prepends() {
+        // Test multiple append/prepend operations on empty list
+
+        let multiple_appends = process("", "{split:,:..|append:!|append:?}").unwrap();
+        assert_eq!(multiple_appends, "!?");
+
+        let multiple_prepends = process("", "{split:,:..|prepend:_|prepend:#}").unwrap();
+        assert_eq!(multiple_prepends, "#_");
+
+        let mixed = process("", "{split:,:..|append:!|prepend:_}").unwrap();
+        assert_eq!(mixed, "_!");
+    }
+
+    #[test]
+    fn test_empty_list_join_behavior() {
+        // Test join operation on empty list
+        let join_empty = process("", "{split:,:..|join:-}").unwrap();
+        assert_eq!(join_empty, ""); // Should return empty string
+
+        // Test join after operations that might create empty list
+        let join_after_range = process("a,b,c", "{split:,:10..20|join:-}").unwrap();
+        assert_eq!(join_after_range, ""); // Should return empty string
+    }
+
+    #[test]
+    fn test_expected_consistent_behavior_for_empty_lists() {
+        // EXPECTED: append/prepend on empty list should maintain list type consistency
+        // but since it's empty, the final join should use the operation result appropriately
+        let result1 = process("", "{split:,:..|append:a|append:b}").unwrap();
+        let result2 = process("a", "{append:b}").unwrap();
+        assert_eq!(result1, "ab"); // Both should be same
+        assert_eq!(result2, "ab"); // if behavior is consistent
+    }
+
+    #[test]
+    fn test_edge_case_empty_string_vs_empty_list() {
+        // Test difference between empty string and empty list
+
+        // Empty string input
+        let empty_string_append = process("", "{append:!}").unwrap();
+        assert_eq!(empty_string_append, "!"); // String operation
+
+        // Empty list (from split) append
+        let empty_list_append = process("", "{split:,:..|append:!}").unwrap();
+        assert_eq!(empty_list_append, "!"); // List operation -> String
+
+        // These should potentially behave the same way for consistency
+        assert_eq!(empty_string_append, empty_list_append);
+    }
+
+    #[test]
+    fn test_empty_list_with_different_separators() {
+        // Test if the separator tracking works correctly with empty lists
+
+        let result1 = process("", "{split:,:..|append:a|append:b}").unwrap();
+        assert_eq!(result1, "ab");
+
+        let result2 = process("", "{split:-:..|append:a|append:b}").unwrap();
+        assert_eq!(result2, "ab");
+
+        // Both should be the same since we're not creating actual lists
+        assert_eq!(result1, result2);
+    }
+
+    #[test]
+    fn test_empty_list_operation_order_dependency() {
+        // Test if the order of operations affects empty list handling
+
+        // Append then join
+        let append_then_join = process("", "{split:,:..|append:test|join:-}").unwrap();
+        assert_eq!(append_then_join, "test");
+
+        // Join then append (should not be possible, but test error handling)
+        let join_then_append = process("", "{split:,:..|join:-|append:test}").unwrap();
+        assert_eq!(join_then_append, "test");
+
+        // These results expose the internal type conversions
+    }
+
+    #[test]
+    fn test_append_prepend_consistent_behavior() {
+        // All operations on empty lists should return empty results
+        // except when the operation itself provides content
+        // All operations should treat empty list as single empty string element:
+        assert_eq!(process("", "{split:,:..|upper}").unwrap(), "");
+        assert_eq!(process("", "{split:,:..|append:!}").unwrap(), "!");
+        assert_eq!(process("", "{split:,:..|prepend:_}").unwrap(), "_");
+    }
 }
diff --git a/src/pipeline/parser.rs b/src/pipeline/parser.rs
new file mode 100644
index 0000000..0011ff2
--- /dev/null
+++ b/src/pipeline/parser.rs
@@ -0,0 +1,129 @@
+use pest::Parser;
+use pest_derive::Parser;
+
+use super::{RangeSpec, StringOp, unescape};
+
+#[derive(Parser)]
+#[grammar = "pipeline/template.pest"]
+struct TemplateParser;
+
+pub fn parse_template(template: &str) -> Result<Vec<StringOp>, String> {
+    let pairs = TemplateParser::parse(Rule::template, template)
+        .map_err(|e| format!("Parse error: {}", e))?
+        .next()
+        .unwrap();
+
+    let mut ops = Vec::new();
+    for pair in pairs.into_inner() {
+        if pair.as_rule() == Rule::operation_list {
+            for op_pair in pair.into_inner() {
+                ops.push(parse_operation(op_pair)?);
+            }
+        }
+    }
+    Ok(ops)
+}
+
+fn parse_operation(pair: pest::iterators::Pair<Rule>) -> Result<StringOp, String> {
+    let inner = pair.into_inner().next().unwrap();
+    match inner.as_rule() {
+        Rule::shorthand_range => {
+            let range = parse_range_spec(inner)?;
+            Ok(StringOp::Split {
+                sep: " ".to_string(),
+                range,
+            })
+        }
+        Rule::shorthand_index => {
+            let idx = inner.as_str().parse().unwrap();
+            Ok(StringOp::Split {
+                sep: " ".to_string(),
+                range: RangeSpec::Index(idx),
+            })
+        }
+        Rule::split => {
+            let mut parts = inner.into_inner();
+            let sep = unescape(parts.next().unwrap().as_str());
+            let range = parts
+                .next()
+                .map_or_else(|| Ok(RangeSpec::Range(None, None, false)), parse_range_spec)?;
+            Ok(StringOp::Split { sep, range })
+        }
+        Rule::join => {
+            let sep = unescape(inner.into_inner().next().unwrap().as_str());
+            Ok(StringOp::Join { sep })
+        }
+        Rule::slice => {
+            let range = parse_range_spec(inner.into_inner().next().unwrap())?;
+            Ok(StringOp::Slice { range })
+        }
+        Rule::replace => {
+            let mut parts = inner.into_inner().next().unwrap().into_inner();
+            let pattern = parts.next().unwrap().as_str().to_string();
+            let replacement = parts.next().unwrap().as_str().to_string();
+            let flags = parts
+                .next()
+                .map_or_else(String::new, |p| p.as_str().to_string());
+            if pattern.is_empty() {
+                return Err("Empty pattern in sed string".to_string());
+            }
+            Ok(StringOp::Replace {
+                pattern,
+                replacement,
+                flags,
+            })
+        }
+        Rule::upper => Ok(StringOp::Upper),
+        Rule::lower => Ok(StringOp::Lower),
+        Rule::trim => Ok(StringOp::Trim),
+        Rule::strip => {
+            let chars = unescape(inner.into_inner().next().unwrap().as_str());
+            Ok(StringOp::Strip { chars })
+        }
+        Rule::append => {
+            let suffix = unescape(inner.into_inner().next().unwrap().as_str());
+            Ok(StringOp::Append { suffix })
+        }
+        Rule::prepend => {
+            let prefix = unescape(inner.into_inner().next().unwrap().as_str());
+            Ok(StringOp::Prepend { prefix })
+        }
+        _ => Err(format!("Unknown operation: {:?}", inner.as_rule())),
+    }
+}
+
+fn parse_range_spec(pair: pest::iterators::Pair<Rule>) -> Result<RangeSpec, String> {
+    let inner = pair.into_inner().next().unwrap();
+    match inner.as_rule() {
+        Rule::range_inclusive => {
+            let mut parts = inner.into_inner();
+            let start = parts.next().and_then(|p| p.as_str().parse().ok());
+            let end = parts.next().and_then(|p| p.as_str().parse().ok());
+            Ok(RangeSpec::Range(start, end, true))
+        }
+        Rule::range_exclusive => {
+            let mut parts = inner.into_inner();
+            let start = parts.next().and_then(|p| p.as_str().parse().ok());
+            let end = parts.next().and_then(|p| p.as_str().parse().ok());
+            Ok(RangeSpec::Range(start, end, false))
+        }
+        Rule::range_from => {
+            let start = inner.into_inner().next().unwrap().as_str().parse().ok();
+            Ok(RangeSpec::Range(start, None, false))
+        }
+        Rule::range_to => {
+            let end = inner.into_inner().next().unwrap().as_str().parse().ok();
+            Ok(RangeSpec::Range(None, end, false))
+        }
+        Rule::range_to_inclusive => {
+            let end = inner.into_inner().next().unwrap().as_str().parse().ok();
+            Ok(RangeSpec::Range(None, end, true))
+        }
+        Rule::range_full => Ok(RangeSpec::Range(None, None, false)),
+        Rule::index => {
+            let idx = inner.into_inner().next().unwrap().as_str().parse().unwrap();
+            Ok(RangeSpec::Index(idx))
+        }
+        _ => Err(format!("Unknown range spec: {:?}", inner.as_rule())),
+    }
+}
diff --git a/src/pipeline/template.pest b/src/pipeline/template.pest
new file mode 100644
index 0000000..273f80e
--- /dev/null
+++ b/src/pipeline/template.pest
@@ -0,0 +1,69 @@
+WHITESPACE = _{ " " | "\t" }
+
+template = { "{" ~ operation_list? ~ "}" }
+
+operation_list = { operation ~ ("|" ~ operation)* }
+
+operation = {
+    shorthand_range |
+    shorthand_index |
+    split |
+    join |
+    slice |
+    replace |
+    upper |
+    lower |
+    trim |
+    strip |
+    append |
+    prepend
+}
+
+shorthand_index = { number }
+shorthand_range = {
+    range_to_inclusive |
+    range_to |
+    range_inclusive |
+    range_exclusive |
+    range_from |
+    range_full
+}
+
+split = { "split" ~ ":" ~ arg ~ ":" ~ range_spec? }
+join = { "join" ~ ":" ~ arg }
+slice = { "slice" ~ ":" ~ range_spec }
+replace = { "replace" ~ ":" ~ sed_string }
+upper = { "upper" }
+lower = { "lower" }
+trim = { "trim" }
+strip = { "strip" ~ ":" ~ arg }
+append = { "append" ~ ":" ~ arg }
+prepend = { "prepend" ~ ":" ~ arg }
+
+arg = @{ (escaped_char | normal_char)* }
+normal_char = { !(":" | "|" | "}" | "\\") ~ ANY }
+escaped_char = { "\\" ~ (":" | "|" | "\\" | "n" | "t" | "r" | "/") }
+
+sed_string = { "s/" ~ sed_part ~ "/" ~ sed_part ~ "/" ~ sed_flags? }
+sed_part = @{ (("\\" ~ ANY) | (!("/" | "\\") ~ ANY))* }
+sed_flags = @{ ASCII_ALPHA* }
+
+range_spec = {
+    range_to_inclusive |
+    range_to |
+    range_inclusive |
+    range_exclusive |
+    range_from |
+    range_full |
+    index
+}
+
+range_inclusive = { number? ~ "..=" ~ number? }
+range_exclusive = { number? ~ ".." ~ number? }
+range_from = { number ~ ".." }
+range_to = { ".." ~ number }
+range_to_inclusive = { "..=" ~ number }
+range_full = { ".." }
+index = { number }
+
+number = @{ "-"? ~ ASCII_DIGIT+ }