Ever rm -rf'd a large directory and sat there waiting for it to finish? With poof you no longer need to wait:

$ poof ./large-file ./large-directory "**/globs"

poof is a fast, non-blocking CLI alternative to rm -rf, designed for deleting large files and directories without waiting for cleanup to complete.

It works by quickly moving files and directories out of the way, then deleting them in the background. This means large deletions finish instantly from your perspective, even when there's a lot of data to clean up.

On a large filesystem (4.7 GB, 190k files), poof returns control in ~0.6s while rm -rf takes ~28s and rimraf ~12s. Full benchmarks below.

• ⚡ Immediate return: deletion doesn't block your shell
• 🗂 Move-then-delete: fast, atomic rename before cleanup
• 🛡 Built-in safeguards: root protection and directory scoping
• 🖥 Cross-platform: macOS, Linux, and Windows

npm install -g poof

# Delete files or directories
$ poof node_modules dist

# Use glob patterns
$ poof "*.log" "temp-*"

# Recursive match with ** (searches all subdirectories)
$ poof "**/node_modules" "**/dist"

# Verbose output
$ poof --verbose ./large-directory

poof accepts explicit paths or glob patterns for flexible file matching.

How unquoted glob patterns are expanded depends on your shell's settings (dotglob, globstar, etc.).
To get consistent behavior, quote the pattern so poof handles the matching itself.

# The shell expands the glob before poof runs
$ poof **/node_modules

# Recommended: poof expands the glob
$ poof "**/node_modules"

# Explicit paths
$ poof node_modules

# Multiple paths
$ poof dist coverage

# Wildcards in current directory
$ poof "*.log"
$ poof "temp-*"

Use ** to match across nested directories:

# All node_modules in a monorepo
$ poof "**/node_modules"

# All .log files recursively
$ poof "**/*.log"

# Multiple patterns
$ poof "**/dist" "**/coverage" "**/*.tmp"

Use --ignore to exclude paths from deletion:

# Delete all dist folders except those in node_modules
$ poof "**/dist" --ignore "**/node_modules/**"

# Multiple ignore patterns
$ poof "**/*.log" -i "**/important/**" -i "**/backup/**"

By default, glob wildcards (*, **) don't match dotfiles (files starting with .). This helps avoid accidentally deleting .git, .env, or other hidden files.

To target dotfiles, explicitly include the . in your pattern:

# Delete all dotfiles in current directory
$ poof ".*"

# Delete .cache directories (not inside hidden dirs)
$ poof "**/.cache"

# Delete a specific dotfile
$ poof .env.local

**/.cache finds .cache directories in regular directories, but does not scan inside other hidden directories like .git. This is intentional—scanning hidden directories is slow and rarely useful.

To search inside hidden directories, start your pattern with .*:

# Find .cache inside any hidden directory
$ poof ".*/**/.cache"

Or use brace expansion to target specific directories:

# Search inside .config and src
$ poof "{.config,src}/**/.cache"

Extglob negations like !(pattern) match everything except the specified pattern:

# Delete everything except .gitkeep
$ poof "!(.gitkeep)"

poof includes guards to help prevent common accidents:

• Root protection: refuses to delete the filesystem root
• Directory scoping: won't delete paths outside cwd unless --dangerous is passed
• Script-friendly: missing paths and empty glob matches are silently ignored (like rm -rf), so cleanup scripts won't fail on non-existent files

Traditional rm -rf blocks until every file is unlinked. For large directories, this means waiting on thousands of filesystem operations.

poof uses a different strategy:

1. Resolve glob patterns and validate paths
2. Spawn a detached cleanup process
3. Rename files to a temp directory (constant-time, atomic)
4. Stream renamed paths to the cleanup process as renames complete
5. Exit process to return your shell while cleanup process continues in the background

If the target is on a different filesystem (EXDEV), poof falls back to renaming in place with a hidden prefix (e.g., .poof-uuid-large-directory) and streams it directly to the cleaner.

Deleting **/node_modules directories from a synthetic fixture:

Fixture: 4.7 GB, 190k files

Environment: macOS 15.2, Apple M2 Max, SSD

poof can also be used programmatically:

import poof from 'poof'

await poof('./large-directory')
await poof(['**/dist', 'coverage'])

const { deleted, errors } = await poof('./large-directory', { dry: true })

type Options = {
    cwd?: string
    dry?: boolean
    dangerous?: boolean
    ignore?: string[]
}

type Failure = {
    path: string
    error: Error
}

type Result = {
    deleted: string[]
    errors: Failure[]
}

Some tools provide fast, non-blocking removal by moving files to the system trash:

• trash (macOS)
• trash-cli (cross-platform)

These are useful for recoverable deletes, but have some limitations:

• Large directories accumulate in trash and consume disk space
• trash fails on non-existent paths, making it unsuitable for cleanup scripts where files may or may not exist (e.g., cache files)

poof permanently deletes files, freeing space immediately, and silently ignores missing paths for script-friendly behavior.

Node.js >= 20.19.6

MIT