Lightweight, deduplicating, compressed and encrypted backups for Windows, written in C++20, with a Qt 6 frontend. It also builds and passes its tests on Linux (SteamOS on the Steam Deck first), where the packages (AppImage, Flatpak) are not tested yet; see docs/LINUX_PORT.md for its status.
- Small and idle-free. The engine is one static ~1 MB executable: no service, no kernel driver. Scheduled backups are started by the system scheduler, run, and exit. Peak RAM stays around 100 MB however much data there is (measured: 101 MB for a 9.7 GB folder with the worker threads, 9 MB for an unchanged re-run; packs written in the background add 32 MiB each, and the 4 parallel file readers about 45 MB more). The frontend only uses memory while it is open.
- Deduplicated. Files are split into content-defined chunks (FastCDC, ~1 MiB average). A chunk already stored, from any file in any earlier snapshot, is never stored again. Every snapshot looks like a full backup but only adds what changed.
- Compressed and encrypted. Each chunk is zstd-compressed, then sealed with AES-256-GCM. Chunk ids are keyed BLAKE3 hashes, so the storage location learns nothing about the content.
- Fast incremental runs. Files whose size and timestamps match the previous snapshot are not even read.
- Pause a plan. A job can be paused: it keeps its settings and schedule, but nothing starts it on its own until it is resumed ("Back up now" still works).
- Polite. Priorities and hard limits for CPU, disk, memory and bandwidth, per job.
- Verifiable.
verify --read-datadecrypts and checks every stored chunk, and jobs run health checks on their own (see below). - Portable repositories. A repository written on Windows restores on Linux and the other way round (same format, same crypto).
- Local or cloud. Back up to a disk, a USB drive, a network share, S3-compatible cloud storage (Cloudflare R2, Backblaze B2, Amazon S3, IDrive e2, MinIO, ...), or a cloud drive (pCloud, OneDrive, Google Drive, MEGA), a WebDAV server (Nextcloud, ownCloud, a NAS), or an SSH server over SFTP, each through its own API with no extra software. The cloud only ever sees encrypted chunks.
- Watches the drives. The health of the backup drive and the drives backed up from, with a percentage from S.M.A.R.T. and a warning when a drive gets worse.
- Easy to get files back. A timeline of versions, a search across all of them, the history of any file, a preview of pictures and code without restoring, and each version as a folder in File Explorer (or, on Linux, the file manager).
- Disk tools. Set up a new disk (partition table, file system, drive letter) and erase a disk, a drive or a drive's free space so the data cannot be brought back (drive cleanser).
- Moves to a new computer. Export the settings and every backup job to one file and import them on another computer; passwords and keys only on request, and then encrypted.
- Several PCs in one view. Computers that back up into the same place (a shared folder, a NAS, a cloud bucket) leave an encrypted status note there, so any of them shows how every computer's backups are doing.
The on-disk format is specified in docs/FORMAT.md.
The overview of a job: its last and next backup, the versions kept, the last health check, the drives involved with their health, and the days a backup ran.
| Program | What it is |
|---|---|
vaultik-gui |
The frontend: backup jobs, schedules, progress, history, snapshot browser, restore |
vaultik |
The engine and command line. The frontend and the scheduler run it for the actual work |
vaultik-task |
Windows only: windowless launcher that Task Scheduler starts, so no console flashes up |
Windows: Visual Studio 2022 or later with the C++ workload (MSVC, CMake and the bundled vcpkg).
build.cmd release test
The programs end up in build\release\. Dependencies (zstd, BLAKE3, nlohmann-json, Qt 6 for the
frontend, doctest for tests) come from vcpkg and are linked statically. The first build compiles
a minimal Qt and takes a while; later builds reuse it.
Linux (not yet built or tested, see docs/LINUX_PORT.md): a C++20 compiler (GCC 12+ or Clang 16+), CMake, Ninja and the distribution's development packages. On Debian or Ubuntu:
sudo apt install g++ cmake ninja-build pkg-config libzstd-dev libssl-dev libcurl4-openssl-dev \
nlohmann-json3-dev doctest-dev qt6-base-dev libqt6svg6-dev libfuse3-dev fuse3
./build.sh release test # BUILD_DIR=~/vaultik-build to build outside the source folder
libfuse3-dev (Fedora: fuse3-devel, Arch and SteamOS: fuse3) lets vaultik mount show a
version as a folder; without it everything else builds and the command says what to install
(-DVAULTIK_FUSE=OFF leaves it out on purpose). Running a mount needs the fuse3 package
(fusermount3) and /dev/fuse.
BLAKE3 comes from the distribution where it has it (libblake3-dev), otherwise CMake downloads
release 1.5.4 and checks its SHA-256. ./build.sh vcpkg release test builds with vcpkg instead
(VCPKG_ROOT). Configure with -DVAULTIK_BUILD_GUI=OFF for a command-line-only build (servers).
Until the Linux port is verified, the Linux notes in this README describe the intended behavior.
Every push builds and tests on Windows and Linux, and once more on Linux with AddressSanitizer and UndefinedBehaviorSanitizer (memory errors, leaks, undefined behavior). The tests include runs cut short by a failing drive (a write that fails, a pack cut short, a rename that does not happen, a failed delete or read, through a test storage that fails on purpose): a backup, a cleanup or a health check stopped that way must leave every version readable, and the next run must finish and leave the backup whole.
Start vaultik-gui, then New backup job:
- General: a name, the destination (a folder on a USB drive, other disk or network share, or Cloud storage...) and the repository password. A new destination gets a new encrypted repository; an existing one is opened with its password. Cloud storage asks for the provider, then for S3-compatible storage the endpoint, an existing bucket, an optional folder in it and an access key, or for a cloud drive a folder and a sign-in; Test connection checks them. The secret key or sign-in token is stored like the password (see "Cloud drives" below).
- What to back up: folders and files, with Add common data for your own folders
(Documents, Desktop, Pictures, Music, Videos, Downloads) and the data of common programs:
browser profiles (Chrome, Edge, Brave, Firefox, Opera), email (Outlook data files, Thunderbird)
and game saves, each found wherever Windows keeps it (moved into OneDrive, say). Also name
patterns to skip (
*.tmp,node_modules), and whether to use a Volume Shadow Copy for open and locked files (on by default; it needs administrator rights, see "Current limits"). For the shadow copy, Windows briefly pauses the writes of programs that take part in it, such as SQL Server. "Do not pause SQL Server" leaves SQL Server running; its database files are then saved as they would be after a power cut, which SQL Server recovers from when the files are attached again. - Virtual machines: WSL distributions and Hyper-V virtual machines to back up through their own export tools (see "WSL and Hyper-V" below).
- Docker and databases: Docker volumes to back up through Docker, and databases (SQL Server, MySQL or MariaDB, PostgreSQL, also in a Docker container) to dump with their own tools before the backup (see "Docker volumes" and "Database dumps" below).
- Schedule: manually, every few hours, daily, or on selected weekdays. Schedules are kept by
Task Scheduler (Windows, task folder
\Vaultik) or a systemd user timer (Linux), so Vaultik does not need to stay open; a run missed while the computer was off starts at the next chance. Scheduled runs can skip while the computer runs on battery, wake the computer from sleep at their time, and, for cloud storage, skip over a metered connection such as mobile data (the skipped run shows in the Activity tab; the next scheduled one tries again). While a backup, health check, cleanup, restore, disk image or an erase of a disk or of free space runs, the computer does not go to sleep (the display still turns off and the screen still locks): Windows lists the run underpowercfg /requests, and on Linux it holds a logind sleep inhibitor (systemd-inhibit --list) when logind is there. The computer may sleep again as soon as the run ends, however it ends. "Back up now" always runs. "Only save a version when something changed" makes a run that finds every file and folder as in the last version (content, times, attributes, permissions, streams; a folder's own times aside, which Windows updates lazily) save no new version; it shows as "nothing changed" and still counts as a backup for the overdue reminder (vaultik backup --skip-unchangedon the command line). Paused (a tick in this section, or Pause schedule in the job's More menu, which turns into Resume schedule) keeps the job, its schedule and every setting, but nothing starts it on its own until it is resumed: no scheduled task or timer, no idle, lock, sign-out, update, drive, continuous or other-computer runs, and no "not backed up for N days" reminders. The job list shows it as "Paused (Daily at 18:00)". Back up now still runs it. Pausing a job with administrator rights updates its approved copy and removes its task through the usual approval; when that approval is declined (or fails) the job stays as it was, not paused, and Vaultik says so (vaultik pause-job <job>andvaultik resume-job <job>on the command line). On Windows a job can also run with administrator rights, so scheduled runs use a shadow copy for open and locked files. Windows then asks for administrator approval each time the job (or its schedule) is saved or removed. Without the option, the task runs with normal rights and needs no approval. Such a job only works when Vaultik is installed in a folder only administrators can change, such asC:\Program Files\Vaultik: the approved step checks this, then copies the job and its password intoC:\ProgramData\Vaultik\admin\<your account>, which your account can read but only administrators can change. Scheduled runs read only that copy, and refuse to run if its permissions were loosened, so nothing your normal account (or a program running as you) can change decides what an administrator run does. Editing the job in Vaultik and saving it updates the copy; so does changing the password in Vaultik. The copy is taken from your own job file, which a program running as you could have changed, so when what the job backs up, where it saves it, or its commands differ from the copy already approved (or there is none yet), the approved step shows them and asks before it copies them. Scheduled runs of such a job use the Windows system account, not yours, so they also run when nobody is signed in and your profile, registry and environment play no part; the job's secrets in the copy are sealed with the computer's key so that account can open them. Each run first checks that the account that approved the job is still an administrator of the computer (and not disabled), and does not run otherwise. The system account cannot sign in to network shares, so a job whose destination or folders are on one cannot use the option (back up over SFTP or WebDAV instead). The task itself can be read by your account but changed only by administrators. A job saved with an older version keeps running as your own account until it is saved again. - Resources: a priority preset and optional hard limits (see below).
- Old backups: a preset: Smart (the default: one version per day for 7 days, per week for 4 weeks and per month for 12 months), the newest N versions, every version of the last N days, custom rules, or keep everything; plus an optional size limit, which removes the oldest versions (never the newest, never pinned ones) when the backup grows past it. The dialog says in plain words what the rules keep. Every version is a complete backup, so removing one never breaks the others; after each run the versions no rule keeps go and the space only they used is freed.
The window follows the Windows light or dark setting and accent colour. The sidebar lists the jobs with their last result; the job page shows live progress and four tabs:
- Versions: a timeline grouped by day, week and month, each version with what changed since the one before (new, changed and removed files), its size and the space it added. Pin a version to keep it whatever the rules say, add a note ("before reinstalling Windows"), delete one, or restore from it. Versions the next cleanup will remove are marked.
- Find a file: search every version by name (
budget,*.xlsx); pick a result to see only the versions where it changed, each compared with the file on this PC now, and restore any of them. - Activity: every run, also the scheduled ones, with its result.
- Log: warnings of the runs started here.
Restore opens a version browser: pick a file or folder (or nothing, for everything) and
restore it to another folder or to its original location; right-click an item for all its
versions. Before it writes anything, a restore works out how much it will write and stops
with a clear message when the target drive does not have room for it ("the restore needs about
40 GiB but only 12 GiB is free"; --ignore-space restores anyway). With Overwrite, it also
counts room for the largest file of the same size it replaces (a file of another size is counted
in full already). The estimate is only a help: when it cannot be made
(a damaged folder listing, say), the restore says so and goes on, restoring everything it can
read. Skip files that are already
identical (on by default; --skip-identical) leaves files in the target that have the same
size, date and content as in the backup as they are, so a restore that was interrupted (the drive
was unplugged, the computer went off) simply goes on where it stopped when run again; a file it
left half written is restored again (with Replace files that already exist). A preview beside the browser (and Preview in Find a file) shows a file of any
version without restoring it, decrypted into memory only:
- Pictures (JPEG, PNG, GIF, BMP, TIFF, ICO, and HEIC or WebP where Windows has the codecs), fitted to the window or at full size, turned the way the camera recorded.
- Text and code with line numbers and syntax colours (C/C++, C#, Java/Kotlin, JavaScript and TypeScript, Go, Rust, Python, PowerShell, shell and batch files, SQL, Lua, XML/HTML, JSON, YAML, INI/TOML, CSS, Markdown), line wrapping on request, and Ctrl+F to find text (all matches highlighted, with next/previous and match case). Files over 8 MB show their beginning.
Small files of a local backup open as soon as they are selected; large files and cloud backups wait for Show preview, since they have to be downloaded first.
Settings (in the sidebar) has, like System Informer: start Vaultik when you sign in, optionally hidden in the notification area; show its icon there; turn the icon red when a backup needs attention; close and/or minimize to the notification area; and a single click on the icon to show or hide the window. From the notification area it watches every job, including scheduled runs, and shows a Windows notification when a backup fails or skips files, or when a job has not backed up for too long (about twice its interval: two days for a daily job; a set number of days for jobs without a schedule). The icon turns red while something needs attention; its menu opens Vaultik, starts a job's backup, opens Settings or quits. Closing the window keeps Vaultik in the notification area, and starting it again brings the running one to the front. With Windows' Do Not Disturb on, the notifications go quietly to the notification centre.
Restore from another backup... under the list of jobs (or Restore from an existing backup...
before there is a job) opens any Vaultik backup, in a folder or in
cloud storage, with its password, without a saved job: the way to get files back on another
computer. Copy vaultik-gui.exe, vaultik.exe and vaultik-task.exe there (they need nothing
else), connect the backup drive (or have the cloud storage keys at hand), pick the location and
enter the password.
The password is stored for scheduled runs, readable only by your user account: encrypted with
DPAPI on Windows; on Linux sealed with a key kept in your own settings folder
(~/.config/vaultik/secrets/local.key) and stored with mode 0600 inside a 0700 folder (anything
that can read your account's files can read it there, but a portable copy's settings on a backup
drive do not carry the key, so the drive alone does not give the password away). Job files live in %LOCALAPPDATA%\Vaultik
or ~/.config/vaultik (override with VAULTIK_CONFIG_DIR).
A run that starts on its own (the schedule, a connected drive, an idle or locked computer, changed files) never asks for anything. When the job's password is not saved on this PC (or was saved by another account), it fails at once with "the password of this backup is not saved on this PC", records that in the job's history and sends a "password" alert (at most one a day per job, however often the job is started), instead of waiting for an answer nobody can give. Edit the job and enter its password, or start it with Back up now.
Keep the password safe elsewhere too. Without it the backups cannot be decrypted, and nobody can reset it. What helps is the recovery key: a new backup shows one once (8 groups of 4 characters, with buttons to copy it or save it to a file). Keep it apart from the computer. If the password is forgotten, Password and recovery key... under the list of jobs sets a new password with the recovery key; the same dialog changes the password with the current one, or makes a new recovery key (which replaces the old one, and gives older backups one). Saved jobs that use the backup get the new password. A changed password does not re-encrypt the backup: a copy of the backup folder made before the change still opens with the old password.
Print recovery kit... (where the recovery key is shown, and in Password and recovery key
for the key you type in) saves one page to print, as a PDF or a web page: the recovery key as
text and as a QR code, where the backup is and what kind of place that is (a folder on an
external drive, a network share, S3-compatible storage, a cloud drive...), the computer's name,
the date, and short steps to restore on a new computer. It never holds the password or a cloud
storage key. The file is readable by your account only; once the page is printed, delete it.
vaultik recovery-kit -r <repository> --out kit.pdf (or kit.html) writes the same from the
command line, for the recovery key it asks for (or --new for a new one); its PDF uses the
PDF's built-in fonts, so letters outside Western European ones show as ? there (the web page
and the frontend's PDF have them all).
Still unprotected on a job's Overview lists, in plain words, what would still leave the
backup at risk, each with a button to the fix where there is one: the password is not saved on
this PC (so scheduled runs cannot run), there is no second copy, the recovery kit was never saved
or printed on this PC, a test restore never ran, the schedule is paused, the last health check
found damage, could not finish or is overdue (or checks are off), the backup is on the same drive
as files it backs up, or every job saves to one drive and none has a second copy. Saving or
printing a recovery kit leaves a marker in kits in the settings folder (it holds nothing of
the key). The card is hidden once nothing is left.
powershell -File tools\package.ps1 builds the release programs and makes, in dist\:
Vaultik-<version>.msi: the installer. It shows the license and lets you pick the folder (C:\Program Files\Vaultikby default), adds a Start menu entry and putsvaultikon PATH. A newer version replaces an older one in the same place (the choice is remembered), and removing Vaultik also removes its scheduled tasks (jobs, history and backups stay). The installer makes the folder administrator-only, which jobs with administrator rights and "Start Vaultik as administrator" need, so it refuses a drive or a folder like Program Files or Windows itself (pick a folder of Vaultik's own); outside Program Files those also need every folder above it to be administrator-only (a folder likeD:\Appsusually lets any user change it, so they then refuse to run). The programs load the system libraries they need from System32 only, and administrator jobs check every file in the program folder, so nothing placed next to the programs loads into an elevated run.Vaultik-<version>-portable.zip: a Vaultik folder to unzip anywhere, e.g. on an external drive. The fileportablenext to the programs keeps jobs, history, passwords and settings inSettingsthere, so nothing is written to the PC. Passwords are sealed for the Windows account that saved them, so on another PC Vaultik asks once for each backup's password.
pwsh -File tools\msi-sandbox-test.ps1 tests the newest MSI in Windows Sandbox, a throwaway
Windows, so nothing is installed on your computer: it installs it (add -OldMsi <older msi> to
test an upgrade, -Wizard to click through its pages), checks what it set up, backs up and
restores with it, and uninstalls it. It prints the result and exits with 0 only when all passed.
After each backup to an external drive (USB, FireWire, memory card), Vaultik also keeps
<drive>\Vaultik\ with these portable programs and a "How to restore" note, so any Windows PC
can restore from the drive with nothing installed. It only replaces an older copy.
On Linux, tools/appimage.sh builds dist/Vaultik-x86_64.AppImage (window and engine in one
file; Vaultik-x86_64.AppImage --cli <command> runs the command line), and
packaging/flatpak/io.github.bigisoft.Vaultik.yml is a Flatpak manifest; both are untested so
far. After a backup to an external drive, the AppImage keeps a copy of itself in
<drive>/Vaultik/ with "How to restore on Linux.txt", next to the Windows programs; there it is
portable (settings in Settings-Linux), so a Steam Deck in Desktop Mode can restore from the
drive with nothing installed.
The version is set in project() in CMakeLists.txt. The program icon is drawn from
src/gui/app_icon.svg; after changing it, build vaultik-make-icon and run
vaultik-make-icon src\gui\app_icon.svg src\gui\vaultik.ico.
Once a day (Settings, Updates) Vaultik asks GitHub for the number of the newest release and,
when there is a newer one, says so in a notification and in Settings with a link to its page.
Nothing is downloaded or installed by itself and nothing about you or your backups is sent;
vaultik update-check asks the same from the command line. Each release lists the SHA-256 of
its files (SHA256SUMS.txt; compare with certutil -hashfile <file> SHA256). tools/package.ps1
signs the programs and the MSI when a code signing certificate is set up (see the top of that
script); without one, Windows SmartScreen warns when the download is opened.
vaultik init -r E:\Backups\vaultik
vaultik backup -r E:\Backups\vaultik C:\Users\me\Documents D:\Projects --exclude node_modules --exclude *.tmp
vaultik snapshots -r E:\Backups\vaultik
vaultik computers -r \\nas\backups\vaultik
vaultik ls -r E:\Backups\vaultik latest C/Users/me/Documents
vaultik restore -r E:\Backups\vaultik latest --target D:\Restore --path C/Users/me/Documents/report.docx
vaultik verify -r E:\Backups\vaultik --read-data
vaultik stats -r E:\Backups\vaultik
vaultik forget -r E:\Backups\vaultik --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune
vaultik prune -r E:\Backups\vaultik
vaultik jobs
vaultik run-job documents
vaultik pause-job documents
vaultik resume-job documents
vaultik settings export moving.vaultik-settings --with-secrets
vaultik settings import moving.vaultik-settings --jobs documents --replace
vaultik check-job documents --full
vaultik report --month 2026-10 --html report.html
vaultik copy documents
vaultik diff --job documents latest
vaultik estimate --job documents
vaultik mount --job documents latest
vaultik restore --job documents latest --target D:\Restore
vaultik key passwd -r E:\Backups\vaultik
vaultik key passwd -r E:\Backups\vaultik --recovery-key
vaultik key recovery -r E:\Backups\vaultik
vaultik recovery-kit -r E:\Backups\vaultik --out kit.pdf
vaultik grew --job documents --since 30d
vaultik apps --job documents latest --missing
vaultik apps install --job documents Git.Git 7zip.7zip
vaultik disk list
vaultik disk init 2 --label Backups
vaultik disk wipe 2 --method dod3 --verify
vaultik disk wipe-free D:
The repository can be any folder: an internal disk, a USB drive or a network share
(\\nas\backups\vaultik, or a mounted share on Linux). Set VAULTIK_REPO and VAULTIK_PASSWORD
(or use --password-file) for unattended runs, or use --job to take the repository and stored
password from a saved job. Snapshot paths start with the drive letter (C/...) or
UNC/server/share/... on Windows, and with the top-level folder (home/...) on Linux.
It can also be S3-compatible cloud storage, written s3:https://<endpoint>/<bucket>[/<folder>]:
set AWS_ACCESS_KEY_ID=...
set AWS_SECRET_ACCESS_KEY=...
vaultik init -r s3:https://<account id>.r2.cloudflarestorage.com/backups/my-pc
vaultik backup -r s3:https://s3.eu-central-003.backblazeb2.com/my-bucket/vaultik C:\Users\me\Documents
set VAULTIK_S3_STORAGE_CLASS=DEEP_ARCHIVE
vaultik cloud-thaw -r s3:https://s3.eu-west-1.amazonaws.com/archive/my-pc latest --days 7
The bucket must exist. The signing region is worked out from the endpoint (auto for R2,
us-east-1 when it cannot be); set AWS_REGION to override it. With --job, the job's stored
keys are used. Each repository file is one object; requests are retried with backoff on network
errors, throttling and server errors, and --write-limit / --read-limit cap uploads and
downloads. Browsing a cloud snapshot in the frontend downloads the folders it shows, so it is
slower than browsing a local one.
sftp:<user>@<server>[:<port>]/<folder> backs up to a folder on any server you reach with SSH
(a NAS, a Linux server, a rented storage box); the folder and any missing folders above it are
created, and every file is written under a temporary name and renamed into place. Sign in with a
password, or with a private key file (RSA or ECDSA, in OpenSSH or PEM format; ed25519 keys are not
supported yet) and its passphrase. Windows only so far (libssh2 with Windows' own crypto).
Nothing is sent before the server has shown the key that was trusted for it: the first connection
(Test connection in the Cloud storage dialog, provider SFTP) shows the server's key as
OpenSSH does (SHA256:...); compare it with the one the server's owner gives you (ssh-keygen -lf on the server) before you trust it. The trusted key is kept with the job, and a server that
shows another one later is refused with both keys named. On the command line: VAULTIK_SFTP_KEY
(the key file), VAULTIK_CLOUD_SECRET (the password or passphrase) and VAULTIK_SFTP_HOST_KEY
(the trusted key).
webdav:https://<server>/<folder path> backs up to a folder on a WebDAV server: Nextcloud and
ownCloud (https://<host>/remote.php/dav/files/<user>/<folder>, with an app password),
Synology and QNAP NAS boxes, Apache or nginx with WebDAV, and many web hosts. The folder and any
missing folders above it are created. The user name and password are entered in the Cloud
storage dialog (provider WebDAV) and stored like a job's password; on the command line,
VAULTIK_CLOUD_USER and VAULTIK_CLOUD_SECRET. They go to the server with every request (HTTP
Basic authentication), so the URL must use https, except to a private network address (10.x,
172.16-31.x, 192.168.x, this computer).
Locations pcloud:<folder>, onedrive:<folder>, gdrive:<folder> and mega:<folder> back up
to a folder in that drive. Sign in once in the frontend's Cloud storage dialog; the job then
keeps a sign-in token (never the password), sealed like the job password, and scheduled runs use
it. On the command line use --job, or put a token in VAULTIK_CLOUD_SECRET.
pCloud, OneDrive and Google Drive only let registered apps sign in, so each needs a free, one-time registration of your own "Vaultik" app; its client ID (and secret) go into the dialog and are remembered:
- pCloud: at docs.pcloud.com, "My applications", create an app and
add the redirect URI
http://localhost:53682/. Enter its client ID and client secret. The folder is from the top of your pCloud; the token does not expire. - OneDrive: in portal.azure.com, App registrations, New
registration: accounts "in any organizational directory and personal Microsoft accounts",
platform Mobile and desktop applications with the redirect URI
http://localhost, then Authentication, "Allow public client flows" on. Enter its Application (client) ID. Vaultik asks only for its own app folder (OneDrive\Apps\<app name>), and the folder is inside it. Files deleted byprunego to the OneDrive recycle bin, which counts against the quota until it is emptied. - Google Drive: in console.cloud.google.com, a project
with the Google Drive API enabled, the OAuth consent screen set to External and
published (in "Testing" the sign-in lapses after 7 days), and an OAuth client ID of type
Desktop app. Enter its client ID and client secret. Vaultik asks only for the files it
creates (
drive.file), so it makes its own folders; one of the same name made by hand is not used. The folder is from the top of My Drive. - MEGA: no registration: sign in with the email and password (and the two-factor code if the account has one). Vaultik stores the MEGA session and the account key, not the password; "close all other sessions" in MEGA's settings signs it out. MEGA encrypts files with its own scheme, which Vaultik does itself (on top of its own encryption). Free accounts have a download transfer limit, which large restores can reach.
init prints the new repository's recovery key. key passwd sets a new password after
checking the current one (or, with --recovery-key, the recovery key from a prompt or
VAULTIK_RECOVERY_KEY; the new password comes from a prompt or VAULTIK_NEW_PASSWORD), and key recovery makes a new recovery key.
On Windows, backup reads from a Volume Shadow Copy when it runs as administrator
(--vss auto, the default); --vss on makes that required and --vss off always reads live.
--vss-skip-sql keeps SQL Server from being paused for the shadow copy.
--json turns the output into one JSON event per line (progress, warning, done); with it,
a line cancel on stdin stops a backup or restore cleanly. The frontend uses this.
Exit codes: 0 ok, 1 error, 2 wrong password or damaged data, 3 finished but some files
were skipped (see warnings), 4 cancelled, 5 repository in use by another run, 6 (disk
tools) a drive is in use by another program (see Drives in use), 7 (Linux)
the progress channel given with --progress-pipe cannot be used, so nothing was done, 8
(run-job, copy) the backup drive is not connected, so the run waits for it (see below;
copy returns it when the drive of the job's second copy is not connected), 9
(disk wipe --then-init) the disk was erased, but setting it up again failed.
forget removes snapshots by keep rules (--keep-last, --keep-hourly, --keep-daily,
--keep-weekly, --keep-monthly, --keep-yearly). Each rule keeps the newest snapshot of each
of the last N periods that have one; a snapshot kept by any rule stays. Rules apply per job, or
per computer and set of paths for snapshots made without a job; --tag job:<id> limits forget
to one job. --dry-run shows the decision without removing anything. Removing snapshots frees
no space by itself: prune (or forget --prune) then deletes the data no remaining snapshot
uses, rewriting packs that are mostly unused.
"Open in Explorer" on a version (or vaultik mount --job <job> <version>) shows it as a
read-only folder under the settings folder (browse), using the Windows Projected File System
(an optional Windows feature; Vaultik offers to turn it on). Nothing is copied up front: folder
listings come from the version and a file is read from the backup the first time it is opened,
so any program can open or copy files from it. Deleting and renaming are refused, and nothing
written there reaches the backup. The folder is removed when it is closed (the status bar
button, Enter in the command, or quitting Vaultik); one left by a killed process is removed by
the next mount.
On Linux, "Open as folder" (or vaultik mount -r <repo> <version> [<folder>]) mounts the
version with FUSE 3 and opens it in the file manager. The mount is read-only and only your
account sees it; files keep their sizes, modification times, modes, owners and symbolic links,
and their content is read from the backup as programs read it. It ends with Enter or Ctrl+C in
the command (or SIGTERM, or closing it in Vaultik), and fusermount3 -u <folder> ends it from
outside. If the process is killed, newer fusermount3 versions unmount it by themselves, and the next
vaultik mount removes whatever is left in browse. It needs the fuse3
package (installed on SteamOS); a Flatpak cannot mount, so use the AppImage or a native build.
A job can name a second copy (General tab): another folder or cloud storage, e.g. a USB drive
for the backup and cloud storage for the copy. After each backup that saved a version,
run-job copies the new versions there (vaultik copy <job> does it on demand): a repository
of its own, with the job's password, created on first use. The two repositories have their own
keys, so every chunk is decrypted and stored again under the copy's key; data the copy already
has is not stored twice, and <settings>\copies\<job>.map remembers what was copied so later
runs read only what is new. The job's keep rules apply to the copy too. A copy is its own entry
in the history ("copy"), so a failed copy shows in the tray without failing the backup.
Several computers can back up into the same repository: a shared folder, a NAS or a cloud
bucket, with the same password. Each snapshot already records the computer it came from; on top
of that, after every run of a saved job (backup, health check, second copy, test restore) a
computer leaves a small encrypted status note in the repository (status/, see
docs/FORMAT.md): its name, its Vaultik version, and per job the last run and its result, the
last version saved, the next scheduled run, and warnings such as a failing drive or a ransomware
warning. Each computer is known by an id made from Windows' machine GUID and the repository's
key, so renaming it does not matter and nobody without the password can tell that two
repositories hold notes of the same computer. Writing the note never fails a run.
All computers... in the frontend's sidebar lists, for every destination your jobs use, each computer with its state (OK, warning, failed, or overdue: no run for more than 3 days past its schedule), its last backup and its versions; click one for its jobs. On the command line:
vaultik computers --job documents
vaultik computers -r \\nas\backups\vaultik --json
Computers that backed up with an older Vaultik, or without a saved job, show with their versions only. Prune, repair and health checks leave the notes alone, and S3 Object Lock does not lock them (they are rewritten after each run). Two jobs of one computer that end at the same moment both keep their entry: each run reads the note back after writing it and writes it again when the other run's note replaced its own.
Remove... (or vaultik computers --forget <name or id>) deletes the note of a computer that
no longer backs up there, after asking; its versions stay. It refuses this computer's own note.
Ask to back up now (or vaultik computers --ask <name or id>, --ask-job <job id> for one
job) leaves an encrypted request for that computer in the repository. Vaultik on the other
computer looks for requests every 15 minutes for folders, drives and network shares and every hour
for cloud storage, where each look costs a few billed requests and counts against the cloud
drives' rate limits (not over a metered connection); a look opens the repository without its
index and reads one small file. It then runs the asked jobs on that repository once (recorded
with the trigger "request"). A job that runs anyway (on its schedule) counts as having answered
the request for that job; a job with administrator rights is only answered that way, since Vaultik
does not start those itself. The view shows a request as "asked to back up" until the last job
ran; a request is dropped 7 days after it was made, whether or not it was taken up. Requests only
name saved jobs of that computer: they cannot make it run anything else. Whoever can write to
the storage (a cloud provider, someone with access to the share) cannot make or change a request,
but could put an old one back; each computer remembers the newest request it took up and ignores
that one and older ones. They could likewise put back an older status note: a note older than
that computer's newest version is marked as such ("status record older than its newest version",
health at least "warning").
New backups compress at zstd level 3, which keeps up with fast drives. When the drive is the
bottleneck (a USB 2.0 hub at about 40 MiB/s, a network share), a higher level writes less and can
make the backup faster as well as smaller. The job's Compression (Options tab) is "as the
destination has it" by default, which leaves existing backups exactly as they are; Fast (3),
Balanced (6) or Small (12) become the destination's setting with the next backup and
apply to new data only. Data already stored stays as it is, and every level reads back the same
way, also with older Vaultik versions (which keep writing at level 3). The setting is the file
settings/compression in the backup (see docs/FORMAT.md).
OneDrive (and similar sync programs) can keep files only online, with a placeholder on the disk.
Reading such a file makes OneDrive download it, so a backup does not read them by default: it
keeps their name, size and dates, and counts them on their own. The run's result, the
Overview's last backup and Still unprotected then say "N files are only in the cloud and not
backed up" ("cloud_only" in the history and the --json result; the version keeps the count).
Turn on Download files that are only in the cloud in the job's Options to have the backup
download them first and save their content; that takes time and fills the disk with them (OneDrive
can free the space again later). With it on, folders the change journal says are unchanged are read
again when they hold such files, so they are downloaded too, and Still unprotected keeps naming
the files until a backup saved them.
A job saving to a folder on a drive records the drive's volume ID ("volume" in the job
file). When Windows gives the drive another letter, the job follows it, so a backup drive that
comes back as G: instead of F: still works. With "Also back up when the destination drive is
connected" (Schedule tab), the running frontend or tray icon starts the job as soon as the drive
is plugged in (run-job <job> --on-connect, which does nothing when the job just saved a
version or is already running), then says when the drive can be unplugged.
Jobs that back up to the same drive take turns: a backup, health check, test restore or cleanup
waits while another job uses that drive ("Waiting for another job on this drive" in the app), and
starts when it is done, so three jobs on one USB drive do not share its speed and each take as
long as all three together. The turn follows the drive's volume ID, not its letter, and holds
between runs started by Task Scheduler or a systemd timer and runs started in the app. On Windows
jobs with administrator rights take turns with the runs of the account that set them up; other
accounts cannot take or hold the turn, so they cannot hold up your backups. As a program of your
own account could hold the turn, a job with administrator rights that waited the whole 12 hours
goes on with a warning instead of giving up: it can be delayed, never stopped. A turn that another
account made, or one your account may not open, is not waited for: the run goes on (and says so in
its log), while an eject counts it as in use, as it does when another program took the turn's name
for something else. On Linux root's runs take turns with the runs of every account through
/run/lock, your own prune or eject too; as any account could hold that shared turn, a run waits
for another account's run for 5 minutes at most and then goes on with a warning (both then share
the drive's speed): it too can be delayed, never stopped. Your own runs still take turns with each
other, whatever settings folder each uses (the installed app and a portable copy, say), through a
file in your own /run/user folder, where no other account can put one first, and one in /run/lock
(where your account cannot make that one, as on distributions whose /run/lock only root may write
to, a file in your settings folder instead, so runs with and without the /run/user folder still
take turns as long as they use the same settings folder), and a run as root is waited for as long
as it runs, also one that went on beside another run of yours, and also when another account made
the shared file in /run/lock first so that your account cannot use it (your eject then still
counts root's runs and commands as busy). Root keeps its own marks in /run/vaultik, where no other
account can put files. Keep every copy of Vaultik on a computer (the installed one, a portable
copy, an AppImage) on the same version: copies of different versions may not see each other's
turns and may then share a drive for a while. Another account cannot keep your eject refused, and
can make a command of yours wait 2 seconds at most; a command or eject as root still counts. An
eject as root also counts the runs and commands of every account that another account kept from
the turn all accounts share (by holding or making its file in /run/lock first), through their own
files in /run/lock and /run/user, and through the turn file in the settings folder that a program
holding a turn has open (so also a run without a /run/user folder whose file in /run/lock another
account made first), and is refused where Linux cannot tell whether those are in use (also where a
program in another container holds a turn file). So that no account can keep it looking for long,
it looks into at most 256 programs and 65536 open files of each account (and 3 seconds in all); an
account with more counts as in use for an eject as root, and a command as root does not wait for
it. An eject or command as root does not look at such files on a FUSE mount (an sshfs folder,
say), whose program could keep it waiting; one whose mount it cannot find at all (a FUSE mount
taken away with umount -l) it does not look at either, and counts as in use. A run kept from the
shared turn may share the drive's speed with a run as root. A turn file in /run/lock that another
account mounted something on (a FUSE file system, whose program could keep everybody who opens it
waiting) is not opened at all (Linux 5.8 and later). Any other run gives up after waiting 12
hours, and a run that cannot take its turn at all (the system refuses it) goes on rather than not
backing up. While a run only waits, the computer may go to sleep. A run started on its own that
waited behind a run of the same job does nothing once that run saved a version (and leaves neither
a record nor a log). A vaultik command started by a job's before or after command (a prune of
the same drive, say), also one started there with sudo, does not wait for the run that started
it; one that outlives that run takes the turn as usual. On Linux Vaultik tells this from which
program holds the drive's turn (the run the command was started from, also through a shell, sudo
or pkexec), so it works whatever environment reaches the command. As any account can hold the
turn all accounts share in /run/lock, a program holding only that one is taken for the command's
run only when it also holds a turn no other account can take (its account's own, or root's; for a
command started with sudo, also the turn file in the run's settings folder, which a run without
a /run/user folder uses where only root may write to /run/lock, and which root sees the run has
open, also when another account holds the turn all accounts share). A turn file counts as one no
other account can take by what the file is (your account's own, which no other account may open),
never by its name, so another account that made the shared file first and moves it away while the
command waits cannot pass it off as the run's. An account's own turn counts only for a program
that runs as that account now: Linux keeps naming the program that took a turn after it ended, and
its number may later go to a program of another account (your shell, or sudo). Another account
cannot make your commands skip their turn or keep your eject refused that way. Where root may not
look at other accounts' programs (some containers), such a sudo command waits 5 minutes for its
run and then goes on beside it. A turn counts only on its own drive: a lock that another account
holds on a file of another drive with the same file number is never taken for the run's. Where
Linux cannot tell who holds the turn (a settings folder on btrfs or overlayfs with Linux older
than 5.8, /proc mounted with hidepid, a run in another container), a command goes by what the
run passed on to it in VAULTIK_HELD_DRIVES, as on Windows; an eject never does. Cloud storage
has no such turns.
A backup drive formatted with exFAT (or FAT), as most new USB drives are, has no journal, and Vaultik's atomic file replacement falls back to a plain move there. The Drives card then shows one calm note: "This drive uses exFAT: always eject it before unplugging, or reformat it to NTFS for more safety."
Eject the backup drive (the Drives card of the Overview, for an external drive, or vaultik eject <job>) prepares the drive to be unplugged, as Windows' "Safely remove" does: it is
flushed, locked and dismounted where your account may, then Windows is asked to eject it, which
it refuses (naming the program) while something still uses the drive; on Linux udisksctl unmount and power-off. Vaultik refuses while any of its own commands has the drive open (a
backup, check, cleanup, restore, copy, repair or any other command that opened the backup), also
one with administrator rights, and a command that starts while the drive is being ejected waits
for the eject (at most a minute) and then finds the drive gone. Eject it on its own when the last job using it is done (vaultik eject <job> --when-done on, per drive) ejects it after the last of the jobs that waited for it
finishes. No administrator rights are needed for a USB drive.
When a run finds the backup drive not connected, that is no failure: the drive is simply
elsewhere. The run is recorded once as "Waiting for the drive" (grey, not red; "status": "waiting" in the history, exit code 8, Event Log id 104 as information), sends no alert or
failure notification at first, and the Overview says since when it waits. Back up now with the
drive away says the same in the status bar ("Waiting for the drive"), not "Backup failed". As soon as the drive is plugged
in while Vaultik is open (or in the notification area), the missed backup runs, also for jobs
without "Also back up when the destination drive is connected"; otherwise the next scheduled run
does it. If the drive stays away too long, the overdue reminder ("not backed up for N days")
speaks up as before, and so does an alert (below). A second copy whose drive is away waits the same way and catches up after
the next backup with its drive connected. Once the backups of a job, or its second copy, have
waited for their drive for 3 days (for a weekly job: the longest gap between its days, plus one),
each run sends a "backup drive missing for N days" alert, at most one a day, also for a job that
never saved a version or backs up every hour, and without the app running. (Windows has no Task Scheduler trigger for a drive
being plugged in that works without turning on an extra event log first, so the catch-up is done
by Vaultik itself.)
Besides a time, the Schedule tab's "Also back up" starts a job:
- When the computer has been idle for 10 minutes, or when you lock it: a second Task
Scheduler task (
\Vaultik\<job>-events) runsrun-job <job> --on-event. It works for jobs with administrator rights too. - When you sign out or shut down: the tray icon asks Windows to wait, with the reason
"Vaultik is backing up before Windows signs out", runs the job (
--on-sign-out) and then lets Windows go on. Windows shows its "apps are preventing sign-out" screen meanwhile, where you can go on without waiting. A shutdown Windows forces (low battery, the end of an update's restart deadline) is not held up. - When Windows starts installing updates: the same
-eventstask also starts on Windows Update's "Installation Started" event (event 43 ofMicrosoft-Windows-WindowsUpdateClient, which Windows writes to the System log, not to the WindowsUpdateClient/Operational one). The run looks at what was installed in the last 15 minutes and skips Defender definitions and Microsoft Store apps, which install several times a day; it is recorded with the trigger "update". Windows does not wait for the backup: the installation goes on alongside it, so the version may already hold some of the update's files, which is harmless for your own files. While such a backup runs, Vaultik in the notification area holds up the restart that follows the update, like a sign-out ("Vaultik is finishing a backup..."); a restart Windows forces (at the end of the restart deadline) does not wait. For jobs with administrator rights the restart is not held up. - These runs skip a job that was backed up within the last few hours ("but not again within", 4 hours by default), so locking the computer ten times a day does not mean ten backups.
- Continuously: the tray icon watches the job's folders and starts a backup a few minutes
(5 by default) after the first change since the last one (
--on-change). Changes in excluded folders, the backup's own folder and Vaultik's settings do not count. With the change journal and "Only save a version when something changed" such runs take seconds.
Sign-out and continuous backups need Vaultik running in the notification area (Settings, Start with Windows), and are not offered for jobs with administrator rights: the tray would start them without those rights.
For S3-compatible storage, the cloud settings of a job have "Lock uploads for N days" (on the
command line: VAULTIK_S3_LOCK_DAYS, and VAULTIK_S3_LOCK_MODE=compliance). Every repository
file except the short-lived lock files is then uploaded with Object Lock until that date: a
delete only hides it behind a delete marker, and an overwrite only adds a newer version. In
governance mode (the default) that stops Vaultik's keys only if they lack
s3:BypassGovernanceRetention, s3:PutObjectRetention and the right to change the bucket's lock
settings, so give Vaultik a key limited to reading, listing, writing and deleting. Compliance
mode cannot be lifted early by anyone, the account owner included, so the data is also billed
until its date. The bucket must have Object Lock turned on (most providers
only offer that when the bucket is created; Vaultik checks before saving). Data removed by
cleanup stays billed until its lock ends, so a lock a little longer than the oldest kept version
is enough.
After an attack, vaultik cloud-rollback --job <job> --to "2026-11-09 20:30" --dry-run lists
the files that were deleted or overwritten since that time, and without --dry-run brings them
back: later delete markers and versions are removed, or the old version is copied over a later
one that is itself locked. Files added later stay; old lock files never come back. Then run
vaultik verify.
A long-term copy, usually the second copy, can keep its data in a cheaper storage class: in the
cloud settings of S3-compatible storage, "Storage class" (on the command line:
VAULTIK_S3_STORAGE_CLASS). Standard is the default; Amazon S3 also offers Infrequent Access
(STANDARD_IA, ONEZONE_IA), Glacier Instant Retrieval (GLACIER_IR), Glacier Flexible
Retrieval (GLACIER) and Glacier Deep Archive (DEEP_ARCHIVE). Most other providers
(Cloudflare R2, Backblaze B2, Wasabi, IDrive e2, MinIO) offer only Standard, or Standard and
Infrequent Access; a class they do not offer makes the first upload fail with a clear message.
Only the packs of file data and their repair data (data/, parity/) go to that class.
Everything small stays in Standard: the config, keys, recovery key, index, versions, locks and
the folder listings, which then go to packs of their own. So listing versions, browsing them,
opening the repository and backing up keep working as usual.
Infrequent Access and Glacier Instant Retrieval are read at once (each read is billed).
Glacier and Deep Archive must be restored for a while ("thawed") before a restore can read
them: vaultik cloud-thaw --job <job> [<version>|latest] [--path C/Users/me/Documents] works
out which packs restoring that version (or those files) needs and asks for a readable copy of
each (--days, default 7; --tier Standard|Bulk|Expedited). It reports how many were asked
for, are still being thawed and can be read already; run it again (or with --status, which
asks for nothing) to see how far it is. A thaw takes minutes (Expedited, Glacier only) to 12
hours (Standard), and up to 48 hours with Bulk or Deep Archive. A restore that reaches data
that is not thawed stops with a message naming cloud-thaw; the restore window of the frontend
offers to request the thaw instead.
Health checks cannot read Glacier or Deep Archive data: they check that every pack is there and
read the folder listings and versions, and say how many packs were only checked to be there.
Cleanup (prune) only deletes packs nothing uses any more and never rewrites partly used ones,
which would mean reading them. Repair needs every pack readable.
These classes have minimum storage durations: data deleted earlier is billed as if it stayed (on Amazon S3: Infrequent Access 30 days, Glacier Instant Retrieval and Flexible Retrieval 90 days, Deep Archive 180 days). Keep versions in such a copy for longer than that, so cleanup does not delete data that is still billed.
While backing up, Vaultik compares each changed file with its previous version. A document,
database or text file whose content went from compressible to random-looking is what encryption
by ransomware looks like (photos and videos look random already and never count), and so is a
file replaced by its name plus an extension (report.docx -> report.docx.locked). When at
least 20 files and 5% of the previous version's files look like that, the backup still saves
the new version but warns ("alert" in the history and the done event), pins the version
before it with a note, and the job skips removing old versions that run. The frontend shows the
warning and the tray icon turns red.
The Overview shows the drives a job uses (the backup drive, the second copy's and the drives
backed up from) with the health Windows reports for them, and flags a backup kept on the same
physical drive as the files it backs up. A backup drive that reports a warning or a failing
condition puts a banner on the Overview, and run-job records it in the history ("drive"),
so the tray says so too.
Each drive gets a health percentage where it can be worked out. For an SSD it is the part of its
rated life left, from the wear the drive counts. With administrator rights (see "Start Vaultik as
administrator" in Settings) Vaultik also reads the S.M.A.R.T. attributes of SATA and USB drives,
hard disks included: the health starts at 100% and loses weight x log2(1 + count) for each kind
of bad sector or error (reallocated 6, pending 8, offline uncorrectable 8, spin retries 10,
end-to-end errors 10, reported uncorrectable 4, reallocation events 2), so one reallocated sector
gives 94% and a hundred 60%; an attribute at its threshold caps it at 10%. Reallocated, pending or
uncorrectable sectors turn the drive's status into a warning, and a drive at 10% or less counts
as a problem. NVMe drives report their wear to anyone. vaultik drives lists every drive, and
vaultik drives --smart each drive's attribute table.
On Linux the drives come from /sys/block, and a folder's drives are found through its mount,
partitions, LVM or encryption (device-mapper), software RAID and loop devices. Vaultik asks the
drive itself, the same way and with the same percentage as on Windows: an NVMe drive's health log
(as on the Steam Deck), or a SATA or USB drive's attribute table through ATA pass-through, and
otherwise smartctl -j (smartmontools) where it is installed. Linux lets only root send these
commands, so as a normal user (and in the frontend) the health shows as unknown with the reason,
and the temperature where the kernel reports it; sudo vaultik drives reads it, and so does a
job run as root from a system timer. Memory cards (the Steam Deck's microSD slot) and virtual
disks have no S.M.A.R.T. data.
Vaultik also keeps a record of each drive's health (in drive-history.jsonl in its settings
folder, matched by the drive's serial number): a reading whenever the Overview, run-job or
vaultik drives looks at a drive, at most one a day unless something changed. A drive that got
worse in the last 90 days (more reallocated, pending or uncorrectable sectors, more unrecoverable
read errors, or a health percentage at least 5 points lower) counts as a problem even while
Windows still calls it healthy: the Overview lists what changed and shows a banner (for the
backup drive: copy the backup elsewhere; for a drive backed up from: keep the backup current),
and run-job records it so the tray warns. vaultik drives --history lists the stored readings.
After run-job saves a version, it runs the job's health check when one is due (--no-check
skips it). The weekly check reads a share of the stored packs back (10% by default, a different
share each week, always at least one pack), checks their hashes and decrypts every chunk in
them; the monthly check reads everything. Both also check that every version's folders and
files point at data that exists. A check is its own entry in the job's history ("kind": "check" or "full_check"), so a damaged drive turns the tray icon red and shows a
notification. check-job <job> [--full] runs one now; verify --read-data --read-share 10 does
the same on any repository. New cloud jobs skip the monthly full check, since it downloads the
whole backup.
Vaultik remembers on this PC (in checks in its settings folder, never in the backup) when each
stored pack was last read back intact, for the backup where it is: a copy of the backup on
another drive or in another folder starts from scratch. The weekly check reads the share read
longest ago, so over the weeks every part of the backup is read (packs in archive storage, which
cannot be read without a thaw, take no part of it). The scheduled monthly full check reads for at
most 3 hours per run by default (the job's Schedule tab: "at most ... per run", or no limit); when
the time is up it stops calmly ("the rest after the next backup"), and the next check goes on
where it stopped, also after a cancel or an unplugged drive. A full check is complete once every
pack was read since that monthly round began, so each pack is read once every round. One that found
damage is alerted at once, and the round is not complete; a damaged pack counts as visited, so a
pack that stays damaged does not keep the round open: the next round reads every pack again.
Packs found in archive storage although the job does not say it keeps data there (an S3 lifecycle
rule moved them) are remembered, take no part of the checks' reading and keep no full check open;
the check says how many are in archive storage and could not be read. A full check you start yourself (the app,
or check-job <job> --full) reads everything, without a time limit; --budget makes it keep to
the job's limit and go on where it stopped next time. While a check reads, the app shows how far it is
as a percentage of the data it reads this time, with the time left (smoothed over the last half
minute, as for the drive cleanser); --json gives "done" and "total" bytes in its
check_progress events.
Several jobs that back up to the same repository (the same folder on the same drive, or the same cloud storage) share their checks: one completed check of the repository counts for all of them, so the repository is not read once per job, and what it read is remembered for all of them. The check of each job's own files on this PC (below) is not shared: when another job checked the repository and the job's own schedule calls for a check, a job whose files were not compared in the last 7 days (30 with only the monthly check on) still gets that comparison after its backup.
Only a check that read what it set out to read counts as done. A check that could not finish (the drive was unplugged part way, say) or was cancelled does not: it stays due and runs again after the next backup, and one that could not finish shows a notification and sends a "health check could not finish" alert (with "failure" alerts on, at most one a day per job; one that no channel took, with no network yet, say, goes out with the next run instead of a day later).
Each check also looks for silent damage on this computer ("bit rot"): it reads up to 20 files back from this PC (at most 256 MB, for at most 2 minutes, within the job's resource limits) whose size, modification time and creation time are still as the newest version of this computer stored them, and that were last written at least a day before that version. It hashes them the way the backup does and compares the result with the stored content. A file whose content changed while nothing wrote to it was changed by the drive (or bad memory, or a cable), not by a program: the check then warns, names the files, and says that the backup holds the earlier good copy and from which version to restore it, on the Overview (a banner), in the Activity tab, as a notification, to the alert channels ("damage" alerts) and in the Event Log (a warning, event 205). Files that are locked or cannot be read are skipped, and the files are only read, never changed. The check can be turned off in the job's Schedule tab.
A health check proves the stored data reads back; a test restore proves files come back. It
picks up to 20 files at random from the newest version (at most 500 MB together), restores each
one into a temporary folder, checks that it comes back whole (every chunk decrypted and matching
its hash, the size as stored) and, when the file on this PC still has the same size and
modification time, compares the two byte for byte. Then it removes the folder again. The result
is its own history entry ("kind": "restore_test"), shown on the Overview, and a failed one gets
a banner and a notification.
Run one any time with Test a restore on the Overview or vaultik test-restore <job>
(--files <n>, --max-size <size>). In the job's Schedule tab, "Once a month, test a
restore of a few files" (off by default) runs one after a backup when the last is 30 days old.
The temporary folder is made in Vaultik's settings folder, or for a run with administrator rights
in the admin-only store, never in a folder a less privileged program could tamper with.
Move to this PC... in the restore window (or vaultik move-here --job <job>, or -r <repository>, with a version, latest by default) finds an old computer's account in a backup,
<drive>\Users\<name>, and puts its Documents, Desktop, Pictures, Music, Videos, Downloads,
browser profiles, email and game saves into the same folders of your account on this computer,
wherever they are here (another user name, Documents in OneDrive, another drive). You choose what
goes; files already there are left alone unless you tick the box (--overwrite), and the old
account's permissions are never applied. --dry-run lists what goes where; --only documents,browsers picks groups or single items; --account picks one when the backup holds
several. Close the browsers and email programs first; saved browser passwords were sealed for the
old account, so browsers ask you to sign in again.
Export settings and plans... (Tools in the sidebar) saves Vaultik's settings (notification
area, reminders, updates), the alert settings and every backup job in one file,
Vaultik-settings-<computer>-<date>.vaultik-settings. By default it holds no password, cloud
storage key, database password or alert token. Include the passwords and cloud storage keys
adds them, and then the whole file (jobs and folders too) is encrypted with AES-256-GCM under a key
derived from a password you type (PBKDF2-HMAC-SHA256, 600,000 rounds), so nothing is written in
clear; keep that password apart from the file.
Import settings and plans... on the other computer reads the file (asking for its password
when it is encrypted; a wrong one is refused), shows its jobs to choose from, and for a job whose
id is taken there either imports it next to the existing one (under a new id, "(imported)" after
its name) or replaces it. Imported jobs keep their schedule but start paused, so nothing runs
before you checked their folders and destination on the new computer: choose Resume schedule
for each then. A job imported without its password asks for it the first time it runs or is
opened (Edit job shows "not saved on this computer yet"), and one on cloud storage needs its key or
sign-in entered again in Edit job > Cloud storage.... A file from a newer Vaultik (a newer
format) is refused with a note to update. The list shows which jobs run a command before or after
the backup or run with administrator rights; those are left out unless you tick Keep the
commands and administrator rights (--keep-commands), since a file from someone else could
run anything on this computer. The alert settings are imported only when ticked (--alerts),
and the window shows where they send alerts. Every chosen job is checked before anything is
written, so a damaged file changes nothing (and removes no saved password). When the schedule of
a replaced job cannot be removed (an approval was declined), Vaultik says so: that job may still
run on its own until it is paused.
vaultik settings export # Vaultik-settings-<computer>-<date>.vaultik-settings
vaultik settings export moving.vaultik-settings --with-secrets
vaultik settings import moving.vaultik-settings --jobs documents,photos
vaultik settings import moving.vaultik-settings --replace --alerts
From the command line the password comes from --password-file, VAULTIK_SETTINGS_PASSWORD or
the console; the frontend's own settings are exported and imported by the frontend only.
Each version of a saved job also keeps the list of programs installed on the computer (name,
version, publisher; turn it off in the job with "Keep a list of the installed programs"). It is
read from the Windows uninstall list, leaving out system components, parts of other programs and
updates, and matched to winget packages where winget is there for your account; an unchanged list
is stored once. A backup within a day of the job's last one keeps that version's list instead of
listing again (continuous and triggered backups run often, and winget takes a while). vaultik backup keeps it only with --apps.
On a new computer, Reinstall programs... in the restore window shows the programs of that
version that are not installed here. Those with a winget package can be ticked and installed one
after the other; winget installs each silently as you, and Windows asks for administrator approval
when an installer needs it (Vaultik never runs it with those rights itself). The others are listed
with their publisher and version, to install by hand. From the command line, vaultik apps [<version>] --job <job> (or -r <repository>) lists them, --missing only those not on this PC,
and vaultik apps install <id>... [--snapshot <version>] installs packages of that list (no
other ids are taken).
The disk files of a WSL distribution (ext4.vhdx) and of a Hyper-V machine (.vhdx, .avhdx)
are open while it runs, so a plain file backup gets a half-written copy or none at all. The
Virtual machines tab of a job backs them up through their own export tools instead:
- WSL distributions: each ticked one is exported with
wsl --export <name> -, streamed straight into the backup as the fileWSL\<name>.tarof the version (no copy on disk first; deduplication stores only what changed since the last export). Itsext4.vhdxis left out of the file backup automatically. Exporting a running distribution can catch files half-written, so by default a running one is left out that time with a warning (and old versions are kept); the job can instead export it while it runs, or stop it first (wsl --terminate, which closes the programs running in it; it starts again when next used). Vaultik never stops a distribution unless the job says so. WSL belongs to your own account, so this is for jobs without administrator rights. To get one back, pickWSL\<name>.tarin the restore window and choose Import as new...: it is installed as a new distribution withwsl --import <new name> <folder> -, fed from the backup. An existing distribution of that name is replaced only after you confirm it, and only after the whole export was read from the backup and checked (it is unregistered first, which deletes its disk, so a damaged backup must not get that far). The.tarcan also simply be restored as a file. - Hyper-V machines (a job with administrator rights): each ticked machine is exported with
Export-VM(a consistent copy, also of a running machine, through a checkpoint Hyper-V takes and merges itself) into an export folder (ProgramData\Vaultik\hyperv-export, or a folderVaultik Hyper-V exportmade in the folder you set, which itself is left as it is; only administrators can read the export folder, and it needs room for the largest machine), backed up from there as the folderHyper-V\<name>with its configuration and disks, and removed again. Exports left behind by a run that was killed are removed by the next run. The machines' own disk files are left out of the file backup. List machines needs Vaultik started as administrator; a machine can also be added by name. To get one back, pickHyper-V\<name>and choose Import as new...: its files are restored into<folder>\Exported, then imported (after an administrator approval) withImport-VM -Copy -GenerateNewIdinto<folder>\Machineunder a new name; an existing machine is never replaced.
From the command line: vaultik backup ... --wsl <name> [--wsl-running skip|export|stop] --hyperv <machine> [--hyperv-staging <folder>], vaultik wsl list, vaultik wsl import <version> <distro> --name <new name> --to <folder> [--replace], vaultik hyperv list and, as
administrator, vaultik hyperv restore <version> <machine> --to <folder> [--name <new name>]
(or vaultik hyperv import <restored folder> --to <folder> for files restored already).
Docker keeps a named volume's files inside its own storage (Docker Desktop's virtual disk on
Windows, /var/lib/docker on Linux, which only root can read), so a file backup does not reach
them. The Docker volumes list on the Docker and databases tab of a job backs them up
through Docker instead (List volumes asks Docker for them, also which running containers use
each one; a volume can also be added by name):
- Each ticked volume is mounted read-only into a throwaway container that runs
tar -cover it, and its output is streamed straight into the backup as the fileDocker\<volume>.tarof the version (no copy on disk first; deduplication stores only what changed since the last export). The container runs from an image already on this computer (busybox, alpine, debian or ubuntu, or Windows' nanoserver or servercore in Windows containers mode, or the one the job names), without network, and is removed afterwards; Vaultik never downloads an image. With none there, the run says which one to get once (docker pull busybox). - Containers using the volume keep running and are never stopped, restarted or changed. A database running in one may then be saved half-written, so the run warns about every chosen volume that a running container uses: dump such a database too (see "Database dumps" below), which gives a consistent copy.
- When Docker is not running (or not installed), or a volume is gone, the run says so plainly and that volume counts as an item that could not be read: the rest is backed up, and old versions, which still have it, are kept.
- To get one back, pick
Docker\<volume>.tarin the restore window and choose Import as new...: a NEW volume of the name you give is created and the export is unpacked into it bytar -xin a throwaway container. An existing volume is never written to: a name that is taken is refused, and when the import fails, the volume it created is removed again. The.tarcan also simply be restored as a file.
Docker volumes and database dumps run programs of your own account (found on PATH), so they are
for jobs without administrator rights. From the command line: vaultik backup ... --docker-volume <name> [--docker-image <image>], vaultik docker list and vaultik docker restore <version> <volume> --name <new volume> [--image <image>].
When a check or a restore found damage (a bad sector on the backup drive, a file changed by
something else), Repair the backup... in a job's ... menu, or vaultik repair --job <job> (or
-r <repository>), keeps whatever is intact:
- It opens the backup without its index (so a damaged index file cannot stop it), reads every
pack, checks every chunk in it against its hash, and builds the index again from the intact
ones (
--quicktrusts the packs' own headers instead, reading no chunks). Packs that cannot be read at all stay where they are. - It writes the new index files, then deletes the old ones.
- A version whose manifest cannot be read is removed. A version with files whose data is gone, or folders whose listing is gone, is saved again without them, with a note saying what was lost; pins stay. The next backup stores those files again when they are still on the PC.
--dry-run shows what it would do. It holds the exclusive lock, like prune. From cloud storage
it downloads everything (with --quick, only the pack headers).
Repair data. A backup on a single drive has no second copy to fall back on, so each job also
keeps repair data next to its backup ("Repair data" in the job, 5% of the backup's size by
default for drives, off for cloud storage, which keeps its own copies): Reed-Solomon parity per
pack file, like a .par2 file. With it, Repair rebuilds a pack file damaged by bad sectors, cut
short or changed, as long as no more than about 5% of it is damaged (in one stretch or several),
before it would drop anything; a health check that finds such a pack says it can be rebuilt.
Data saved before repair data was turned on gets it during the health checks, or at once with
vaultik repair-data 5 --job <job> (off turns it off). Writing it adds about 60 ms per 32 MiB
pack on one core.
Windows notifications only reach someone at the computer. Settings > Alerts when you are away sets up alerts that the backup sends itself (so Vaultik need not be open), when a backup fails or skips files, when a check or test restore finds damage or a check could not finish, when a check finds files on the computer that changed by themselves, or the backup drive is failing, and optionally after every backup:
- ntfy (a free push notification app, ntfy.sh or an own server): the topic URL, an optional access token, and optionally an email address ntfy forwards the alert to.
- Telegram: a bot token (from @BotFather) and the chat id it writes to.
- Webhook: a JSON POST (
source,event,level,job,title,message,computer,time) to any https URL.
Alerts name the computer and the job and say what happened in fixed words, with counts; never a
run's own message, file names, paths or content, which stay in Vaultik's history. Settings are in
alerts.json in Vaultik's settings folder; the tokens are sealed like job passwords. URLs must
use https (http only to this computer). Save and send a test, or vaultik alert-test, checks
every channel. A job with administrator rights never reads your own alert settings: they are
copied into the admin-only store with the job, shown in the question before it is approved, and
updated the next time such a job is saved.
Send a monthly summary (off by default) also sends, at the start of each month, one short message about the month before: how many jobs and backups, how many succeeded, partly or failed, and how many things need attention, in the same fixed words and without job or drive names. The first backup of the month sends it, or Vaultik in the notification area when no backup runs.
Once a month Vaultik sums up every job from its run history: how many backups ran and how they ended, when the last one succeeded, how much data they added, how big the backup is and how much it grew over the month, the health checks and test restores and what they found, the second copies, what the backup drive reported, and drives whose health got worse. A list at the top says what needs attention: a job that has not saved a version for too long (2 days for an hourly schedule, 7 daily, 14 weekly, 31 by hand), a last backup that failed, damage found, checks or test restores that could not run, a failed second copy, a ransomware warning, a backup drive that reported a problem, a drive getting worse, or a backup drive that fills up within 30 days.
At the start of a month, Vaultik in the notification area shows a notification that opens the
report of the month before; Monthly report... in the sidebar (or the tray menu) shows any of
the last twelve months, and Save as... keeps it as a web page or a text file. The page is
self-contained (no scripts, no links). vaultik report prints it (--month 2026-10, by default
the month before this one; --html <file> writes the page; --json for scripts). The backup size
comes from each backup's history entry ("backup_size", the stored size of the whole destination
after the backup and its cleanup), so it is known from the first backup of this version on. Each
job's history keeps its newest 2,000 runs, over a month of hourly backups. Which month a run
belongs to follows the local calendar. A marker file in reports in Vaultik's settings folder
remembers that a month's notification and summary went out, so each goes out once, whichever
Vaultik process gets there first.
Every backup records the stored size of its whole destination and, for a folder destination, the
space left on its drive ("backup_size" and "free_space" in the history). From those Vaultik
works out how fast the backup grows and when the drive is full at that rate: "At this rate the
drive is full in about 6 weeks (grows 1.2 GiB a day)" on the job's start page, a "Drive space"
line per job in the monthly report and vaultik report. The growth is the median of the growth
per day between every two days of the last 90 (one size per day), counted from the last big
cleanup (a drop of more than 10%), so the small drops of the regular cleanup and a single odd day
do not throw it off, while a backup whose cleanup keeps it the same size shows as not filling up.
It needs sizes from at least 3 days spread over 3 days or more.
When the drive is full within 30 days, the start page says so, the tray shows a notification (once a week), the monthly report lists it under what needs attention, and the backup that first sees it warns and sends an alert to the alert channels (with "damage" alerts on). Keep fewer versions (the job's Old backups tab) or move the backup to a larger drive. Cloud storage reports no free space, so for it Vaultik only shows how fast the backup grows. Several jobs with their own backups on one drive each count the drive's whole free space, so with several the drive fills up sooner than each one says.
What grew (on the job's Overview, and in the banner when the drive fills up) lists the
folders that added the most new data to the backup over a period (the last 30 days by default,
or 7 days, 90 days or a year): what each version stored that the versions before it did not
have yet, at its stored (compressed) size, given to the folder of the file that brought it. A
folder is shown as specific as it can be while it still holds a share of the growth, so a
node_modules or a download folder shows up as itself. Where one of the ready-made exclusions
the job does not use leaves a folder out (developer folders, caches, temporary files...), or the
folder is a well-known one that is rarely worth keeping (Downloads, Temp, build output...), a
button adds the exclusion to the job; versions saved already keep the folder until they are
cleaned up. Below the list, each ready-made exclusion the job does not use says how much it
would have left out. Only the versions' folder listings are read, never the stored file data, so
it takes about as long as listing the newest version once plus what changed since.
vaultik grew -r <repository> (or --job <job> for that job's versions and exclusions) prints
the same (--since 30d, 2w, 12h or a date; --top <n>; --json for scripts).
A backup normally lists every folder and compares every file's size and times with the last
version, which takes minutes with hundreds of thousands of files even when little changed. Runs
with administrator rights (the runs of a job with administrator rights, scheduled or started with
Back up now in Vaultik started as administrator) read the NTFS change journal instead, which Windows keeps of every change on a
volume: a folder in which nothing was added, removed, renamed or changed since the last backup,
and which was not changed itself, is taken from that version without being read. A file with
several names (hard links) changed through one of them also counts as a change in the folders of
its other names. Inside a folder that was itself renamed, moved or created since the last backup
nothing is taken from it: two folders that swapped names leave no trace in the journal for what is
in them. Once a week, and
whenever the journal cannot answer (it wrapped, it was recreated, the job's folders or exclusions
changed, the last backup skipped files), every folder is read again. The journal's position is
kept with the job's settings (journal\<job>.json). Without administrator rights, on FAT and
exFAT drives and on Linux, every folder is read as before.
Windows' folder listing shows a file with several names (hard links) with the size and times of
its last change through that name, so a change through its other name would look like no change.
Vaultik remembers which files have several names and asks those files themselves. A file that
gets its second name only after a backup and is then changed through it is caught when the run
uses the change journal (it names the folders of the changed file's other names, and every file
in those folders is asked). Runs that read every folder (without administrator rights, and the
weekly full read) still miss it: for folders where hard links come and go (package stores, build
output), tick Check every file in the job's Schedule tab (--check-every-file), which asks
every file and makes scanning unchanged files about three times slower.
A job can back up whole disks instead of folders (What to back up: "Whole disks (disk image)"): every partition (Windows, its EFI system, MSR and recovery partitions, data partitions) and the partition table, so a computer whose disk died is brought back onto a new one, Windows, programs and all. NTFS volumes are read from a Volume Shadow Copy (one consistent moment for every disk of the job) and only their clusters in use (the volume bitmap); unused space, the page file and the hibernation file come back as zeros (a restore onto a disk with old data writes the start of each, so no hibernated Windows that was on that disk wakes up over the restored one). Other partitions (the FAT32 EFI partition, MSR, unknown file systems) are read byte for byte. The data goes into the same deduplicating repository as file backups, so the next image stores only what changed, and pruning, health checks, second copies and repair work on images as on any version. An image job needs administrator rights (its scheduled runs have them; Back up now works when Vaultik runs as administrator and the job has a schedule, since it then runs the approved copy of the job that the schedule runs), and its destination must be on another disk.
vaultik image disks # the disks, with their numbers
vaultik image backup -r E:\Backups\vaultik system # the disk Windows runs from
vaultik image info -r E:\Backups\vaultik latest
vaultik image restore -r E:\Backups\vaultik latest --vhdx D:\pc.vhdx
vaultik image mount -r E:\Backups\vaultik latest # its drives, read-only, until Enter
vaultik image restore -r E:\Backups\vaultik latest --to-disk 2 --boot
Restoring to a .vhdx file needs no administrator rights: File Explorer opens it (double-click)
and Hyper-V starts it (generation 2 for a GPT disk). image mount and Open its drives in File
Explorer in the restore window copy the image to a temporary virtual disk with new disk ids
and open it read-only, to take single files out. Restoring onto a disk replaces everything on
it, so it is guarded: never the disk Windows runs from, nor the one holding the backup or
Vaultik; the disk's model, size and serial number are shown and you type ERASE DISK <number>
(in the window or with --confirm). Disk numbers move when disks are plugged in or out, so
the restore stops, before writing, when the disk at that number is no longer the one shown (its
size, serial number or partition table id differ). The partition tables are written last: a
restore that stops halfway leaves a disk without partitions, not one with half-written ones.
The target needs the same sector size. A larger disk is fine (the partitions keep their
sizes). A smaller one works when the NTFS partitions can shrink to fit: the last NTFS partition
that can is shrunk first (typically the Windows partition), by whole MiB and only as far as
needed, and the partitions after it (a recovery partition) move down with their content, type,
GUID and attributes. image info shows how far each partition can shrink and the smallest disk
the image fits on; --size of image restore --vhdx may be smaller than the imaged disk, and
the restore window and the recovery menu offer smaller disks when the image fits on them. An NTFS
volume shrinks only down to just past its last cluster in use (nothing in it is moved), so a
volume with data near its end cannot shrink much; the volume Windows ran from keeps 1 GiB free;
volumes read while in use (without a shadow copy) are not shrunk. Before the first byte is
written, every file record of a volume to shrink is read and checked to have no data past the
new end; a volume whose bitmap disagrees with its files is refused (run chkdsk on it before the
next image). A shrunk volume gets what ntfsresize changes: its size in the boot sector (and the
backup boot sector in its new last sector), $Bitmap and the bad-cluster list cut to the new
size, an emptied $LogFile and the dirty flag, so Windows checks the volume once when it first
mounts or starts from it. Disk and partition ids stay the same, so the restored Windows starts as
before; --boot (or the recovery menu) also runs bcdboot to write its boot files. What a
shrink or a move does not fix (boot entries of moved partitions on MBR disks, the start recorded
in a moved FAT partition, the emptied $LogFile) is listed under "Current limits".
The disk Windows runs from is restored from the recovery drive (More > Create recovery
drive, or vaultik recovery-media --usb E: / --iso <file>): Windows PE with Vaultik on a
USB stick (erased; FAT32, so up to 32 GB) or an ISO file. It needs Microsoft's free Windows ADK
with its Windows PE add-on (winget install Microsoft.WindowsADK and winget install Microsoft.ADKPEAddon); the ADK, not the computer's own recovery environment, because WinRE
differs between computers, lives in a hidden partition and is often missing. Started from it, a
computer opens a menu: it finds backups on the connected drives (or a network share), asks for
the password, lists the disk images and the disks, and after the typed confirmation restores
and makes the disk start. Vaultik is one program with no other files, so the same drive works
for every computer.
Set up a new disk... (Tools in the sidebar, or More next to Create recovery drive...)
prepares a new, blank or unwanted disk for use, like a disk manager's "add new disk": it removes
what is on it, writes a new partition table (GPT, the default, or MBR for older computers, up to
2 TiB), makes one partition over the whole disk, formats it (NTFS or exFAT on Windows; ext4, NTFS
or exFAT on Linux) with the name given, and gives it a drive letter (Windows) or mounts it on
request (Linux). On a GPT disk Windows gets its usual 16 MiB reserved partition first. Never
offered: the disk Windows (or Linux) runs from, the disk holding the partition the computer
starts Windows from (the EFI system partition, or the "System Reserved" partition of an older
computer, even when it is on another disk than Windows), the one Vaultik runs from, a disk with
a page, swap or hibernation file, a dynamic disk, a Storage Spaces disk or a disk holding part of
a volume over several disks, a disk Windows keeps offline or read-only (bring it online in Disk
Management first), or (Linux) one used as swap or by LVM, RAID or encryption. A drive some
program is using (or, on Linux, a mounted one) can be forced closed (see
Drives in use).
When Vaultik cannot tell which disks Windows runs and starts from, it offers none. A disk from
another computer that holds its own Windows can be erased. As for a disk image restore, the
disk's model, size and serial number are shown and you type ERASE DISK <number> (Linux:
ERASE DISK sdb); the disk is checked again on the opened disk, before anything is written, to
be the one shown, and once more before it is formatted. It needs administrator rights and shows
how far it is in a status window of Vaultik (see
Tasks with administrator rights).
Windows writes the partition table with IOCTL_DISK_CREATE_DISK and
IOCTL_DISK_SET_DRIVE_LAYOUT_EX after locking and dismounting the disk's volumes, and formats
with format.com (from the Windows system folder), which gets the new volume's own name
(\\?\Volume{...}, without the closing backslash, which it refuses), never a drive letter
that another drive could take meanwhile; right before it runs, the letter given to the volume is
checked too to still belong to it, and nothing is formatted when another drive has it now; Linux uses sfdisk (through the disk opened
exclusively and checked) and mkfs.ext4 (mkfs.ntfs, mkfs.exfat).
vaultik disk list
vaultik disk init 2 --label Backups # GPT, NTFS, a free letter
vaultik disk init 2 --mbr --fs exfat --label CAMERA --letter K
vaultik disk init 2 --size 200G --size rest # two partitions
sudo vaultik disk init /dev/sdb --fs ext4 --label backups --mount /mnt/backups
Drive cleanser... (next to Set up a new disk...) erases so the data cannot be read back:
- A whole disk: every byte of it, then its partition table goes too, so Windows shows it as
not initialised (Linux: no partitions). The same guards and typed
ERASE DISK <number>as above. A disk without a partition table has no drive, so File Explorer does not show it; that is why When done, set the drive up again is checked: right after the erase the disk is set up for use again, in the same run and with the same approval prompt, so it comes back ready (for example asF:namedBackup, NTFS). You choose the partition table (GPT, or MBR on a disk of 2 TB or less), the file system (NTFS or exFAT; on Linux ext4, NTFS or exFAT), the name (the one the drive had, orBackup) and the drive letter (the one it had; when it had none, any free letter, picked when the erase is done). A letter Windows has given to a drive that shows nothing, such as an empty card reader slot, an empty DVD drive or a locked BitLocker drive, counts as taken and is not offered. Should another drive have taken the letter you chose by the time the erase ends, it stays with that drive: the new drive keeps the letter Windows gave it and the window says so. A letter the disk's own drive has never counts as taken, since setting the disk up removes that drive. This is the same setup as Set up a new disk..., on the very disk that was erased: it is checked again to be that disk (serial number, size, model and connection, and blank now, also without a file system or encryption on the whole disk) before anything is written. A USB stick or SD card that Windows treats as removable media keeps one drive (with its letter, but without a file system) even when it has no partition table; that one drive counts as blank. On Linux, the programs the setup needs (sfdiskand themkfstool of the file system chosen) are looked for before anything is erased. The setup runs only after an erase that went through to the end (and passed its check, with Read the last pass back); after an erase that was stopped or failed, the drive is not set up, and the window says so. When the erase worked but the setup failed, the window says why and offers Set up the drive to try the setup again: it shows the disk once more and asks before it starts, and it works only on the same disk, still blank, or with exactly the partition table the failed setup had written (when it failed while writing that table: blank, or with exactly that table). It keeps the letter you chose, also when the failed setup had already given it to the new drive. Should another drive have taken that letter meanwhile, it stays with that drive: Windows gives the new drive a free letter (you can change it later), and the window says so before it starts. - One drive (volume): only that partition (
ERASE E:, LinuxERASE sdb1); never the one Windows or Vaultik runs from, nor one with a page or hibernation file, nor an EFI system, reserved, recovery or active partition, nor a volume on a dynamic disk or over several disks. It is locked and dismounted first (see Drives in use). The drive is checked again just before it is written to, to be the one listed (Windows: its volume id, size and serial number; Linux: its partition id, where it starts, its size and the disk's serial number), so a USB stick swapped for another one in the meantime is not erased. - Only the free space of a drive: a temporary file fills the free space and is deleted again, so files deleted earlier cannot be brought back. The files on the drive are not touched, it needs no administrator rights, and it shows its progress and can be stopped in the window. The file is not compressed, and it goes away when the program ends, also when it is killed (one left over after a power cut is removed the next time). On a drive that compresses it anyway, random data is written instead of zeros; a drive that keeps even that compressed (ZFS with deduplication, say) stops with an error.
The methods are one pass of zeros (the default, enough for today's drives), one pass of random
data, and three passes (random, random, zeros, like DoD 5220.22-M); Read the last pass back
checks that the drive kept what was written. Several large writes (and, for the check, reads)
are kept at the drive at once, so it never waits for the next one, and a pass counts as done only
once the drive says it has written everything. Vaultik's status window shows the pass (or the
check), how far it is, the speed and the time left (from the speed of about the last half
minute, so it follows a hard drive that slows down towards its end); Cancel there stops it
after asking (what was written stays overwritten), as Ctrl+C does on the command line. From the
command line --confirm gives the confirmation beforehand, for scripts, and --expect-size,
--expect-serial and --expect-id (which the Vaultik window passes along) make it stop when the
disk or drive is another one by then.
On the command line, --then-init gpt (or mbr) does the same after erasing a whole disk,
with --fs, --label and --letter (Linux: --mount) as for disk init. It ends with exit
code 9 when the disk was erased but setting it up failed; with --json, its done event then
tells with table_written and table_id whether a new partition table had been written, so
disk init with --expect-id <table_id> sets up that same disk again.
vaultik disk wipe 2 --method dod3 --verify
vaultik disk wipe 2 --then-init gpt --fs ntfs --label Backup --letter F
vaultik disk wipe --volume E: --confirm "ERASE E:"
vaultik disk wipe-free D:
Erasing a disk or drive, setting up a new disk, restoring a disk image onto a disk and making a
recovery drive need administrator rights, which the Vaultik window itself does not have. After
the approval (UAC) prompt, Vaultik starts its engine with those rights without a console window
and shows a status window instead: a progress bar with the percent, how much of how much is
done (23.1 GiB of 4.55 TiB), the speed and the time left (33 h 06 min left), the pass or
step it is at (Pass 2 of 3, Checking what was written), and a Cancel button that asks
first. At the end the same window says whether it worked, or why not. Setting up a new disk
takes moments and cannot be stopped halfway; making a recovery drive stops after the step it
is at.
The engine sends its progress over a private channel that the window makes for each task: on
Windows a named pipe with a random name (\\.\pipe\vaultik-progress-...) that only you and
the administrators can open, made as the only one of that name, and that programs running
with low integrity (such as a sandboxed browser) can neither read nor write; the engine checks
that the program serving it runs as you, and the window takes only the engine it started and
drops any other program that connects. On Linux a folder only you can open with two FIFOs in
it, which the engine opens through the folder it checked, without following links. Only the
progress, the steps, the drives in use and the result go over it (never a password), and only
cancel comes back (the engine keeps at most 4 KiB of a line). The engine refuses any other
name. While it is connected the engine asks nothing in its hidden console: a task that would
need an answer there (such as a password) stops with an error that the status window shows. A
task cannot be ended from a program without administrator rights, so Cancel asks the
engine over the channel to stop, and the window waits until it has (it stops writing at once).
When the channel breaks while the task runs, the window says that it can no longer be stopped
from there and lets you close it; the task finishes on its own. Vaultik can be closed while
such a task runs, after a question: the task goes on and finishes, only its progress is not
shown any more (a disk left half erased or half restored would be worse). When the channel
cannot be made, or the engine has not connected 20 seconds after the approval, the engine shows
its progress in a console window of its own as before (Ctrl+C there stops it), and the status
window says so; an engine that connects later still brings back the progress and Cancel.
On Linux Vaultik starts the engine through pkexec, which asks for the password in a window of
its own (the status window waits for it as long as it takes); without pkexec, the Vaultik window shows the sudo command to run in a terminal
instead. A task with root rights that cannot use the status window's progress channel stops at
once, before it changes anything, and the window says so (it has no window of its own to show
its progress in). Restoring a disk image onto a disk and making a recovery drive are Windows only.
From the command line, --progress-pipe <name> (with --progress-user <user>) sends the
--json events to such a channel instead of the standard output.
Erasing a disk or drive and setting up a new disk first lock every drive on it (Windows), so
nothing else writes to it meanwhile. That fails while a program has a file or folder open there:
File Explorer, Windows Search, a virus scanner or backup software. Vaultik then stops before
writing anything, names the drives (F: is in use by another program) and ends with exit code
6 (with --json: an in_use event and a done event with status in_use, both listing the
volumes; with --in-use-file <file>, the drives in use are also written to that file, one
per line). The Vaultik window then asks whether to force the drives in use closed, naming
them; with Force close
and erase (or Force close and set up) it runs the same job again, with the same checks
and without asking for the confirmation again, and the drive is taken away from the programs
using it, as format /X does: they lose access to their open files there, and unsaved changes to
those files are lost. From the command line, --force-dismount does that: each drive that
cannot be locked is dismounted by force (FSCTL_DISMOUNT_VOLUME), opened again and locked
through that new handle (never through the one that dismounted it), and stays locked until the
job ends, so Windows cannot mount it again meanwhile; when even then it cannot be locked, the
job stops with an error and nothing is written. A drive that cannot be locked for another
reason than a program using it is not offered to be forced: the job stops with that error. On
Linux a mounted partition is in use: --force-dismount unmounts it first with umount (never a
lazy unmount), and a file system still busy stays mounted and stops the job, naming its mount
point. When another drive is mounted over it at the same folder, nothing is unmounted and the
job stops, naming that drive. A swap partition in use, and a member of a btrfs file system over
several drives, are still refused. On Linux the Vaultik window asks before it starts the task
(or shows the sudo command), and adds --force-dismount only when you agree. Every other check (the disk the system,
Windows or Vaultik runs from, page files, pools, the drive shown, the typed confirmation) comes
first and is as strict as without the option; nothing is forced without it.
vaultik disk wipe --volume F: --confirm "ERASE F:" --force-dismount
sudo vaultik disk init /dev/sdb --force-dismount
Solid-state drives (SSD, NVMe, memory cards): overwriting reaches every block the computer can see, but not the spare blocks the drive keeps for itself (for wear levelling and bad blocks), which may still hold old data. Vaultik does not send the drive's own secure erase command (NVMe Format with Secure Erase, ATA SECURE ERASE): done wrong it can leave a drive locked or unusable, and many computers block it. Use the drive maker's tool or the computer's firmware setup for that, or keep the data on an encrypted drive (BitLocker, LUKS) from the start. Wiping free space does not reach small files NTFS keeps inside its file table, nor the slack at the end of files.
Each run of a job (backup, second copy, health check, test restore) writes every warning in full
to a log file of its own: each file that was skipped and why, each problem a check found, what a
command printed when it failed, and the result at the end. The history keeps only counts and the
first few, so the log is where to look for the whole list. Logs are in logs/<job> in Vaultik's
settings folder, at most 4 MiB each (a longer one says where it was cut short), and the newest 30
of each job are kept. The run's history entry names its log ("log"), and in the Activity tab a
double-click (or the menu) opens it.
Every run of a job (backup, second copy, health check, test restore) is also written to the
Windows Event Log (Application, source Vaultik; syslog on Linux), so Event Viewer and monitoring
tools see failed backups without any alert set up. The event id tells what it was: 100s a backup,
200s a health check, 300s the second copy, 400s a test restore; the last digit is the result
(0 success, 1 partial, 2 failed, 3 cancelled, 5 succeeded with a warning: ransomware signs, old
versions kept, the drive's health, or files on this computer that changed by themselves). Failures are errors and warnings are warnings. Every
account of the computer can read that log, so an entry says only which job ran, what kind of
run it was, how it ended and how many files it saved, never its messages (which name files);
those stay in the Activity tab. The
installer registers the source; the portable version writes the same entries, which Event Viewer
then shows after a note that the source is not registered.
A job can run a command line before its backup and one after it (What to back up tab:
"Before the backup, run" and "After it, run"), as typed in a command prompt (cmd.exe on
Windows, /bin/sh on Linux): for example a database dump into a backed-up folder before, or
starting a program again that the first command stopped. When the "before" command fails (an
exit code other than 0), nothing is backed up and the run fails with that reason. The "after"
command runs once the "before" one succeeded (or there is none), whatever the backup's result,
before the second copy and the checks; VAULTIK_RESULT holds the result (success, partial,
failed, cancelled), and VAULTIK_JOB and VAULTIK_JOB_NAME the job. The start of their
output goes to the log; a failing "after" command is a warning. They run with the job's rights:
for a job with administrator rights, as the system account, from the approved copy of the job in the
admin-only store, so a program running as you cannot change what they are. Since the job file it
is copied from is yours, and any program running as you could have added a command to it, the
elevated step that copies the job shows the exact commands and asks before it copies new or
changed ones; a program without administrator rights cannot answer that window for you. That
window shows everything that gives the job its power: the commands, the destinations with their
keys, server keys, Object Lock and storage class, the second copy, which old versions are
removed, the folders, the whole disks of an image job and the Hyper-V machines with their export
folder; a job too large to show in full is refused rather than shown in part.
With "Start Vaultik as administrator" (Settings), Vaultik runs with your full administrator token without asking each time. Your job files stay yours, and any program running as you could change them, so in that window too nothing they say gets administrator rights without an approval: the backups, checks, test restores and repairs of jobs, and the runs it starts by itself (continuous, when a drive is connected, at sign-out, asked by another computer), run with your own rights, as they would without that setting. A job with administrator rights backs up with them through Back up now from its approved copy (the one its schedule runs, with checked commands). What you start in a window that shows what it does (a restore, a disk image restore, installing programs again) keeps the administrator rights. The engine also refuses, whenever it has those rights without being an approved administrator job, to start a job by itself or to run a job's commands.
A database writes to its files all the time, so a copy of them taken while it runs (by a file backup, a shadow copy without its writer, or a Docker volume's export) may not open again. The Database dumps before the backup list on the Docker and databases tab has the database write a consistent copy of itself first, with its own tool, which is then backed up. It saves writing the command for "Before the backup, run" by hand:
- SQL Server:
sqlcmdrunsBACKUP DATABASE ... TO DISK ... WITH COPY_ONLY. A copy-only backup stands outside the database's own backup chain, so its regular full, differential and log backups go on as before. SQL Server writes the file itself, so the server must be this computer (.\SQLEXPRESS,localhost; its service,NT SERVICE\MSSQLSERVERorNT SERVICE\MSSQL$<instance>, is given write access to the dump's folder) or run in a Docker container. An empty user signs in with your Windows account. - MySQL and MariaDB:
mysqldump --single-transaction(ormariadb-dump), which reads InnoDB tables from one consistent snapshot without locking them, as SQL text. - PostgreSQL:
pg_dump -Fc, its compressed custom format, restored withpg_restore.
Each dump is backed up as Databases\<name>.bak, .sql or .dump (the name is the database's
unless the job gives another). For a database in a Docker container, name the container: the
tool inside it runs through docker exec and its output is copied out (SQL Server writes the
backup inside the container, which is copied out and deleted there). When the tool is not
installed, the run says which one to install; it is looked for on PATH and in the folders its
installer uses (C:\Program Files\PostgreSQL\<version>\bin and the like). Test in the
database's window makes a dump right away into a temporary folder and removes it again.
The password is stored like the job's own (sealed for your account, see "Programs") and never
put on a command line, where other programs could read it: sqlcmd gets it in its
SQLCMDPASSWORD variable, mysqldump from an option file and pg_dump from a password file
(each in a private folder, removed right after the dump), and a tool in a container through
docker exec -e, which takes the value from the environment of the docker command alone. The
dumps are made in a private folder of your account (Windows: Vaultik\Temp\databases in your
local application data folder; Linux: ~/.cache/vaultik/databases, or under $XDG_CACHE_HOME),
not in the shared temporary folder, where another account could make the folder first. Only your
account can read the dump files. They are read from there by the backup and removed when the run ends; dumps left by a run that was killed are removed by
the next one. A dump that fails is a warning (with the tool's own message) and an item that could
not be read: the files and the other dumps are still backed up and old versions are kept. Dumps
are for jobs without administrator rights.
From the command line: vaultik backup ... --database <spec> (repeatable), with the password in
VAULTIK_DB_PASSWORD, and vaultik db dump <spec> --to <folder> to try the settings. A spec is
kind://[user@][host][:port]/database[?container=<name>&name=<name>], kind sqlserver, mysql
or postgres, with %XX for characters that would be read otherwise:
postgres://app@localhost/shop, sqlserver://.\SQLEXPRESS/Sales,
mysql://root@/wordpress?container=wp-db.
Backups, restores and checks of the same repository can run at the same time, also from several
computers. forget and prune need the repository to themselves: they wait for nothing by
default and stop with exit code 5 when another run is active (--lock-wait 10m waits instead;
scheduled jobs wait up to 10 minutes). A run that crashes leaves a lock behind that expires at once
on the same computer and after 2 hours for the other computers (a computer whose clock runs ahead
cannot take a live lock for an old one); vaultik unlock removes expired locks and
vaultik unlock --all every lock.
Every command, and every saved job, can control how much of the computer it may use, so a backup can run while you work without slowing anything down.
vaultik backup -r E:\Backups\vaultik C:\Users\me --priority low
vaultik backup -r \\nas\backups\vaultik D:\Projects --priority background --write-limit 20M
vaultik restore -r E:\Backups\vaultik latest --target D:\Restore --priority high
| Option | Values | Windows | Linux |
|---|---|---|---|
--priority |
background, low, normal (default), high |
Preset for the three priorities below | same |
--cpu |
idle, low, normal, high |
Process priority class | nice 19 / 10 / 0 / -5 (high needs root) |
--io |
background, low, normal |
I/O priority hint on every file | ioprio idle / best-effort 7 / default |
--ram |
low, normal |
Memory priority: Windows reclaims Vaultik's pages first | no equivalent, ignored |
--cpu-limit |
1-100 |
Hard cap, percent of total CPU (Job Object) | same, enforced by pausing |
--max-memory |
size, at least 128M |
Hard cap on committed memory (Job Object) | address-space limit |
--read-limit |
rate, e.g. 50M |
Max read speed per second | same |
--write-limit |
rate, e.g. 20M |
Max write speed per second, also to network shares | same |
--threads |
0-16 |
Threads that compress and encrypt (default up to 4, 0 at background priority or with --max-memory) |
same |
--read-threads |
1-16 |
Files read, chunked and hashed at once (default up to 4, 1 at background priority or with --max-memory); each reader holds up to about 16 MiB |
same |
Presets: background = CPU idle, I/O background, RAM low; low = CPU low, I/O low, RAM low;
high = CPU high. Individual options override the preset (--priority low --cpu normal).
run-job uses the job's saved settings; options given on its command line override them.
Priorities only take effect when something else competes for the resource, so on an idle PC a
low backup runs at full speed. Limits apply all the time; --read-limit and --write-limit
are totals, shared by all of a backup's threads. Sizes and rates use binary units
(512K, 64M, 1.5G). Restores from the frontend run at normal priority without limits.
- Open and locked files (Outlook data files, databases, files of running programs) are only
backed up when the backup runs with administrator rights (a job with administrator rights, or
vaultik backupfrom an elevated prompt): it then reads from a Volume Shadow Copy, a frozen view of each source volume made at the start of the backup. Without those rights, and on Linux, files are read live: locked files are skipped with a warning, and a file being written during the backup may be captured mid-change. Scheduled jobs get those rights only with the job's "Run with administrator rights" option, which needs Vaultik installed in a folder only administrators can change. The backup destination of such a job is still a folder you can change; keep it on a drive used for backups only. - Windows: file content, attributes, creation and modification times, permissions (owner, group
and access list), alternate data streams of files (not of folders) and symlink/junction
targets are kept. Restores bring
streams and links back always, permissions when restoring to the original location (or with
--permissions): restored into another folder, another account's permissions could lock you out of your own files. Setting another account as owner needs administrator rights; without them the access list is applied alone. Permissions go only on files and folders the restore creates itself, checked by their file id (or through the handle the folder was made with), never on a folder that was there already or on whatever a link put in their place points at. Audit settings (SACLs) are not kept. Backups with these extras need Vaultik 0.6 or later to restore. Linux: content, permissions, owner (restored when running as root), modification time and symlinks are kept; extended attributes and ACLs are not. A restore running as root goes only through folders that root alone can change (so another account cannot swap one for a link to/etc): restore into a new folder under/rootand move the files, or restore as the account that owns the folder. Kernel file systems (/proc,/sys,/dev, tmpfs) are skipped. - Disk images: basic disks only (not dynamic disks or Storage Spaces); a BitLocker volume is
stored as its unlocked content and comes back unencrypted (turn BitLocker on again after a
restore). A smaller target disk works only as far as the NTFS partitions can shrink without
moving data: down to just past each volume's last cluster in use (data near the end of a
volume keeps it large; defragmenting or Windows' own Shrink Volume before the image helps), and
never for volumes read while in use, MBR disks with logical partitions or volumes whose master
file table is too fragmented for one file record. FAT and other file systems keep their size.
A shrunk Windows volume is checked by Windows once when it first starts. A moved recovery
partition keeps its content, but Windows RE may need
reagentc /disableandreagentc /enablein the restored Windows to be found again (its configuration notes where the partition was), and old restore points (shadow copies) of a shrunk volume may be dropped by Windows. The target needs the same sector size. On MBR disks Windows' boot configuration (BCD) names a partition by where it starts, so its entries for a partition that moved (such as Windows RE on the recovery partition) point to the old place untilreagentc(above) orbcdbootwrites them again; the Windows partition itself never moves. A FAT partition that moves keeps the start written in its own boot sector ("hidden sectors", which only NTFS volumes get corrected): Windows does not use it, but starting a computer from that partition in BIOS (legacy) mode may fail until it is fixed with a disk tool. A shrunk volume's$LogFileis emptied: changes it still held that were not yet written to their place (none for a volume read from a shadow copy) are lost, as after a sudden power cut, which the check Windows makes at the first start deals with. - NTFS names that are not valid UTF-16 (unpaired surrogates, very rare) cannot be backed up.
- The program list knows only what the Windows uninstall list and winget know. Jobs with administrator rights run as the system account, which has no winget and its own per-user list: their versions list the programs installed for everyone, by name only, so none of them can be installed with winget from there. A backup or Vaultik started with administrator rights in your own account does not run winget either (it is found in folders your programs without those rights can change), so it lists programs by name only, and reinstalling needs Vaultik started without them. A program is "missing" when neither its winget package nor its name (without version numbers) is found on this PC.
- Restores and backups check for links planted in the folders they work on, but a parent folder swapped for a link during the run by someone who can write there is not detected. Run elevated restores into folders only you can write to.
- Compression and encryption run on up to 4 worker threads (
--threads), and up to 4 files are read, chunked and hashed at once (--read-threads): on a 12-core PC a fresh 9.7 GB backup took 1m43s instead of 2m12s single-threaded (peak memory 101 MB, before the parallel reading). Everything that touches the backup itself (storing chunks, the snapshot's listing) stays on one thread, and files are stored in folder order, so the result is the same with any number of readers. Several readers help most with many small and middle-sized files on a fast disk; one very large file is still read by a single thread, and a backup to a folder spends much of its time writing packs. So packs are written in the background while the next is built: 2 at a time for cloud storage, 1 for a folder (--uploads; each holds 32 MiB in memory), which about halves a first backup to a disk. At background CPU priority or with--max-memory, a backup stays on one thread, reads one file at a time and writes one pack at a time.
- Repository format, file backup/restore/verify, CLI (done)
- Saved jobs, scheduling, resource controls, Qt frontend on Windows, retention
(
forget/prune), repository locks, Volume Shadow Copy (done) - Cloud storage: S3-compatible storage (Cloudflare R2, Backblaze B2, Amazon S3, IDrive e2, MinIO) and cloud drives (pCloud, OneDrive, Google Drive, MEGA) (done, Windows)
- Friendlier versions (done): timeline, pins, notes, file history, search, cleanup presets, a start page per job (last result, next run, size, warnings, a calendar of backup days), and browsing a version in File Explorer (Windows Projected File System).
- Knowing backups work, and protecting them (done):
- Notifications and a tray icon (done).
- Health checks (done): after a backup, a check reads a sample of the stored data weekly and all of it monthly, so a failing drive is noticed before a restore needs it.
- Back up when the drive is plugged in (done): a job whose destination is an external drive runs when that drive connects (recognised by its volume ID, not its letter), then says it can be unplugged.
- Back up when something happens (done): when the computer is idle or locked, at sign-out or shutdown (holding Windows up until the backup is done), when Windows starts installing updates (holding up the restart after them), and continuously, a few minutes after files change.
- Ransomware warning (done): when a backup sees many files that look encrypted or were renamed with an added extension, it warns, pins the version before it and skips cleanup, so the last clean version is never removed automatically.
- Monthly report (done): what every job did last month and what needs attention, as a
notification, a page to save,
vaultik report, and optionally a summary to the alert channels. - Backup drive forecast (done): when the drive fills up at the rate the backup grows, with a warning a month ahead.
- Locked cloud copies (done): S3 Object Lock (Backblaze B2, Wasabi, Amazon S3) keeps uploaded
data undeletable for a set time, even with the keys, and
cloud-rollbackbrings it back. - Archive storage classes (done): a long-term cloud copy keeps its data in S3 Infrequent
Access, Glacier or Deep Archive, and
cloud-thawgets back what a restore needs.
- Portable version and installer (done for Windows): a portable folder that keeps its own settings, a copy of it kept on external backup drives with a how-to-restore note, and an MSI installer whose uninstall also removes the scheduled tasks. For Linux (8), written but not yet tested: an AppImage build (portable, kept on the backup drive next to the Windows programs) and a Flatpak manifest.
- More convenience and security (done): a second copy of each backup (3-2-1), a size and time
estimate before the first backup, comparing two versions with a side-by-side text diff,
"Earlier versions in Vaultik" in File Explorer's right-click menu, ready-made exclusions,
pausing a backup and a slower speed during working hours, a Bulgarian translation,
Windows Hello before backups are opened, and the installed programs kept with each version
to install again with winget on a new PC. Several PCs in one view (done): computers sharing
a repository see how each other's backups are doing, can ask each other to back up now, and
retired computers can be removed from the view. WSL distributions and Hyper-V machines
(done): backed up through
wsl --exportandExport-VMinstead of their open disk files, and imported back as new ones. - Linux port, SteamOS on the Steam Deck first (in progress). The review's hazards are fixed or decided (docs/LINUX_PORT.md); the cloud code has a libcurl client and the browser sign-in, drives are tracked by file system UUID, and the frontend has its Linux parts (single instance, autostart, drive watcher, inotify for continuous backups). It builds and passes its tests on Ubuntu 24.04, and the command line works end to end. A version opens as a folder through FUSE, and drive health reads NVMe and SATA drives (as root) with the same percentage as on Windows. Still to do: the AppImage on a Steam Deck.
- Disk image backup (done, Windows): whole disks from shadow copies, used space only, in the
deduplicating repository; restore to a
.vhdx, onto a disk, or browse an image's drives. Restores onto a smaller disk shrink NTFS partitions down to their used space (without moving data). Still to come: moving data to shrink further, images of Linux disks. - Bare-metal restore (done, Windows): a recovery USB stick or ISO (Windows PE from the ADK) that restores a disk image onto a computer that does not start.
Vaultik is free software under the GNU General Public License, version 3 (or any later version). It uses Qt (LGPL-3.0), zstd (BSD), BLAKE3 (CC0 / Apache-2.0), nlohmann/json (MIT), libssh2 (BSD) and doctest (MIT).







