Backed by mandō

Remove nothing.
Perfectly.

Vøid is the industry-standard empty directory removal engine trusted by elite engineering teams. Surgical precision. Zero collateral damage. Only empty directories. Only clean filesystems. This is the tool your infrastructure deserves.

See it in action

~/projects

$ void -pv old/cache/tmp

void: removing directory, 'old/cache/tmp'

void: removing directory, 'old/cache'

void: removing directory, 'old'

$ void -v notempty/

void: failed to remove 'notempty/': Directory not empty

$ # Working as intended. Scope boundaries respected.

Features

Principled constraints.
Not limitations.

We don't remove non-empty directories. That's not a bug — it's a design philosophy. Every feature is a guardrail that protects your data at scale.

🛡️

SafeRemove™ core

Only removes empty directories. Period. While other tools recklessly destroy populated paths, Vøid's zero-collateral architecture guarantees that not a single file is ever at risk. This isn't a limitation — it's the highest-leverage safety primitive in the entire POSIX specification.

🧬

AncestorPurge™ -p

Remove a directory and its ancestor chain in a single invocation. void -p a/b/c eliminates a/b/c, then a/b, then a — but only if each is empty. Recursive cleanup without recursive risk. This is the compound effect applied to filesystem hygiene.

📢

VerboseTrace™ -v

Output a diagnostic for every directory processed. Full observability into each removal operation. Know exactly what happened, when it happened, and in what order. Auditability is not optional at scale — it's a north star metric for infrastructure health.

🤫

GraceFail™ --ignore-fail-on-non-empty

Silently ignore failures when a directory isn't empty. No exit code pollution. No noisy stderr. Your CI/CD pipelines stay green, your cleanup scripts stay idempotent, and your on-call rotation stays asleep. Graceful degradation is a feature, not a compromise.

🎯

ScopeGuard™ design

Vøid will never, under any circumstances, remove a directory that contains files, symlinks, or subdirectories. This is not configurable. This is not overridable. This is the single-responsibility principle applied to filesystem operations with zero compromises.

⚡

BatchVoid™ multi-arg

Pass multiple directories in a single invocation. Vøid processes each target in sequence with atomic-level precision. One command, many voids. This is the high-leverage multiplier for teams running large-scale directory cleanup across build systems and artifact stores.

How it works

Elegantly simple. By design.

A disciplined, zero-overhead pipeline that does exactly one thing and does it better than anything else on earth.

Target Selection

Point Vøid at one or more directory paths. Our engine validates each target exists and is indeed a directory — not a file, not a symlink, not a socket.

Emptiness Verification

The core differentiator. Vøid inspects each directory to confirm it contains zero entries. If a single inode is found, the operation halts. Your data stays safe. Always.

Surgical Removal

Empty directories are unlinked from the filesystem with zero side effects. With -p, ancestor directories are removed bottom-up, each independently verified for emptiness.

Audit Trail

With -v, every operation is logged to stderr. Full traceability for compliance, debugging, and post-mortem analysis. Your infrastructure team will thank you.

Live Demo

See Vøid in action.

Real commands, real output. The constraint is the feature.

AncestorPurge™ in action

$ void -pv build/artifacts/tmp

void: removing directory, 'build/artifacts/tmp'

void: removing directory, 'build/artifacts'

void: removing directory, 'build'

GraceFail™ — silent resilience

$ void --ignore-fail-on-non-empty logs/ cache/ tmp/

$ echo $?

$ # logs/ had files — gracefully skipped. Zero noise.

ScopeGuard™ — protecting your data

$ ls important-project/

README.md src/ package.json

$ void -v important-project/

void: failed to remove 'important-project/': Directory not empty

$ # Your files are safe. Always.

0

Files accidentally deleted. Ever.

0

Flags. That's all you need.

0%

Of removals verified empty first

0K+

Empty directories removed per day

Manifesto

Why empty directory removal deserves its own product.

The filesystem is a shared resource. Every orphaned directory is technical debt. Every empty folder left behind by a build tool, a deployment script, or a careless mkdir is entropy accumulating in your infrastructure.

Other tools try to do everything. They remove files. They remove directories. They remove non-empty directories recursively. They are generalists in a world that rewards specialists.

Vøid does one thing. It removes empty directories. It will never remove a file. It will never remove a directory that contains anything. This is a feature. This is the moat. This is the principled constraint that makes Vøid the safest, most predictable directory removal primitive ever built.

We believe that in a world of rm -rf, the courage to do less is the ultimate competitive advantage.

Comparison

Principled. Not limited.

See how Vøid's intentional scope compares to reckless generalists.

Capability	Vøid	Tool A	Tool B
Removes empty directories	✓	✓	✓
Removes files	✗ by design	✓	✓
Removes non-empty directories	✗ by design	✓	✓
Ancestor chain purge	✓	✗	✗
Graceful non-empty handling	✓	✗	✗
Zero data loss guarantee	✓	✗	✗
Can destroy your production database	✗ impossible	✓	✓
Verbose audit trail	✓	✓	✗

Pricing

Pay for peace of mind.

Every tier guarantees zero files deleted. Scale your emptiness management as your infrastructure grows.

Starter

$0 / mo

For solo devs who manually clean up after themselves.

Remove 1 empty directory at a time
Basic error messaging
Community support
AncestorPurge™ (-p)
VerboseTrace™ (-v)
GraceFail™

Pro

$14 / mo

For power users with lots of empty directories to manage.

Everything in Starter
AncestorPurge™ chain removal (-p)
VerboseTrace™ audit logging (-v)
BatchVoid™ multi-directory support
Unlimited empty directory removals
Email support

Enterprise

$49 / seat / mo

For teams with mission-critical emptiness requirements.

Everything in Pro
GraceFail™ silent error suppression
CI/CD pipeline integration kit
SSO & audit log export
Dedicated account manager
99.999% SLA on empty removals
Priority support

Testimonials

Trusted by teams that value restraint.

"After the incident where someone ran a recursive remove on our artifact store, we switched every cleanup script to Vøid. It literally cannot delete files. The ScopeGuard architecture gives our SRE team the confidence to automate cleanup without ever worrying about data loss. This is the tool we didn't know we needed."

Julian Svensson

Staff SRE, InfraCo

"We have 40,000 build artifacts generated per day. After each pipeline run, hundreds of empty directories accumulate. Vøid's AncestorPurge feature cleans the entire tree bottom-up in a single invocation. The GraceFail flag means our CI stays green even when some directories aren't empty yet. Absolute game-changer."

Kai Hashimoto

VP Platform, BuildKit

"I pitched Vøid to our board as 'the safest cleanup tool in existence' and they immediately approved the Enterprise license. When I explained that it physically cannot remove a directory that contains anything, the CISO literally applauded. We've had zero incidents since deployment."

Tamara Matsuda

CTO, SafeScale

"Other removal tools give you a loaded gun and say 'be careful'. Vøid gives you a tool that can only remove empty directories. That's not a limitation — that's a philosophical commitment to safety. We run it in production across 3,000 nodes. Zero files lost. Zero."

Bianca Park

Head of Infra, CleanOps

"The verbose mode alone is worth the Pro subscription. During our SOC 2 audit, we pulled VerboseTrace logs showing exactly which empty directories were removed, in what order, and by whom. The auditors had never seen such granular filesystem hygiene documentation. Passed with flying colours."

Camille Reeves

Security Lead, ComplianceHQ

What's new

Shipping less, intentionally.

Every release is a deliberate refinement of our core constraint.

v3.2.0

New GraceFail™ Mode

--ignore-fail-on-non-empty silently skips non-empty directories instead of failing. Your CI/CD pipelines stay green. Your on-call engineers stay in bed. Idempotent cleanup at scale.

v3.1.0

Improved AncestorPurge™ Diagnostics

The -p flag now emits per-ancestor verbose output when combined with -v. Full bottom-up traceability for each directory in the ancestor chain. Compliance teams rejoice.

v3.0.0

Fix Exit Code Consistency

Ensured that batch operations return the correct exit code when some directories fail and others succeed. Combined with --ignore-fail-on-non-empty, exit semantics are now fully deterministic.

FAQ

Questions? We've thought about this.

Vøid operates within clearly defined scope boundaries. If a directory contains any entries — files, subdirectories, symlinks, or otherwise — the removal operation is declined. This is a deliberate design decision rooted in the single-responsibility principle. We recommend verifying emptiness before invocation, or using --ignore-fail-on-non-empty for graceful degradation in automated pipelines.

You're not paying for removal — you're paying for the guarantee that nothing else gets removed. In a post-rm -rf / world, the value of a tool that can never delete your data is incalculable. Our Enterprise customers report a 100% reduction in accidental file deletions from cleanup scripts after switching to Vøid. That's not a feature set — that's an insurance policy.

When you invoke void -p a/b/c, Vøid first removes a/b/c (if empty), then a/b (if empty), then a (if empty). Each ancestor is independently verified for emptiness before removal. If any directory in the chain is not empty, the purge stops at that point. Zero assumptions. Zero risk. Compound cleanup with atomic safety guarantees.

Yes. Pass multiple directory paths in a single invocation: void tmp/ cache/ old-builds/. Each directory is processed independently. Failures on one path do not affect the others. Combined with --ignore-fail-on-non-empty, this makes Vøid ideal for batch cleanup operations in CI/CD environments where some directories may or may not be empty.

Vøid is the safest removal tool in existence. By architectural design, it is physically incapable of removing files or non-empty directories. There is no flag combination, no race condition, no edge case that would allow Vøid to delete your data. Run it in production. Run it in a cron job. Run it on a Friday afternoon. You literally cannot break anything.

Remove nothing.Perfectly.

Principled constraints.Not limitations.