FileDO - Know your storage before you trust it

Fake-Capacity Check • Speed Test • Duplicate Finder • Folder Compare • Wipe Free Space • Password-Protected Files • Virtual Disks

Test USB sticks and SD cards for fake capacity, check drive speed, find duplicate files and wipe free space to make recovery harder - on Windows, with a window and a command line. For anyone who bought a stick or card and wants to know it is real.

---

Quick Start

Most Common Tasks

# Check if USB/SD card is fake
filedo E: test del

# Test drive performance
filedo C: speed 100

# Wipe free space
filedo D: fill 1000 del

# Find and manage duplicate files
filedo C: check-duplicates
filedo D:\Photos cd old del

# Copy files with progress tracking
filedo folder C:\Source copy D:\Backup
filedo device E: copy F:\Archive
# Count the tree first for an exact time left (otherwise copying starts at the first file)
filedo folder C:\Source copy D:\Backup --precount

# Fast wipe folder contents
filedo folder C:\Temp wipe
filedo folder D:\Cache w

# Show device info
filedo C: info

Compare & Cleanup

compare <source> <target> --strict judges the trees: matching relative paths, sizes and modification times give Passed (exit 0); a difference gives Failed (exit 1); an incomplete comparison gives Not proven (exit 2). Add --by-hash to compare equal-size pairs by content instead of time. Plain compare still reports differences with Done (exit 0); --strict cannot be combined with deletion. Both modes publish onlyInSource, onlyInTarget, differentFiles, sameFiles, totalSource and totalTarget in the --events result. For check, --max-files N reads at most N files (0 means unlimited); --resume ends Passed (exit 0) when every eligible file has an unchanged entry in the good list, with checkedFiles = 0 and skippedGoodFiles showing the earlier proof.

# Compare two folders and show summary + save report
filedo compare D:\Data E:\Backup

# Compare and delete (permanent, no confirmation)
filedo cmp D:\Data E:\Backup del source  # delete in Source if also exists in Target
filedo cmp D:\Data E:\Backup del target  # delete in Target if also exists in Source
filedo cmp D:\Data E:\Backup del old     # delete older side (by mtime), equal time: skip
filedo cmp D:\Data E:\Backup del new     # delete newer side (by mtime), equal time: skip
filedo cmp D:\Data E:\Backup del small   # delete smaller side, equal size: skip
filedo cmp D:\Data E:\Backup del big     # delete bigger side, equal size: skip

# Optional side qualifier (only apply when that side matches)
filedo cmp D:\Data E:\Backup del small source  # only if smaller is on Source
filedo cmp D:\Data E:\Backup del big target    # only if bigger is on Target
filedo cmp D:\Data E:\Backup del old target    # only if older is on Target
filedo cmp D:\Data E:\Backup del new source    # only if newer is on Source
filedo cmp D:\Data E:\Backup del source --yes  # no question (scripts); the checks still apply

Notes: matching by relative path; del source and del target delete a pair only when size and modification time match (--by-hash: equal content; --allow-mismatch: any pair) - a pair that differs is reported and kept; two spellings of one folder, or a folder inside the other, are refused; every delete rule first lists how many files it will delete and by which mode and asks (y/N) - --yes (or -y) skips the question, never a check, and with no answer (a closed stdin, a script) nothing is deleted and the run ends with exit 2; optional side qualifier for old/new/small/big; mtime used for old/new; Windows compare is case-insensitive and deletes use each file's real name; an entry that cannot be read or deleted ends the run with exit 2; logs: compare_report_.log, delete_report__.log.

Health CHECK (fast read check)

# Check folder by reading files; mark as damaged if initial read delay > 2.0s
filedo check F:\Mov

• The damaged and good lists name a file by path, size, modification time and the volume and file it was recorded on: a changed file, or a copy at the same path on another card at the same drive letter, is read again. Entries written by older versions carry no volume and are not trusted
• An online-only file (a OneDrive or other cloud placeholder, or an offline file) is never opened - not in a sweep and not when it is the one file you check - so nothing is downloaded. It is counted as not-read(online-only), is never recorded as damaged, and makes the run "could not verify" (exit 2) unless a damaged file was found (exit 1)

CHECK: CLI flags (flags override env)

Flags mirror FILEDO_CHECK_* environment variables and have precedence. Use them after check <path>.

• General
  • --threshold <sec> (FILEDO_CHECK_THRESHOLD_SECONDS)
  • --warmup <sec> (FILEDO_CHECK_WARMUP_SECONDS)
  • --warmup-idle <sec> (FILEDO_CHECK_WARMUP_IDLE_RESET_SECONDS)
  • --workers <int> (FILEDO_CHECK_WORKERS)
  • --buf-kb <int> (FILEDO_CHECK_BUF_KB)
  • --mode quick|balanced|deep (FILEDO_CHECK_MODE)
  • --balanced-min-mb <int> (FILEDO_CHECK_BALANCED_MIN_MB)
  • --min-mb <float> / --max-mb <float> (FILEDO_CHECK_MIN_MB / FILEDO_CHECK_MAX_MB)
  • --include-ext ".jpg,.png" / --exclude-ext ".bak,.tmp" (FILEDO_CHECK_INCLUDE_EXT / FILEDO_CHECK_EXCLUDE_EXT)
• Limits
  • --max-files <int> (FILEDO_CHECK_MAX_FILES)
  • --max-seconds <float> (FILEDO_CHECK_MAX_DURATION_SEC)
  • --precount / --no-precount (FILEDO_CHECK_PRECOUNT)
• Behavior & output
  • --dry-run (FILEDO_CHECK_DRYRUN)
  • --verbose (FILEDO_CHECK_VERBOSE)
  • --quiet (FILEDO_CHECK_QUIET)
  • --resume (FILEDO_CHECK_RESUME) - carry on: skip the files an earlier run already read cleanly (the good list)
• Reporting
  • --report csv|json (FILEDO_CHECK_REPORT)
  • --report-file <path> (FILEDO_CHECK_REPORT_FILE)
• Good files cache
  • --good-list <path> (FILEDO_CHECK_GOODLIST)
• HDD‑friendly I/O (single-reader + adaptive throttling)
  • --single-reader auto|on|off (FILEDO_CHECK_SINGLE_READER)
  • --ewma-alpha <float> (FILEDO_CHECK_EWMA_ALPHA)
  • --ewma-high-frac <float> (FILEDO_CHECK_EWMA_HIGH_FRAC)
  • --ewma-low-frac <float> (FILEDO_CHECK_EWMA_LOW_FRAC)
  • --max-sleep-ms <int> (FILEDO_CHECK_MAX_SLEEP_MS)
  • --sleep-step-ms <int> (FILEDO_CHECK_SLEEP_STEP_MS)
  • --hdd-sleep-ms <int> (FILEDO_CHECK_HDD_SLEEP_MS) - a fixed pause after each file, per reader

Examples:

# Balanced mode, worker override, ETA precount
filedo check D:\Data --mode balanced --workers 6 --threshold 1.8 --precount

# Force single-reader for HDD/USB with adaptive throttling
filedo check F:\Photos --single-reader on --ewma-alpha 0.2 --max-sleep-ms 250

# Filter by extensions, cap files, save CSV report
filedo check D:\Media --include-ext .jpg,.png --max-files 1000 --report csv --report-file D:\rep.csv

# Use custom good files cache list and quiet output
filedo check D:\Data --good-list D:\check_files.list --quiet

• One-time warm-up allowance up to 10.0s before the first read (spin-up)
• The damaged and good lists live in %LOCALAPPDATA%\FileDO\state (never beside your files) and name each file by path, size and modification time, so a changed file is read again; copy keeps its own skip list
• A file already on the damaged list is reported again without being read (exit 1); a locked or unreadable file or folder is could not verify (exit 2), never damaged; parallel workers; Ctrl+C supported

Installation

Option 1 - winget (recommended)

winget install SerZhyAle.FileDO
# short form (works once Microsoft indexes the moniker):
winget install filedo

This installs the CLI tools (filedo, filedo_check, filedo_fill, filedo_test) plus the filedo_win GUI (a window with a page per job), and adds them all to your PATH. To upgrade later:

winget upgrade SerZhyAle.FileDO

To uninstall:

winget uninstall SerZhyAle.FileDO

Also available in the Microsoft Store - the same tools, installed and updated by the Store.

Option 2 - Installer (setup EXE)

Download FileDO-<version>-setup.exe from Releases and run it. This is the option that makes FileDO an ordinary Windows program rather than a folder of executables:

• installs the binaries into C:\Program Files\FileDO and puts filedo on the system PATH;
• creates a Start menu entry and a desktop icon for the FileDO window (filedo_win.exe), and a second Start menu entry, FileDO Disk Manager, that opens the Disk manager straight (filedo_win.exe --disks);
• registers the Explorer integration: a File DO.. group in the right-click menu of every file - Secure (keeping, deleting or wiping the original, or under a random name), Unsecure (optionally deleting the container or starting the restored file), Wipe this file, Check this file, Info - plus the .fd-sec document type with its own icon, whose double-click is exactly the Unsecure-and-start entry: a console asks for the password there, restores the original under its true name into %LOCALAPPDATA%\FileDO\reveal - readable by this account and the system only - hands it to whatever program owns its real extension, and takes that copy away again when the console window closes. On Windows 11 the group lives under Show more options;
• registers the .fdd disk container type (feature Disk container files (.fdd)): its icon, a double-click that opens the FileDO window and mounts the virtual disk, and Mount read-only and Unmount in the right-click menu - see Virtual Disks.

The installer is not code-signed, so on first run Windows may show Windows protected your PC and then ask for administrator permission. Compare the SHA256 (the .sha256 file published next to the download; certutil -hashfile FileDO-<version>-setup.exe SHA256), then choose More info and Run anyway. Why the warning appears, what the administrator prompt is used for, and what FileDO never does: Windows warned you about FileDO.

The last three are features you can deselect on the installer's "Choose what to install" page, and turn on or off later with Change in Apps & features. For an unattended rollout:

# everything, no questions asked
FileDO-<version>-setup.exe /quiet
# ..with a log, if it has to be explained afterwards
FileDO-<version>-setup.exe /quiet /log install.log
# remove it again
FileDO-<version>-setup.exe /uninstall

The same release also publishes the bare FileDO-<version>-windows-x64.msi - the setup EXE carries exactly that file inside it - for deployment tools that want the package and the feature names directly:

msiexec /i FileDO-<version>-windows-x64.msi /qn ADDLOCAL=Main,ExplorerIntegration,DiskContainerIntegration,DesktopShortcut
msiexec /i FileDO-<version>-windows-x64.msi /qn ADDLOCAL=Main   # no Explorer entries, no .fdd type, no desktop icon

Uninstalling removes everything the installer wrote, the registry entries included.

Option 3 - Microsoft Store (MSIX)

One package, two entries: a clickable FileDO tile - a GUI with a page per job, whose Command page builds and runs any command - and the filedo command exposed on PATH for any terminal. Best when you want the graphical window and the CLI together. The Store build does not carry the Explorer entries: a packaged build can only get them through a signed shell handler, which is separate work. It does claim the .fd-sec file type: a double-click on a container opens the FileDO window on its Open a secret file page with that container already chosen, and the password is asked there. It claims the .fdd type too, but the Store build cannot mount a virtual disk: a double-click opens the FileDO window on that container, where it can be read, verified and exported - see Virtual Disks.

Option 4 - Manual download

1. Download: Grab the latest FileDO-<version>-windows-x64.zip from Releases
2. Extract anywhere (e.g. C:\Tools\FileDO)
3. Optional: add the folder to your PATH so you can call filedo from any directory
4. GUI: the zip includes filedo_win.exe - run it next to filedo.exe for the graphical window (a page per job, plus a Command page)
5. Run: execute from command line or GUI

Explorer integration without an installer

winget, the portable zip and go install never run an installer, so they register nothing at all. Ask for the same group and document type yourself, and take them back the same way:

filedo fdsec register              # for this user
filedo fdsec register -all-users   # machine-wide (needs an elevated console)
filedo fdsec unregister            # removes exactly what was written

FileDO removes only what it marked as its own: a document type that meanwhile belongs to another program is left alone, and whoever owned .fd-sec before FileDO did gets it back. A machine that already has the installer's registration is left alone too - the per-user copy would show every entry twice.

Option 5 - Build from source

git clone https://github.com/SerZhyAle/FileDO.git
cd FileDO
.\build.ps1   # or build.bat

Requires Go 1.24+. Builds all four executables into exe_to_download/.

Build only the main CLI:

go build -o filedo.exe .\cmd\filedo

---

Core Operations

Device Testing # Information filedo C: info filedo D: short # Fake capacity detection filedo E: test filedo F: test del # Performance testing filedo C: speed 100 filedo D: speed max

File & Folder Operations # Folder analysis filedo C:\temp info filedo . short # Performance testing filedo C:\data speed 100 filedo folder . speed max # Network operations filedo \\server\share test filedo network \\nas\backup speed 100 # Batch operations filedo from commands.txt filedo batch script.lst # Cleanup filedo C:\temp clean

---

Secret Files (.fd-sec)

One file - or one folder, its whole tree - goes into one container, behind a password, and comes back out - from the command line, from the Explorer menu, or from the Protect pages in the window. The original's true name, its real size and its timestamps are sealed inside, and for a folder every entry's path, size and timestamps too; the container itself reveals only its own size, its visible name, and its timestamps (rename writes a nameless blob). Nothing on disk tells a folder container from a file one.

# Pack it (asks for the password twice, with no echo)
filedo report.docx secure

# Pack it and get rid of the original - the recoverable way, and the harder one
filedo report.docx secure del p:hunter2
filedo report.docx secure wipe p:hunter2

# Get it back under its sealed name, or into this folder
filedo report.fd-sec unsecure
filedo report.fd-sec unsecure here

# Open it in the program it belongs to, without unpacking it
filedo report.fd-sec reveal

# A folder packs to one file the same way, and comes back as the whole tree
filedo "Tax 2025" secure
filedo "Tax 2025.fd-sec" unsecure to D:\Restored

# The quiet suite: a harder key, no trace of alignment - but only FileDO opens it
filedo report.docx secure suite2

A folder is packed whole - empty subfolders included - and restored whole: into a fresh temporary folder first, moved into place only after every file has verified, and never into or over a folder that already exists (-y restores under a suffixed name instead). A folder holding a junction, a symbolic link or a mount point is refused rather than followed. del and wipe remove the original tree only after the container has been read back, and only if the folder has not changed since it was packed. reveal opens one file, so it refuses a folder container and points at unsecure.

suite2 seals one file (not a folder) with suite 2 instead of the default suite 1: a pepper-folded Argon2id key at 256 MiB and XChaCha20-Poly1305 in 64 KiB frames, so the file is noise from its first byte, without even the 512-byte cluster length pattern suite 1 has. It keeps the true name, the real size and the time of encryption, but not the original's own timestamps - the restored file gets the current time. Only FileDO from this version on opens it: older FileDO builds report it as damaged or as a wrong password, and FastMediaSorter apps cannot open it, so suite 1 stays the default. unsecure, reveal, fdsec info and fdsec verify find the suite themselves; nothing else changes, and an empty password is still obfuscation only.

Five things said plainly, because a security feature that oversells itself is worse than none:

• An empty password is obfuscation only - no secrecy. It is accepted, and every surface that takes a password says what it is worth while it is being typed.
• wipe lowers the odds of recovery and promises nothing. On SSDs and on copy-on-write or journaled file systems, overwriting a file in place does not guarantee the old blocks are gone.
• wipe never overwrites a file that has another hard link. The overwrite reaches every name of the file, so the original is kept and the run says so; remove the extra links first, or use del.
• A revealed copy lives in %LOCALAPPDATA%\FileDO\reveal, read-only, readable by this account and the system only. It goes when you say so, or when the program that opened it lets go of it.
• unsecure start - the double-click - puts its copy in that same protected folder, not beside the container, and removes it when the console window closes. That copy is your own file rather than a read-only view, and if the program still has it open when the window closes, the next FileDO start sweeps it. Plain unsecure is the one that brings the file back for good.
• A power loss leaves that copy on disk until the next FileDO start, which sweeps it. Nothing else will.

There is no recovery key: a forgotten password is a lost file. The original is kept unless you ask for it to go, and nothing is removed before the container has been written, read back and verified. Executables and scripts are never launched out of a container - they are extracted and their location shown.

In the window, the Protect group carries the same three operations as pages: the password is masked, typed twice when packing, and handed to filedo.exe out of sight - it reaches no command line, no run report and no history file. A double-click on a .fd-sec does not open that window; it runs Unsecure and start on the console, exactly as the Explorer menu entry of the same name does.

---

Virtual Disks (.fdd)

A container is one ordinary .fdd file that holds a whole volume. Mounted, it is a drive letter like any other; unmounted, it is a file you can copy, back up, or read with FileDO alone, without mounting it. The format is published in full as the FDD-FORMAT contract, and what a program that reads or writes one must do as FDD-BEHAVIOUR, so the data does not depend on FileDO staying around.

# Create a 20 GB container (plain: the file grows as data is written), then mount it
filedo vd new work.fdd 20G
filedo work.fdd mount

# Save, mark it closed cleanly, detach
filedo X: unmount

# An encrypted one: vault always asks for a password (twice)
filedo vd new private.fdd 5G vault

# Read it without mounting - no administrator rights, nothing written to the container
filedo work.fdd info
filedo work.fdd verify
filedo work.fdd export D:\work.vhd vhd

# Change it while it is not mounted
filedo work.fdd grow 40G
filedo private.fdd pass
filedo private.fdd clone open-copy.fdd nopass

Four profiles for vd new: plain grows as it fills, fast reserves the whole size now, ram keeps the volume in memory while it is mounted and saves it to the file every few seconds (a crash loses what came after the last save), and vault is always encrypted. seal writes a copy that is read-only for good, clone a writable copy with its own identity, compact gives the file's unused space back. format erases the volume (fs ntfs or fs exfat) and destroy removes the container file (wipe overwrites it first): both ask first, and both refuse a mounted container - no flag skips that check. chkdsk scans the volume inside an unmounted container and writes nothing, and chkdsk fix runs chkdsk /f on it - the repair for a container that was not closed cleanly - and asks first. vd add work.fdd as work gives it a short name, vd list and vd status show what is known and what is mounted, and vd auto work logon mounts an obfuscated container when you sign in. vd guard on adds the shutdown guard: when your session ends - a shutdown, a restart or a sign-out, never sleep - it saves ram disks first and then unmounts every mounted container, so each one is closed cleanly; vd guard status shows its last run. A .vhd, .vhdx or .iso mounts through Windows' own image support: filedo disk.vhdx mount.

Two words, two different promises, and FileDO never swaps them:

• Without a password a container is obfuscated, not encrypted. Obfuscation keeps the volume from a casual look and from tools that scan for disk images - and from nobody who has the file and FileDO. info says which of the two a container is.
• With a password it is encrypted: the file cannot be read without it. There is no recovery - a forgotten password is a lost container. pass changes the password without rewriting the data, so copies of the file made earlier still open with the old one.
• A password is never removed in place. An empty new password is refused; clone <new.fdd> nopass writes an obfuscated copy instead, and the encrypted original stays as it was.
• Encryption protects the file, not a mounted volume. While it is mounted, every program you run can read it, like any other drive. An export of an encrypted container is not encrypted either, and ram with a password may let Windows page unencrypted data out to the page file.
• verify reads, it does not prove. It reads the headers, the map and every allocated cluster and reports damage (exit 4), but format 1.0 keeps no checksums of the data, so the data is read, not verified.

What the platform needs, said plainly:

• Windows only. The drive letter comes from the iSCSI initiator built into Windows, talking to a block server inside filedo.exe that listens on 127.0.0.1 only - nothing leaves this computer, and the container never goes to any network - unless you choose to share it (below).
• Mounting needs administrator rights. mount, unmount, save, format, chkdsk and vd auto ask Windows for administrator consent for the initiator step; the password never goes there, and the block server itself never runs elevated. A batch never raises that prompt - run it from an elevated console. When the Microsoft iSCSI Initiator service cannot be used, the run ends with exit 7 and nothing is mounted.
• The Microsoft Store build cannot mount. A packaged app can neither configure the iSCSI initiator nor ask for administrator rights, so there mount, unmount, save, format, chkdsk, vd auto, vd guard and vd register end with exit 6. info, verify, export, compact, grow, seal, clone, pass, destroy, vd new, vd list, vd status, vd add and vd forget work there too; to mount, use the setup or the portable build from GitHub.
• A mount outlives the window. Closing the FileDO window leaves the drive and its server in place, and a new window lists them again; unmount in the Disk manager, on the Disks pages, or with filedo X: unmount.

In the Disk Manager, select a registered file-backed disk and choose Share with Fast Media Sorter & Sharing.. in its detail pane or More menu (Ctrl+Shift+S). Start that program's Share Manager first. If its worker cannot be reached, the dialog offers retry and the installation page; an unavailable worker does not prove the program is absent. Enable the optional FileDO disk component if needed. Its desktop installer is unsigned. Access is read and write by default; tick Read-only access to change that, and sealed disks stay read-only. Enter the folder name and optionally open it for paired devices. A disk already mounted by FileDO is disconnected cleanly after confirmation, saving RAM first through the normal unmount. If FileDO automatic mounting is enabled, explicitly agree to disable it; a manual keep watcher ends with the unmount. FMS autostart remains a separate opt-in. Close shared disk keeps registration; Stop sharing removes it and its saved FMS autostart key. If a step fails, completed steps remain: refresh, retry the remaining action, or stop sharing before explicitly restoring local mounting and its prior automatic policy. Pair clients through Share Manager. This publishes files over SFTP, not a Windows SMB share. Session sharing requires sign-in; a service host stays available without sign-in. Partition disks and external-worker controls from the unverified Store build are unavailable here; use the desktop build for this workflow. The step-by-step page - prerequisites, every dialog and recovery - is Sharing FileDO disks with Fast Media Sorter.

Sharing a disk with Fast Media Sorter for Windows (optional). If Fast Media Sorter for Windows is installed, vd share work.fdd on offers a disk to the phones and tablets you paired with it, as one more folder; vd open, vd close and vd autostart open it for them, close it, and open it again after a restart. FileDO opens no network connection for this - it talks to that program over a local pipe, and that program serves the files. An encrypted disk is unlocked here, on this PC, never from the phone; while it is open, every paired device can read its files, and vd autostart keeps its password on this PC, protected for that program, until you turn autostart off, stop sharing or change the password. A shared disk is held by that program, so mount refuses it while it does; vd status says who holds it. Only the Server edition of Fast Media Sorter for Windows keeps shared disks available with nobody signed in.

Exit codes of one container command: 0 done, 2 usage, 3 wrong credential, 4 damaged, 5 I/O, 6 unsupported, 7 transport unavailable, 8 busy (mounted, open or locked). A batch keeps 0/1/2.

In Explorer, the setup EXE's Disk container files (.fdd) feature (DiskContainerIntegration) gives .fdd its icon and three entries that open the FileDO window. A double-click mounts: a clean obfuscated container at once; an encrypted one asks for its password in the window, never on a command line; one that was not closed cleanly says so first, with the time of its last complete save, and waits; one already mounted opens its drive. The right-click menu adds Mount read-only and Unmount (on Windows 11 under Show more options). Without the installer, filedo vd register (add -all-users for the whole machine) writes the same and filedo vd unregister takes it back. In the window, the Disks group has a page for each operation, and it words both protections exactly as the console does.

The Disk manager is a second window of the same filedo_win.exe - not a new program - with one row per virtual disk: the disks in your list, the ones mounted now, and the VHD, VHDX or ISO images FileDO mounted. Each row shows its state in words beside a glyph (Mounted, Mounted, read-only, Mounted, 180 MiB not saved for a ram disk, Server gone - volume offline, Image mounted, File missing, A different container is at this path, Unreadable, Not closed cleanly, Not mounted), and the list keeps itself true without a manual refresh. Around it sit a toolbar (New disk.., Add.., Mount, Unmount, Open, Save, More actions, Refresh, Help, Main window), a filter row and a detail pane with the buttons that apply; a button that cannot be used says why in its tooltip and in the pane, and the Microsoft Store build, which can never mount, hides the mount controls instead of greying them. A double-click or Enter mounts a disk at rest and opens the drive of a mounted one - it never unmounts; drag .fdd files onto the list to add them, or a .vhd, .vhdx or .iso to mount an image after one confirmation. New disk.. first asks where the disk keeps its data: File on a drive.. opens the Create a disk page in the main window, Partition on free disk space.. opens the manager's own partition dialog - a map of each GPT disk's free space, the size, profile, label and name (the Microsoft Store build offers the file only). For a file disk, Export, Compact, Grow, Seal copy, Clone, Change password, Format and Destroy open their job page in the main window with the container chosen; Format and Destroy keep their typed confirmation there. A partition disk's row says Partition not connected or Partition changed when it is not where it was registered, offers Image to file.. to copy it into a new .fdd file, and is deleted in the manager itself: Destroy asks for its name typed and can overwrite the partition first. Adopt partition.. (under More actions, or a right-click on empty space) lists the FileDO partitions on this computer's disks that are not in the list and adds the chosen one under a name; the Store build hides Image to file and Adopt.

Open it from the FileDO Disk Manager Start menu entry the installer adds (it runs filedo_win.exe --disks), from the Disk manager button at the top right of the FileDO window or the first row of its Disks group (Ctrl+Shift+D too), or with filedo_win.exe --disks; its Main window button brings the FileDO window forward. F1 opens its help - what a row says, the keyboard table, links. The first time the manager opens, a welcome explains what a virtual disk is and says: Obfuscated, not encrypted: anyone with this file and FileDO can read it. It opens without a password. Encrypted: it opens only with its password. It adds that Windows asks for administrator consent at every mount and unmount - and, for a partition disk, at every read too - and it offers Create my first disk.., Add a .fdd file I already have.., Read the guide on the website and Not now. The keyboard table and pictures are in the virtual disks guide. Closing the manager never unmounts a disk.

Partition disks

A virtual disk can also live in a partition instead of a file. FileDO creates a new GPT partition in the unallocated space of a disk and fills it, whole, with one container; nothing outside that free space is changed - FileDO never converts, resizes or writes into an existing partition. GPT disks only: MBR, dynamic, Storage Spaces, iSCSI, removable and USB disks are refused, and vd disks names the reason for each. What you gain is a disk that no host file system holds, which Windows does not give a letter or offer to format, with its space reserved; what you do not gain is speed.

# Every disk, its partitions and its free space - each extent usable or not, and why (no administrator rights)
filedo vd disks

# A partition disk across one whole free extent (the create line vd disks prints), named data
filedo vd new part disk:{GPT-GUID} size max at <offset> as data
filedo vd mount data

# Copy it into an ordinary .fdd file, which reads without administrator rights
filedo vd image data to D:\data.fdd

# Register a FileDO partition this PC does not know (a disk moved here from another PC)
filedo vd adopt fdpart:{GUID} as data

# Delete the partition: type the disk's name to confirm; the space returns to unallocated
filedo vd destroy data

<disk> is disk:{GUID} or the number vd disks printed; size is max or a size such as 40G (rounded down to 1 MiB, at least 64 MiB). The default profile is fast; plain, vault and ram work too. The first mount formats the volume NTFS. A partition disk is addressed by its name or its locator fdpart:{GUID}, never by a path; mount, unmount, save, info, verify, export, pass, seal, clone, vd auto and the shutdown guard work as they do on a file, compact and grow do not (its size is fixed), and sharing it through Fast Media Sorter is refused for now. vd forget drops the name and leaves the partition on its disk; vd destroy .. wipe overwrites the partition before deleting it. A refused disk ends with exit 6, a declined consent with exit 7, and a layout that changed since it was listed with exit 5 - with nothing changed.

• Administrator consent for every read, not only to mount. A partition cannot be opened without administrator rights, so info, verify, export, pass, seal, clone and vd image ask Windows for consent too. vd image removes that need: the file it writes is an ordinary .fdd that every read path opens without administrator rights.
• Not faster than a file disk. Measured end to end on an NVMe drive, a partition disk was slower than a .fdd file on NTFS. Choose it for the fixed, separate space, not for speed.
• fast overwrites the free space; plain and vault do not. Whatever the free space held before stays in the unused clusters of a plain or vault partition disk until the volume writes over it; fast overwrites the whole partition when it is created.
• Windows' Disk Management (diskmgmt.msc) still shows the partition and can delete it. Deleting it there deletes the disk inside, with no question about its contents. FileDO's own vd destroy is the safe way: it refuses a mounted disk, asks you to type the disk's name, and deletes only a partition it has proven to be FileDO's.
• Partition disks are not available in the Microsoft Store version. There vd disks says so and every partition command ends with exit 6; use the setup or the portable build from GitHub.

---

Key Features

Fake Capacity Detection

• 100-file verification with 1% capacity each
• Random position verification - each file checked at unique random positions every time
• Anti-sophisticated fake protection - defeats controllers that preserve predictable data positions
• Readable patterns - uses ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 for easy corruption detection
• Fast raw probe (probe) - writes 32 markers via direct LBA access, completes in ~1 min (requires Admin)

Performance Testing

• Real-world read/write speed measurement
• Memory-optimized streaming for large files
• Progress tracking with ETA calculations
• Configurable file sizes (1MB to 10GB)

Duplicate File Management

• Multiple selection modes (oldest/newest by creation time, alphabetical)
• Flexible actions (delete/move duplicates) - each file is asked about unless -y (or --yes) is given, and a run with no console and no -y is refused before it touches anything
• SHA-256 grouping, and a byte-for-byte comparison with the kept copy right before every delete or move - a hash, cached or fresh, is never the only proof; a move never replaces a file, across drives too
• Hard links and a second name of the same file never count as duplicates; a drive or share root, Windows, Program Files and the system TEMP ask for a typed confirmation even with -y, and a scan skips Windows and Program Files unless it starts inside them
• Hash caching for faster repeated scans - the cache (hash_cache.json) lives in %LOCALAPPDATA%\FileDO\state\, and a cached hash is reused only while the file's size, modification time, file ID and change time still match, so an edited file never counts as a duplicate
• Support for saving/loading duplicate lists

Copy Operations

• Starts at the first file - a plain copy walks the tree once and copies as it goes; add --precount to count the tree first for exact totals and an ETA from the start
• Progress tracking with detailed ETA calculations
• Timeout protection for corrupted/slow filesystems (3-second timeout)
• Preserves metadata - file permissions and timestamps
• Robust error handling - continues copying even if individual files fail
• Universal support - works with devices, folders, network shares, and individual files

Wipe Operations

• Contents only - every entry inside the folder is deleted; the folder itself stays, with its access list, owner, encryption, compression and attributes
• Honest result - an entry that cannot be deleted (in use, locked, access denied) is listed and the run exits 2
• Universal compatibility - supports devices (device D: wipe always means D:\), folders, and network shares
• Confirmation guardrails - wipe always asks Type WIPE to continue before deleting. Add --force (or -y) to skip the prompt in automation. Dangerous targets - drive/share roots in any spelling, and the TEMP, profile, Windows, Program Files and FileDO folders together with every folder above them - always require interactive confirmation and are never bypassed by --force. A junction or symlink target is refused outright: wipe the folder it points to by its own path.

Security Features

• Wipe free space and single files to make recovery harder (no guarantee on SSDs or copy-on-write disks)
• Fill operations with parallel writing and automatic cleanup
• Secret files: one file or one whole folder per .fd-sec container behind a password, with a bounded plaintext window when one is opened - see Secret Files for what each choice does and does not promise
• Batch processing for multiple targets
• Comprehensive operation history, with credentials redacted before anything is written to it
• Context-aware interruption - a graceful cancellation that still cleans up after itself

---

Command Reference

Target Types (Auto-detected)

Pattern	Type	Example
C:, D:	Device	filedo C: test
C:\folder	Folder	filedo C:\temp speed 100
\\server\share	Network	filedo \\nas\backup test
file.txt	File	filedo document.pdf info

Operations

Command	Purpose	Example
info	Show detailed information	filedo C: info
short	Brief summary	filedo D: short
test	Fake capacity detection	filedo E: test del
test N	Test with N files (default 100)	filedo D: test 1000
probe	Fast raw-I/O probe (~1 min, needs Admin)	filedo D: probe
speed <size>	Performance testing	filedo C: speed 500
fill [size]	Fill with test data	filedo D: fill 1000
clean	Remove test files	filedo C: clean
check-duplicates	Find duplicate files	filedo C: check-duplicates
cd [mode] [action]	Check duplicates (short)	filedo D:\Photos cd old del -y
copy <target>	Copy files with progress	filedo C: copy D:\backup
wipe	Delete everything inside a folder	filedo folder C:\temp wipe
from <file>	Execute batch commands	filedo from script.txt
hist	Show operation history	filedo hist

Fill Command Shortcuts

Command	Equivalent	Purpose
filedo D: fill	filedo D: fill 100	Fill with 100MB default
filedo D: f	filedo D: fill 100	Short form
filedo D: f del	filedo D: fill 100 del	With auto-delete
filedo D: f d	filedo D: fill 100 delete	Short auto-delete

Copy & Wipe Shortcuts

Command	Equivalent	Purpose
filedo copy A B	filedo folder A copy B	Generic copy command
filedo A cp B	filedo A copy B	Short copy form
filedo A w	filedo A wipe	Short wipe form

Modifiers

Flag	Purpose	Example
del	Auto-delete after operation	filedo E: test del
nodel	Keep test files	filedo C: speed 100 nodel
short	Brief output only	filedo D: speed 100 short
max	Maximum size (10GB)	filedo C: speed max
old	Keep newest as original (for cd)	filedo D:\Photos cd old del
new	Keep oldest as original (for cd)	filedo E:\Photos cd new move F:\Dups
abc	Keep alphabetically last (for cd)	filedo C: cd abc
xyz	Keep alphabetically first (for cd)	filedo C: cd xyz list dups.lst
-y, --yes	Delete/move duplicates without asking per file (for cd; required with no console)	filedo D:\Photos cd old del -y

---

GUI Application

FileDO GUI (filedo_win.exe) - a VB.NET Windows Forms shell: a rail of jobs on the left and one numbered page per job - what to work on, which parameters, then check and run - plus a Command page, the expert builder that can assemble any FileDO command and run it. What the window holds:

• 5-language UI (EN / RU / UA / DE / FR, remembered) with an inline help panel: what the selected operation and flags do, the expected result, and an example for the target
• Target selection (device / folder / network / file); for device the path becomes a drive-letter picker, and choosing the system drive explains the %TEMP%\FileDO_Operations redirect
• Every operation on the Command page, in one dropdown: info, speed, test, fill, clean, cd (duplicates), the full copy family (copy / fastcopy / synccopy / balanced / maxcopy / smartcopy / safecopy), wipe, compare, check, probe, recover, from, hist
• Source + destination fields for copy and compare
• Context-aware flags (max, del, nodel, short, hist, --force for wipe) and duplicate/compare delete rules
• A page per job in the default window - capacity, speed, info, damaged-files check, raw probe, recover, duplicates, compare, clean, copy, fill, wipe and the three secret-file jobs - each carrying every option the CLI takes for it, including all twenty-nine check flags
• Live command preview in an editable box on the Command page - tweak by hand for anything the builder doesn't cover
• Browse buttons for paths, Copy command to clipboard, and RUN in a console window
• Finds filedo.exe next to itself or on PATH (works under the Store package and portable zip alike)
• About page: build stamp, author, and links to the site, the source, the issue tracker, the privacy page and the author's other tools
• Send logs to the author - the one button on that page packs the FileDO logs found on this machine into a single zip, opens the folder with it selected, puts its path on the clipboard, and opens your default mail program already addressed and titled. You see the zip first, and nothing is sent until you press Send yourself

filedo_win              # if installed via winget / Store (on PATH)
filedo_win.exe          # next to filedo.exe in the portable zip

The Protect pages handle .fd-sec secret files - make a file secret, get the original back, or open it without unpacking. The password is masked and never enters a command line. Handing the window a .fd-sec path directly opens it on that container's page (filedo_win.exe C:\a\x.fd-sec); a double-click in Explorer does not go through the window at all - it runs Unsecure and start on the console, as described above. History, Settings and About have pages of their own; the older command-builder window is retired, and a hand-written command line goes on the Command page. The Disk manager - a second window for the virtual disks, opened with Ctrl+Shift+D, the button at the top right or filedo_win.exe --disks - is described under Virtual Disks.

Ships everywhere: the GUI is included in the winget package, the portable zip, the MSI, and is the clickable tile of the Microsoft Store (MSIX) package.

---

Advanced Features

Batch Processing

Create commands.txt:

# Multiple device check
device C: info
device D: test del
device E: speed 100
folder C:\temp clean

Run: filedo from commands.txt

Exit codes (all non-container verbs): 0 passed or done, 1 ran and found a defect, 2 could not be verified.

History Tracking

filedo hist              # Show last 10 operations
filedo history           # Show command history
# History automatically logged for all operations

Interruption Support

# All long-running operations support Ctrl+C interruption
# Graceful cancellation with cleanup
# Context-aware interruption at optimal points

Network Operations

# SMB shares and network drives
filedo \\server\backup speed 100
filedo \\nas\storage test del
filedo network \\pc\share info

---

Important Notes

Fake Capacity Detection: Creates 100 files (1% capacity each) with context-aware interruption support. Uses modern random verification patterns and optimized buffer management for reliable detection.

Enhanced Interruption: All long-running operations support Ctrl+C graceful cancellation with automatic cleanup. Context-aware interruption checks at optimal points for immediate responsiveness.

Wiping: fill <size> del overwrites free space with optimized buffer management and context-aware writing to make recovery harder.

Test Files: Creates FILL_*.tmp and speedtest_*.txt files. clean removes the ones FileDO wrote - its own names and its own content, nothing else - after listing them and asking; --yes answers the question.

Shared packages: fileduplicates (duplicate detection), fsx (path identity and atomic, non-replacing writes) and statedir (the runtime state root, %LOCALAPPDATA%\FileDO\state).

CHECK Command: Marks a file as damaged if initial read delay exceeds 2.0s. Allows a one-time warm-up up to 10.0s. Records damaged files at once in its own list under %LOCALAPPDATA%\FileDO\state and reports them again on the next sweep without re-reading them. No damaged_files.log.

---

Examples by Use Case

Verify USB/SD Card Authenticity

# Quick test with cleanup
filedo E: test del

# Detailed test, keep files for analysis  
filedo F: test

# Check drive info first
filedo E: info

Performance Benchmarking

# Quick 100MB test
filedo C: speed 100 short

# Maximum performance test (10GB)
filedo D: speed max

# Network speed test
filedo \\server\backup speed 500

Wiping

# Fill 5GB, then delete the test files
filedo C: fill 5000 del

# Clean existing test files
filedo D: clean

# Before disposing drive
filedo E: fill max del

Find & Manage Duplicates

# Find duplicates in current directory
filedo . check-duplicates

# Find and delete older duplicates (asks before each file)
filedo D:\Photos cd old del

# The same without a question per file
filedo D:\Photos cd old del -y

# Find and move newer duplicates to backup
filedo E:\Photos cd new move E:\Backup

# Save duplicates list for later processing
filedo D: cd list duplicates.lst

# Process saved list with specific action
filedo cd from list duplicates.lst xyz del

---

Technical Details

Architecture

• Modular Design: Separated into specialized packages for better maintainability
• Context-Aware Operations: All long-running operations support graceful cancellation
• Unified Interface: Common Tester interface for all storage types
• Memory Optimization: Streaming operations with optimized buffer management
• Cross-Platform: Primary Windows support with portable Go codebase

Package Structure

FileDO/
├── main.go                    # Application entry point
├── fsx/                      # Path identity and atomic writes
├── statedir/                 # Where state files live (%LOCALAPPDATA%\FileDO\state)
├── fileduplicates/           # Duplicate file management
│   ├── types.go              # Duplicate detection interfaces
│   ├── duplicates.go         # Core duplicate logic
│   ├── duplicates_impl.go    # Implementation details
│   └── worker.go             # Background processing
├── filedo_win_vb/           # VB.NET GUI application
│   ├── FileDOGUI.sln        # Visual Studio solution
│   ├── Program.vb           # Entry point; the window is ShellForm.vb
│   └── bin/                 # Compiled GUI executable
├── cmd/
│   ├── filedo/              # Main CLI sources
│   ├── filedo-check/        # Standalone health check utility
│   ├── filedo-fill/         # Standalone fill utility
│   └── filedo-test/         # Standalone test utility
├── fileduplicates/           # Duplicate detection logic
└── helpers/                  # Shared helpers

Key Features

• Enhanced InterruptHandler: Thread-safe interruption with context support
• Optimized Buffer Management: Dynamic buffer sizing for optimal performance
• Comprehensive Testing: Fake capacity detection with random verification
• Duplicate Detection: SHA-256 file comparison with caching, and a byte-for-byte check before any delete or move
• Batch Processing: Script execution with error handling
• History Logging: JSON-based operation tracking

---

Version History

v2610102316 (Current)

• Virtual disks: mount noscan is retired - FileDO no longer changes Microsoft Defender settings; the word is still accepted and ignored, the mount window has no antivirus box any more, and a container file can be excluded by hand in Windows Security
• Security software: the disk steps no longer run PowerShell as an encoded command or with an execution-policy override - both are signs that security software weighs against a program

v2610091940 (Previous)

• Disks: the create, compact and auto-mount actions of the Disks group, and Image to file, now draw their own icons from the shared icon set instead of stand-in symbols - in the group and in the Disk manager
• Sharing: a disk state that the sharing program names with a word this build does not know is shown as unknown instead of failing the whole answer; an unknown state never counts as closed and never allows a mount
• Description: the README, the site and the Store listing now open with "Know your storage before you trust it"; wiping is described as making recovery harder, with no guarantee on SSDs or copy-on-write disks

v2610070412

• Virtual disks (.fdd): a whole volume in one file, mounted as a drive letter - filedo vd new, mount, unmount, plus info, verify and export (raw image or VHD) without mounting, and grow, compact, format, seal, clone, pass, destroy; obfuscated without a password, encrypted with one, and never called the other
• Partition disks: a virtual disk can live in a new GPT partition cut from a disk's free space instead of a file - filedo vd disks lists every disk, its free space and why an extent is usable or not; vd new part, vd image (copy it into an ordinary .fdd) and vd adopt; nothing outside the free space is touched, Windows asks for administrator consent on every read, and the Microsoft Store build does not offer them
• Check and safety: chkdsk scans the volume inside an unmounted container and writes nothing, chkdsk fix repairs one that was not closed cleanly; vd guard on saves ram disks and unmounts every container cleanly when your session ends; vd auto mounts an obfuscated container when you sign in
• Sharing: optionally, vd share offers a disk to the phones and tablets paired with Fast Media Sorter for Windows as one more folder (vd open, vd close, vd autostart, or Share with Fast Media Sorter & Sharing.. in the Disk manager); that program serves the files over SFTP, FileDO opens no network connection of its own, and an encrypted disk is unlocked on this PC, never from the phone
• Explorer: the setup EXE's new Disk container files (.fdd) feature (DiskContainerIntegration) gives .fdd its icon, a double-click that mounts, and Mount read-only / Unmount; filedo vd register does the same without an installer
• GUI: a new Disks group - one page per operation - and the Disk manager, a second window with one row per virtual disk, its state in words, and mount, unmount, open and save from the row; a mount outlives the window, and the installer adds a FileDO Disk Manager Start menu entry that opens it straight
• Limits: Windows only; mounting asks for administrator consent; the Microsoft Store build reads, verifies and exports containers but cannot mount them, use partition disks or share
• Docs: new guides - virtual disks and sharing disks with Fast Media Sorter; the site pages in German and French, and a release notes page

v2609241700

• Secret files (.fd-sec): pack one file into a password-protected container and get it back - secure, unsecure, reveal - from the command line, the Explorer menu or the window's Protect pages; the original's name, size and timestamps are sealed inside
• Explorer integration: the setup EXE adds a File DO.. right-click group (Secure, Unsecure, Wipe this file, Check this file, Info) and the .fd-sec document type; filedo fdsec register / unregister does the same without an installer
• GUI: a new window - a rail of jobs with one page per job, each carrying every CLI option, plus Command, History, Settings and About pages; the old command-builder window is retired
• Copy: copying starts at the first file; --precount counts the tree first for exact totals and an ETA
• CLI: one set of exit codes - 0 passed or done, 1 found a defect, 2 could not be verified; credentials are redacted before anything reaches the history
• Distribution: FileDO is on the Microsoft Store; THIRD-PARTY-NOTICES.txt ships in the zip, the MSI and the Store package
• Docs: new guides - secret files and "Windows warned you about FileDO"

v2607301014

• GUI: 5-language interface (English, Russian, Ukrainian, German, French) with runtime language switching and an app icon
• GUI: About window with a send-logs-to-the-author action
• Privacy: hosted privacy page, linked from the site and the Store listing
• CLI: new "pleasantly paranoid" tagline and clearer usage text
• Docs: redesigned site with new step-by-step guides (storage check, files and copies, GUI command builder)
• Project: sources reorganized under cmd/ (filedo, filedo-check, filedo-fill, filedo-test); separate build and release flows

v2606120121

• Wipe: hardened wipe safety checks
• Duplicates: fixed duplicate-cache correctness and parallelism
• Copy: trimmed copy directory walks

v2605152056

• Installer: setup EXE (a WiX bundle carrying the MSI) plus the bare MSI; application icon embedded in all EXEs and the installed-programs entry
• Store: Microsoft Store submission spec and social preview image

v2604272228

• Distribution: first winget release (SerZhyAle.FileDO) and GitHub Actions release workflow
• Binaries: PE version info and Windows application manifest embedded in all binaries
• Docs: GitHub Pages redesigned and simplified

v2507112115

• Major Refactoring: Extracted capacity testing logic into dedicated capacitytest package
• Enhanced Interruption: Added context-aware cancellation with thread-safe InterruptHandler
• Improved Performance: Optimized buffer management and verification algorithms
• Better Architecture: Modular design with clear separation of concerns
• VB.NET GUI: Updated Windows Forms GUI application with better integration

v2507082120

• Added duplicate file detection and management
• Multiple duplicate selection modes (old/new/abc/xyz)
• Hash caching for faster duplicate scanning
• Support for saving/loading duplicate lists
• GUI application with duplicate management features

v2507062220 (Earlier)

• Enhanced verification system with multi-position checking
• Readable text patterns for corruption detection
• Improved progress display and protection mechanisms
• Bug fixes and error handling improvements

---

FileDO v2610102316 - Advanced File & Storage Operations Tool

Created by sza@ukr.net | MIT License | GitHub Repository | Universal Agent Kit

---

Recent Improvements

• Modular Architecture: Refactored into specialized packages (capacitytest, fileduplicates)
• Enhanced Interruption: Context-aware cancellation with graceful cleanup
• Thread-Safe Operations: Improved InterruptHandler with mutex protection
• Better Performance: Optimized buffer management and verification algorithms
• Updated GUI: VB.NET Windows Forms application with improved integration