Trellis — Enterprise Structured Data Processing

CAPABILITIES

Every feature maps to a
real processing primitive.

Trellis exposes the full power of structured data processing through a composable, operator-driven API. No abstraction leaks. No hidden complexity.

-F

Universal Delimiter Engine

Set your field separator to any character or regex. CSV, TSV, pipe-delimited, colon-separated — Trellis splits your records instantly with -F. No format configuration files. No schema declarations. One flag, any structure.

$1 $2 $N

Column-Level Precision

Reference any field by position. $1 is the first column, $NF is the last. Select, rearrange, and compute across fields with surgical precision. This is the core of Trellis — every record decomposed into addressable atoms.

pattern { action }

Conditional Processing Pipeline

Every rule in Trellis is a pattern-action pair. Match on regex, numeric comparisons, or field values — then execute arbitrary transformations. It's declarative ETL without the YAML.

BEGIN / END

Lifecycle Hooks

Execute setup logic before the first record with BEGIN. Finalize, aggregate, and report after the last record with END. Print headers, compute summaries, flush caches — all built into the processing lifecycle.

NR NF FS

Runtime Context Variables

Trellis exposes NR (total records seen), NF (fields in current record), FILENAME, FNR, and more. Real-time metadata about your pipeline state — no manual counters, no external bookkeeping.

printf

Formatted Output Engine

Produce perfectly aligned, type-safe output with C-style printf. Control column widths, decimal precision, padding, and justification. Generate reports that are pipe-ready and human-readable.

gsub split substr

In-Stream Transformations

Regex substitution with gsub and sub. String slicing with substr. Tokenization with split. Case conversion with tolower / toupper. Transform data in the same pass you read it — zero intermediate files.

array[key]

Native Key-Value Aggregation

Associative arrays are first-class citizens. Group by any field, count occurrences, sum values, build histograms — all in a single pass through your data. No external databases. No MapReduce overhead. Just arr[key] += val.

PIPELINE

Four stages. Zero config.

Trellis processes your data in a deterministic, streaming pipeline. Each record flows through the same stages, every time.

01

Ingest & Split

Trellis reads your input line by line — files, stdin, or piped output — and splits each record into fields using your configured delimiter. CSV, TSV, fixed-width, or custom regex. Fields are immediately addressable as $1, $2, … $NF.

02

Match Patterns

Each record is evaluated against your pattern rules — regex matches, field comparisons, range expressions, compound boolean logic. Only matching records proceed to their associated action block. Non-matching records are skipped at zero cost.

03

Transform & Aggregate

Action blocks execute arbitrary computations: field extraction, string manipulation, arithmetic, aggregation into associative arrays, formatted output via printf. Multiple rules can fire on the same record. State persists across records.

04

Finalize & Emit

END blocks fire after the last record. Emit summary statistics, flush accumulators, write final reports. Output goes to stdout, files, or downstream pipes. Trellis is a first-class Unix citizen — it composes with everything.

0

Records processed per second on commodity hardware

99%

Of Linux servers ship with Trellis pre-installed

47+

Built-in functions for string, math, and time operations

0

External dependencies required

INTEGRATIONS

Composes with your entire stack.

│

Unix Pipes

📁

CSV / TSV

🔄

ETL Pipelines

📊

Log Analytics

🗄️

Databases

☁️

Cloud Storage

🔗

REST APIs

📈

Monitoring

WHY TRELLIS

How we compare.

Traditional ETL tools weren't designed for streaming, field-level processing. Trellis was.

Capability	Trellis	Pandas	SQL	Spark
Zero-config setup	✓	—	—	—
Streaming processing	✓	—	—	✓
Zero dependencies	✓	—	—	—
Regex pattern matching	✓	✓	Partial	✓
Field-level access	✓	✓	✓	✓
Pipe composability	✓	—	—	—
Memory footprint	<1 MB	~200 MB	~50 MB	~2 GB
Startup time	<1 ms	~2 s	~500 ms	~15 s

LIVE DEMO

See Trellis in action.

Real processing pipelines. Real output. Click a tab to explore different use cases.

csv-extraction.sh

# Extract name and department from employee CSV

$ cat employees.csv

id,name,department,salary

101,John Park,Engineering,125000

102,Sarah Chen,Marketing,98000

103,Mike Torres,Design,105000

104,Lisa Wang,Engineering,132000

105,Tom Reeves,Sales,88000

$ trellis -F',' 'NR>1 {printf "%-14s %s\n", $2, $3}' employees.csv

John Park Engineering

Sarah Chen Marketing

Mike Torres Design

Lisa Wang Engineering

Tom Reeves Sales

aggregation.sh

# Average salary by department

$ trellis -F',' 'NR>1 {sum[$3]+=$4; count[$3]++} END {for (d in sum) printf "%-14s $%d\n", d, sum[d]/count[d]}' employees.csv

Engineering $128500

Marketing $98000

Design $105000

Sales $88000

# Count employees per department

$ trellis -F',' 'NR>1 {dept[$3]++} END {for (d in dept) print d, dept[d]}' employees.csv

Engineering 2

Marketing 1

Design 1

Sales 1

transform.sh

# Uppercase department names and format as TSV

$ trellis -F',' 'BEGIN {OFS="\t"} NR>1 {print $1, toupper($3), $2}' employees.csv

101 ENGINEERING John Park

102 MARKETING Sarah Chen

103 DESIGN Mike Torres

104 ENGINEERING Lisa Wang

105 SALES Tom Reeves

# Replace "Engineering" with "Eng" using gsub

$ trellis -F',' '{gsub(/Engineering/,"Eng",$3); print $2, $3}' employees.csv

name department

John Park Eng

Sarah Chen Marketing

Mike Torres Design

Lisa Wang Eng

Tom Reeves Sales

multi-file.sh

# Process access logs — count requests per IP

$ trellis '{ip[$1]++} END {for (i in ip) printf "%4d %s\n", ip[i], i}' access.log

42 192.168.1.10

17 10.0.0.5

128 172.16.0.1

8 192.168.1.25

# Use -v to inject variables from outside

$ trellis -v threshold=20 '{ip[$1]++} END {for (i in ip) if (ip[i]>threshold) print i, ip[i]}' access.log

192.168.1.10 42

172.16.0.1 128

CUSTOMERS

Trusted by data teams everywhere.

"We replaced a 300-line Python ETL script with a single Trellis pipeline. It runs in 40ms instead of 12 seconds. I genuinely don't understand why we ever did it the other way."

Jason Kim

Staff Data Engineer, StreamScale

"The pattern-action model is the most elegant abstraction for structured data I've worked with. BEGIN/END hooks give you full lifecycle control. It's like having a mini database engine in your terminal."

Radhika Patel

VP of Infrastructure, NexaLabs

"We process 4 million log lines per hour through Trellis. Associative arrays let us aggregate by any dimension in a single pass. The printf formatting alone saved our ops team hours of report formatting."

Felix Chen

CTO, ObserveKit

"Field splitting with -F plus gsub for inline transformations — that's our entire CSV normalization pipeline. Runs on every server we have. Zero deployment friction. This is what infrastructure should feel like."

Elena Larsson

Platform Lead, DataForge

"I showed my team leader a one-liner that did what our Spark job does. He asked me how much the cluster costs. I said it was free and runs on a Raspberry Pi. He didn't believe me."

Alex Oduya

Senior SRE, InfraCore

PRICING

Simple, predictable pricing.

Every tier unlocks real processing capabilities. Scale when you're ready.

Starter

Free

For individual developers exploring structured data.

Single file processing
Basic field splitting ($1–$9)
Print and basic output
10 pattern-action rules max
Community support

Frequently asked questions.

What data formats does Trellis support?

Trellis supports any delimited text format out of the box — CSV, TSV, pipe-delimited, colon-separated, and more. Set your delimiter with -F and Trellis handles the rest. For CSV with quoted fields, use the --csv flag (Enterprise). Fixed-width data is supported via FIELDWIDTHS, and content-based splitting via FPAT.

Is Trellis secure enough for production workloads?

Absolutely. Trellis is SOC 2 Type II certified and GDPR compliant. Our Enterprise tier includes sandbox mode (-S) which completely disables system calls, file redirection, and dynamic extensions — giving you a fully locked-down processing environment. Your data never leaves your infrastructure.

How does Trellis compare to writing custom Python scripts?

For structured data processing tasks, Trellis pipelines are typically 10-100x faster than equivalent Python scripts, use negligible memory, and require zero dependencies. A typical Trellis pipeline is a single line that replaces 50-200 lines of Python. For complex ML or statistical workloads, Python is still the right choice — but for ETL, aggregation, and transformation, Trellis is unbeatable.

Can I use Trellis offline?

Yes. Trellis runs entirely locally with zero network dependencies. It processes data on your machine, in your terminal, with no cloud calls. This is by design — when we say "your data never leaves your infrastructure," we mean it literally.

Does Trellis support user-defined functions?

Yes. On Team and Enterprise tiers, you can define reusable functions with full recursion support, local variable scoping, and pass-by-reference arrays. Build libraries of domain-specific transformations and share them across your organization via @include.

Your data pipeline shouldn't need a cluster.

Start processing structured data in seconds. No infrastructure. No dependencies. No excuses.

The ETL layer yourdata stack is missing.

Every feature maps to areal processing primitive.