Backed by mandō

Directory intelligence,
at scale.

Lyst is the best-in-class filesystem visibility engine trusted by world-class engineering teams. Surface every file, every permission, every detail — with zero friction and ruthless prioritisation of what matters.

See it in action

~/projects

$ lyst -la

total 48

drwxr-xr-x 12 dev staff 384 Mar 15 09:42 .

drwxr-xr-x 6 dev staff 192 Mar 12 14:20 ..

-rw-r--r-- 1 dev staff 285 Mar 15 09:42 .gitignore

drwxr-xr-x 8 dev staff 256 Mar 15 09:30 .git

-rw-r--r-- 1 dev staff 1204 Mar 14 17:55 package.json

drwxr-xr-x 42 dev staff 1344 Mar 15 09:30 node_modules

-rw-r--r-- 1 dev staff 892 Mar 14 18:01 tsconfig.json

drwxr-xr-x 9 dev staff 288 Mar 15 09:42 src

-rw-r--r-- 1 dev staff 145 Mar 13 11:22 README.md

drwxr-xr-x 3 dev staff 96 Mar 14 16:40 dist

Features

Every flag is a feature.
Every feature is a moat.

We obsess over filesystem visibility so you can focus on shipping. Every option has been battle-tested at massive scale.

🔍

Deep Inspect™ -l

Unlock the long listing format — a paradigm shift in filesystem observability. Surface permissions, ownership, file size, and timestamps in a single, high-leverage invocation. This is your north star metric for directory health.

👁️

Zero Blind Spots™ -a

Stop ignoring entries starting with a dot. Our category-defining hidden-file revelation engine ensures you never miss a configuration file, a dotfile, or anything your filesystem is keeping from you. Total visibility. Zero compromises.

🌳

Recursive Intelligence™ -R

Compound your directory knowledge by listing subdirectories recursively. This is the 10x multiplier for teams that need to surface deeply nested content across their entire tree — from first principles.

🎨

ChromaView™ --color

Game-changing colorized output that lets you distinguish file types at a glance. Directories, executables, symlinks — each gets its own visual identity. Ship faster with visual pattern recognition built right into your workflow.

📊

HumanScale™ -h

Print sizes like 1K, 234M, 2G — because nobody has time to do mental math on raw byte counts. Move fast with human-readable output that unlocks async decision-making across your entire org.

⚡

SmartSort Engine™ -S / -t / -v / -X

Sort by size, time, version numbers, or extension. Our best-in-class sorting pipeline lets you ruthlessly prioritise files by what actually matters — whether that's the largest, newest, or most relevant entries.

🏷️

TypeClassify™ -F

Append indicator characters (one of */=>@|) to every entry. Instantly distinguish directories, executables, symlinks, sockets, and FIFOs. This is the moat that separates high-leverage operators from everyone else.

📁

DirectoryFirst™ --group-directories-first

Group directories before files — the mission-critical organisation feature every world-class team demands. Default alive with structural clarity. Strong opinions, loosely held, but this one is non-negotiable.

How it works

From zero to one in four steps.

A high-leverage, async-native pipeline designed to surface filesystem insights faster than any legacy solution.

Target Acquisition

Point Lyst at any directory or file path. Our engine ingests your target and prepares the intelligence pipeline.

Feature Selection

Compose your query with flags — long listing, recursion, sorting, filtering. Each flag compounds the value of your invocation.

Execution Engine

Lyst processes your request, reading directory entries, resolving symlinks, computing sizes, and applying sort algorithms at native speed.

Structured Output

Receive a beautifully formatted, column-aligned, optionally colorized listing. Ready for piping into downstream systems or human consumption.

Live Demo

See Lyst in action.

Real commands, real output. No smoke and mirrors — just raw filesystem intelligence.

Deep Inspect + HumanScale

$ lyst -lhS /var/log

total 42M

-rw-r----- 1 root adm 15M Mar 15 09:40 syslog

-rw-r----- 1 root adm 8.2M Mar 14 23:59 kern.log

-rw-r----- 1 root adm 6.1M Mar 15 09:42 auth.log

-rw-r----- 1 root adm 4.8M Mar 13 06:25 dpkg.log

-rw-r--r-- 1 root root 2.4M Mar 15 00:00 alternatives.log

-rw-rw-r-- 1 root utmp 1.1M Mar 15 09:30 wtmp

drwxr-xr-x 2 root root 4.0K Mar 15 09:42 apt

drwxr-xr-x 2 root root 4.0K Mar 12 00:00 journal

Recursive Intelligence + TypeClassify

$ lyst -RF src/

src/:

components/ index.ts utils/ app.tsx

src/components:

Button.tsx Header.tsx Modal.tsx icons/

src/components/icons:

logo.svg arrow.svg close.svg

src/utils:

helpers.ts constants.ts api.ts

0%

Of production servers run Lyst

0+

Configuration flags available

0 GB/s

Directory throughput on commodity hardware

0K+

Teams that ship with Lyst

Comparison

The only tool that compounds.

See how Lyst stacks up against legacy directory listers.

Feature	Lyst	Competitor A	Competitor B	Competitor C
Long listing format	✓	✓	✗	✓
Recursive traversal	✓	✗	✓	✗
Colorized output	✓	✗	✗	✓
Human-readable sizes	✓	✗	✗	✗
Multi-sort engine (size/time/version/ext)	✓	✓	✗	✗
Hidden file discovery	✓	✓	✓	✗
Security context support	✓	✗	✗	✗
Hyperlink output	✓	✗	✗	✗

Pricing

Simple, transparent pricing.

Start free. Scale as your filesystem surface area grows.

Starter

$0 / mo

For solo developers who want basic directory listing.

Basic column listing (-C)
Single-file-per-line mode (-1)
Comma-separated output (-m)
Long listing format (-l)
Recursive traversal (-R)
Colorized output

Pro

$19 / mo

For power users who need full filesystem visibility.

Everything in Starter
Deep Inspect™ long listing (-l)
HumanScale™ readable sizes (-h)
SmartSort™ engine (-S -t -v -X)
Zero Blind Spots™ (-a)
ChromaView™ colorized output
Unlimited invocations

Team

$59 / seat / mo

For engineering teams that need shared filesystem intelligence.

Everything in Pro
Recursive Intelligence™ (-R)
TypeClassify™ indicators (-F)
DirectoryFirst™ grouping
Security context mode (-Z)
Hyperlink output (--hyperlink)
Inode exposure (-i)
Priority support

Enterprise

Custom

For organisations with mission-critical filesystem needs.

Everything in Team
Custom block-size (--block-size)
Full-ISO time formatting (--full-time)
Dired mode output (-D)
Custom quoting styles (--quoting-style)
NUL-terminated output (--zero)
Dedicated account manager
99.999% SLA

Testimonials

Trusted by builders who ship.

"Lyst's Recursive Intelligence feature was an absolute game-changer for our infrastructure team. We went from manually inspecting nested directories to having full tree visibility in a single invocation. The compound effect on our deploy pipeline was unreal. This is the 10x tool I didn't know I needed."

Dot Slasher

Staff SRE, CloudNova

"We replaced three internal tools with Lyst Pro. The HumanScale output alone saves our ops team hours per week — no more mental math converting bytes to gigabytes. Strong opinions, loosely held, but switching to Lyst was the best high-leverage decision we made this quarter."

Dr Rahel Tessema

VP Engineering, Stackblitz

"I used to iterate blindly through codebases. Since adopting Lyst's ChromaView and TypeClassify together, I can visually parse a directory in milliseconds. Directories, symlinks, executables — all colour-coded. It's like going from a flip phone to an iPhone. Default alive energy."

Felix Chen

Founding Engineer, Pipekit

"We evaluated every directory listing solution on the market. Lyst was the only platform that offered sorting by size, time, version, AND extension in a single SKU. The SmartSort engine is the moat. Our team moved fast, shipped faster, and never looked back."

Elena Larsson

CTO, DeployHQ

"Security context mode (-Z) was a non-negotiable for our compliance team. Lyst Enterprise gave us SELinux label visibility out of the box, plus NUL-terminated output for safe scripting pipelines. This is the kind of ruthless prioritisation of developer ergonomics I wish more tools had."

Hana Luz

Head of Security, FinOps Inc.

What's new

We ship every week.

Building in public. Here's what we've been iterating on.

v4.2.0

New Hyperlink Output Mode

Enable clickable file names in supported terminals with --hyperlink. Navigate your filesystem without ever leaving the output buffer. A paradigm shift in directory listing UX.

v4.1.0

Improved SmartSort Width Engine

New --sort=width option lets you sort entries by filename length. Plus, natural version sort (-v) now handles edge cases with mixed alphanumeric sequences 10x more reliably.

v4.0.0

Fix NUL-Terminated Output Pipeline

The --zero flag now correctly terminates every output line with NUL instead of newline, making Lyst fully compatible with xargs -0 and other NUL-delimited consumers. Mission-critical fix for scripting at scale.

FAQ

Questions? We've got answers.

With our Zero Blind Spots feature (-a), Lyst reveals every entry — including those starting with a dot that are normally suppressed. For teams that want hidden files without the . and .. entries, the -A (almost-all) flag provides a refined alternative. Total visibility, your way.

Absolutely. Our SmartSort Engine supports sorting by size (-S), modification time (-t), version number (-v), file extension (-X), and even width. You can also reverse any sort order with the -r flag or disable sorting entirely with -U for raw, unsorted directory output.

Yes. Lyst Enterprise includes security context printing (-Z) for SELinux labels, author attribution (--author), numeric UID/GID output (-n), and inode numbers (-i). Combined with the --full-time option for ISO-format timestamps, you get audit-ready output that meets the most stringent compliance requirements.

Lyst gives you full control over symlink resolution. By default, symlinks are shown as-is. Use -L (dereference) to display information for the file a symlink references, or -H to dereference only command-line arguments. The TypeClassify indicator (-F) appends @ to symlinks for instant visual identification.

Lyst supports multiple output formats to fit any pipeline: column layout (-C), one-per-line (-1), comma-separated (-m), across/horizontal (-x), and the full long listing (-l). You can also control quoting styles with --quoting-style (literal, locale, shell, C-escape, and more) and use --zero for NUL-delimited output.

Directory intelligence,at scale.

Every flag is a feature.Every feature is a moat.