100 programs. One job each, done properly.

One big file, several connections, and a resume that won't corrupt it.

Work through a whole list of downloads at once, politely, without any site cutting you off.

A download queue that survives being killed. Resuming is just running it again.

One download queue on one box, and everybody on the team can add to it.

Double-click it, pick a folder, see where your disk space actually went.

At this rate, when does /var/log fill up? A regression gives you the date.

Sorts what's eating your disk into junk types, and deletes absolutely nothing.

Point it at six shares and see which one runs out of room first.

Byte-for-byte duplicates, compared by contents rather than names, and moved rather than deleted.

Finds invoice.pdf, invoice (1).pdf and invoice_final.pdf. Never opens a file.

Finds the same photo saved twice at different sizes, which an exact-match tool never will.

Which of your shares is wasting the most space on duplicate files?

A folder of screenshots plus a text file becomes one guide you can email.

Twenty ticket screenshot folders in, twenty step-by-step docs out, one command.

Redact forty support screenshots identically, because the coordinates live in a file.

Screenshots plus a manifest become a Word file with the arrows already drawn.

Run any command automatically when a file shows up in a folder you name.

Drop a PDF in Inbox and it gets filed. Dry run until you say otherwise.

Many watch-a-folder rules in one rules file, each failing on its own.

A folder of workflow files a colleague can run right without reading them first.

Overwrites files with random data, removes them, and records what it destroyed.

Knows that Firefox hides your history in places.sqlite. And a hundred places like it.

Shred by policy on a schedule, and keep a ledger that proves it happened.

Checks every laptop's cache and history trails against a written policy.

Turns a terminal recording into PNGs and tells you which seconds are worth one.

Turns a recorded terminal session into a GIF you can paste into a ticket.

Cut a nine-minute terminal recording to ninety seconds without re-recording it.

Finds credentials in terminal recordings before you share them. Misses one in three.

Finds the .tmp, .bak and Thumbs.db files quietly piling up in a folder tree.

Snapshot before you install, snapshot after you uninstall. The difference is the leftovers.

Cleanup policies saved in a file, plus a ledger of every file ever quarantined.

Where is the reclaimable space across all your machines, and which box is worst?

Find a file by name or by what's inside it, with no index to build first.

Index a tree once, then ask which of the hits are .go files under 100 KB.

Index your files once, then get results back with no disk scan at all.

Search every teammate's index at once and find out who else has the same file.

Turns a folder into one password-locked file, with a fingerprint for every file inside.

Look inside an archive someone sent you before you unpack it.

Shreds your originals only after proving the encrypted copy reads back byte for byte.

Split a big archive into volumes, then prove later which piece went bad.

Copies a tree, then re-reads every file off the disk and checks it byte for byte.

Offload a card, then hand the client a manifest proving every file arrived.

Moves files, then proves the copy landed intact before it deletes the original.

Copies one build to three shares at once and says which share came out bad.

Renumber a photo dump, or rename a whole folder by pattern. It shows you the plan first.

Rename in place with a real template language, and an undo that puts it all back.

Write the sorting rules once. Re-run it whenever Downloads gets messy again.

A spreadsheet says what happens to each file. FileDeck does all of it, or none.

A watchlist of hosts that stays quiet until something actually changes state.

Records a command's output with exact timings and replays it at real speed.

Shows what ssh will actually do with your config, and why.

One agreed TCP hop for the team, with a record of who used it and for how long.

Copy a folder's exact bytes now, so you can put one file back later.

Inventory a driver folder before and after an update, then diff the two.

Seal a driver folder's fingerprints, then prove months later that not one byte changed.

Snapshot a driver tree, then get the exact bytes back. Dry run unless you insist.

Save your morning set of tabs, apps and folders under one name. Open it in one command.

Your 12-pane trading layout won't fit the hotel laptop. This says what to give up, and why.

Works out where every window goes when today's screen isn't yesterday's.

Settles whose Ctrl+Shift+P it is across everyone's keybinding files.

One page describing this computer, honest about everything it cannot see.

Loads your machine for five minutes and shows whether it holds its speed.

Logs folder sizes on a schedule and shouts when one jumps more than 25% since last time.

Forty workstations, one sorted table, and the odd one out flagged for you.

Mirrors one folder onto another, and shows the plan before touching anything.

Push a folder to the machine across the room, over your own HTTP server.

Two-way folder sync that can tell your edit apart from the other side's.

One-way sync that keeps the old copy of every file it overwrote.

Fingerprint every file in a tree now, prove later that not one byte moved.

Check an ISO will boot your machine before you spend 20 minutes writing it.

Open an ISO and pull one file out of it. No mounting, no root, no libraries.

Catalogue a shared folder of ISOs and find out which ones are the same file.

Send a file to your phone by opening a web address. No cable, no app, no account.

Both phones got used since they last matched. This works out what belongs where.

Files phone photos by the date the shutter fired, not the date you copied them.

Move a phone's files onto the new handset and prove every byte arrived.

Port scanning and latency checks for one host, with no admin rights needed.

Probe the link every 30 seconds for a month, then write four lines about it.

A local proxy that counts, per site, exactly how many bytes crossed the wire.

Six offices, ten targets, one grid that names whose network is at fault.

How much faster is your machine with every core than with one?

Times one command thirty times over and tells you when it gets slower.

One benchmark score, plus the breakdown showing which part of the machine moved.

Benchmarks on a schedule and flags the day your machine got slower.

Timestamped snapshots you can browse, where unchanged files cost no extra disk.

Audits the backups you already have against the 3-2-1 rule, one file at a time.

Keeps yesterday's snapshots by the hour and last month's by the week.

Which backup jobs quietly stopped working, and how long ago they last succeeded.

Check, then install, then skip it next time. A recipe file that's safe to re-run.

Catches the unattend.xml typo that silently images 200 machines wrong.

Runs deployment steps in dependency order and won't start on a broken graph.

Hand-writes a FAT32 image, then reads it back with code that shares nothing with the writer.

Decode every photo in a folder and learn which ones are actually still good.

Carves photos out of a card image whose filesystem is already gone.

Scan years of photo folders in one run, and rescue JPEGs that lost their tail.

Explains why a video won't play, without a single line of codec code.

Writes 256 MB, fsyncs it, reads it back. Two numbers in MB/s.

Reads a disk image's partition table and checks whether it contradicts itself.

Benchmark several drives against each other, same settings for every one.

Times every block of a disk image and maps which ones are struggling.