SysopKit | Blog

Ephemeral Chrome Profiles in tmpfs

Mon, 28 Sep 2026 00:00:00 GMT

Chrome is write-heavy: shader and GPU caches, media cache, history, and session state churn on every page load. On an SSD-backed home directory that means constant small writes for data with no long-term value. Incognito mode avoids the writes but also drops logins and extensions, and a second persistent profile accumulates the same pollution as the main one.

The setup below takes a different approach: clone a real profile into tmpfs (/tmp), run Chrome there with an isolated --user-data-dir and --disk-cache-dir, and delete the copy when the window closes. Each session starts with working logins and extensions, no browsing history is written back to the SSD, and cache I/O never touches the disk.

The full script, for reference:

#!/usr/bin/bash
set -eEuo pipefail

CHROME_CONFIG_DIR="$HOME/.config/google-chrome"
if [ $# -gt 0 ]; then
    PROFILE_NAME="$1"
    shift
else
    PROFILE_NAME="Default"
fi
SOURCE_PROFILE="$CHROME_CONFIG_DIR/$PROFILE_NAME"

if [ ! -d "$SOURCE_PROFILE" ]; then
    echo "Error: Profile '$PROFILE_NAME' not found at $SOURCE_PROFILE"
    exit 1
fi

mkdir -p /tmp/google-chrome
TMP_ROOT=$(mktemp -d -p /tmp/google-chrome profile.XXXXXX)
TMP_USER_DATA="$TMP_ROOT/user-data"
TMP_DISK_CACHE="$TMP_ROOT/disk-cache"
CURRENT_LINK="/tmp/google-chrome/current"
# First running profile wins: don't steal the link from a live session.
if [[ ! -L "$CURRENT_LINK" || ! -d "$CURRENT_LINK" ]]; then
    ln -sfn "$TMP_USER_DATA" "$CURRENT_LINK"
fi

cleanup() {
    rm -rf "$TMP_ROOT"
    if [[ -L "$CURRENT_LINK" && "$(readlink "$CURRENT_LINK" || true)" == "$TMP_USER_DATA" ]]; then
        rm -f "$CURRENT_LINK"
    fi
}
trap cleanup EXIT INT TERM

mkdir -p "$TMP_DISK_CACHE"
mkdir -p "$TMP_USER_DATA/Default"

cp -r "$SOURCE_PROFILE/." "$TMP_USER_DATA/Default/"

google-chrome --disk-cache-dir="$TMP_DISK_CACHE" --user-data-dir="$TMP_USER_DATA" --no-first-run "$@"

Why a snapshot clone

Three options exist for a throwaway session, and only the clone preserves convenience:

Incognito — clean writes, but no logins, no extensions. Every session starts from zero.
Second persistent profile — keeps logins, but history, cookies, and cache accumulate permanently and still live on the SSD.
Snapshot clone — copies the source profile once at launch. The session starts already logged in, with extensions enabled; all writes land in tmpfs, and nothing is merged back. Closing the window deletes the copy.

Logged-in state is the major advantage over Incognito. The source profile acts as a credentials store: it is opened directly only for maintenance, while everyday browsing happens in disposable clones that inherit its cookies.

Keeping source profiles clean and lightweight

Because the whole profile is copied at every launch, the source profile should be kept small. The recommended setup is a dedicated profile per purpose (for example, one for development services, one for media): create the profile, log in to the services it needs, then clear the disk cache while keeping cookies. Clearing cache via Delete browsing data with only Cached images and files selected (time range All time) removes the bulky regenerable data without touching logins.

Session cookies expire. Some services, such as GitHub, require cookie revalidation roughly once a week. The refresh workflow is:

Launch Chrome once with the source profile directly (not the tmp script).
Visit the service — the session typically refreshes without showing a login screen.
Clear cached images and files again, keeping cookies.
Close the window. Subsequent tmp clones inherit the refreshed cookies.

This keeps each launch fast (small copy), each session authenticated, and the SSD free of per-session churn.

Why tmpfs

/tmp is typically tmpfs, meaning files exist only in memory and swap:

No SSD wear for cache, history, and session churn during the session.
Fast cache I/O without disk latency.
Self-cleaning — a reboot empties /tmp even if a session is killed uncleanly.

Each launch creates a fresh profile.XXXXXX directory with separate user-data and disk-cache subdirectories. Pointing --disk-cache-dir outside the user-data tree keeps evictable cache I/O isolated from profile state.

Script walkthrough

if [ $# -gt 0 ]; then
    PROFILE_NAME="$1"
    shift
else
    PROFILE_NAME="Default"
fi

The first argument selects the source profile; everything after it is forwarded to Chrome via "$@" at the end. That forwarding is what lets desktop actions and terminal invocations pass URLs into the fresh session.

mkdir -p /tmp/google-chrome
TMP_ROOT=$(mktemp -d -p /tmp/google-chrome profile.XXXXXX)

mktemp -d creates a uniquely named session directory with 0700 permissions, which matters because the copy contains cookies and session tokens. The mkdir -p guards against a fresh boot where /tmp/google-chrome does not exist yet.

CURRENT_LINK="/tmp/google-chrome/current"
if [[ ! -L "$CURRENT_LINK" || ! -d "$CURRENT_LINK" ]]; then
    ln -sfn "$TMP_USER_DATA" "$CURRENT_LINK"
fi

/tmp/google-chrome/current points at the live session’s user-data directory so external link openers have a stable path. The first running profile wins: a second concurrent session keeps its own directory but does not steal the link. Its cleanup only removes the symlink when the link still points at its own directory (checked with readlink), so closing the second session never disconnects the first.

cleanup() {
    rm -rf "$TMP_ROOT"
    ...
}
trap cleanup EXIT INT TERM

Exiting Chrome triggers removal of the whole session directory — profile copy, cache, and all browsing traces. There is no merge-back step by design.

Persistent base directory with user tmpfiles

The mkdir -p in the script is enough for correctness, but declaring the base directory via systemd user tmpfiles makes the intent explicit and guarantees correct ownership and mode at login:

~/.config/user-tmpfiles.d/google-chrome.conf

d /tmp/google-chrome 0700 - - -

Apply with systemd-tmpfiles --user --create (or log out and back in). The script’s mkdir -p remains as a fallback for systems without the entry.

Desktop integration

Two user-local desktop entries wire the script into the environment. User entries live in ~/.local/share/applications/ and override the system copies in /usr/share/applications/, so copy the file there first and edit the copy — package upgrades can overwrite the system one:

cp /usr/share/applications/google-chrome.desktop ~/.local/share/applications/

The script itself can live anywhere on PATH, for example ~/.local/bin/google-chrome-tmp-profile (note that Exec= does not expand ~, so the desktop file must contain the absolute path, e.g. /home/user/.local/bin/google-chrome-tmp-profile).

First, add a launcher action that starts a tmp session, optionally with a URL. Register the action in the main group, then define its own group:

# in ~/.local/share/applications/google-chrome.desktop
Actions=new-window;new-private-window;new-tmp;

[Desktop Action new-tmp]
Name=Temp Profile
Exec=/home/user/.local/bin/google-chrome-tmp-profile Default %U

The %U passes clicked URLs or files as extra arguments, which the script forwards to Chrome via "$@". Repeat the pattern for more source profiles (e.g. a new-tmp-work action pointing at a Work profile). After editing, right-clicking the Chrome icon offers Temp Profile alongside the standard window actions.

Second, add a hidden default-browser shim that routes external links (from a terminal, chat app, or xdg-open) into the live tmp session. Save it as a separate file, e.g. ~/.local/share/applications/google-chrome-tmp-current.desktop:

[Desktop Entry]
Type=Application
Version=1.0
Name=Google Chrome (current tmp profile)
NoDisplay=true
Terminal=false
Icon=google-chrome
MimeType=x-scheme-handler/http;x-scheme-handler/https;text/html;...
Exec=/usr/bin/bash -c 'p="/tmp/google-chrome/current"; [[ -L "$p" && -d "$p" ]] && exec "/usr/bin/google-chrome-stable" --user-data-dir="$p" "$@" || exec /usr/bin/true' bash %U

Then hand URL ownership to the shim:

Comment out the MimeType= line in ~/.local/share/applications/google-chrome.desktop so the regular entry no longer claims URLs.
Run update-desktop-database ~/.local/share/applications.
Select the shim as the default browser (desktop settings → Default Applications, or xdg-settings set default-web-browser google-chrome-tmp-current.desktop).

Two details matter in the shim. The bash -c '...' bash %U form with "$@" forwards all URLs; using "$0" would deliver only the first one and drop the rest. And when no tmp session is running, the shim intentionally does nothing (/usr/bin/true): there is no reliable way to surface a notification from a background URL open, so silently dropping is preferable to spawning an unwanted persistent-profile window.

Behavior summary

Launch a tmp session from the application menu; it opens with existing logins and extensions.
Links clicked anywhere else open as new tabs in the running tmp session via the current symlink.
With no tmp session running, external links are dropped instead of leaking into a persistent profile.
A second concurrent tmp session runs isolated but does not hijack link routing.
Closing the session window deletes its tmpfs copy; a reboot clears anything left behind.

Clearing Orphaned Bun Cache Entries

Tue, 22 Sep 2026 00:00:00 GMT

The Bun install cache accumulates every downloaded package version. By default it lives at ~/.bun/install/cache (or $BUN_INSTALL/install/cache when BUN_INSTALL is set). Over time it grows into gigabytes of stale data from upgraded or removed dependencies. The blunt option, bun pm cache rm, deletes everything and forces a full re-download on the next install. The script below takes a surgical approach: it removes only extracted package directories that are no longer referenced by any node_modules tree.

The full script, for reference:

#!/usr/bin/env bash
set -euo pipefail
shopt -s nullglob

BUN_CACHE_DIR="${BUN_CACHE_DIR:-${BUN_INSTALL:-$HOME/.bun}/install/cache}"

if [ ! -d "$BUN_CACHE_DIR" ]; then
    echo "Error: Bun cache directory not found: $BUN_CACHE_DIR" >&2
    exit 1
fi

patterns=(
    "$BUN_CACHE_DIR/*@@@*/"
    "$BUN_CACHE_DIR/@*/*@@@*/"
)

for pattern in "${patterns[@]}"; do
    # shellcheck disable=SC2086 -- intentional glob expansion
    for dir in $pattern; do
        if [ -d "$dir" ]; then
            # Count files with active hard links
            linked_files=$(find "$dir" -type f -links +1 | wc -l)

            # If no files are linked elsewhere, remove the target
            if [ "$linked_files" -eq 0 ]; then
                echo "Removing: $dir"
                rm -rf -- "$dir"
            fi
        fi
    done
done

find "$BUN_CACHE_DIR" -mindepth 1 -xtype l -delete
find "$BUN_CACHE_DIR" -mindepth 1 -type d -empty -delete

Bun cache layout

The cache directory contains three kinds of entries:

<hash>.npm files — registry manifest metadata (bun-npm-manifest-cache format: version lists and tarball URLs), keyed by content hash (for example, 009c472d14d8a98f.npm). These are not package archives; no local tarballs are stored in the cache.
Extracted directories — unpacked packages named name@version@@@1 (for example, acorn@8.18.0@@@1). Scoped packages nest one level deeper: @scope/name@version@@@1 (for example, @openai/codex@0.153.4@@@1).
Alias symlinks — version aliases such as oxlint/1.83.0@@@1 -> ../oxlint@1.83.0@@@1 that Bun uses to resolve version ranges.

The two glob patterns at the top of the script cover both extracted-directory shapes: $BUN_CACHE_DIR/*@@@*/ for unscoped packages and $BUN_CACHE_DIR/@*/*@@@*/ for scoped ones. The .npm manifest files match neither pattern and are left untouched, which is deliberate: all 728 of them total around 36 MB out of a 2.7 GB cache (~1.3%), and they are needed for dependency resolution. Their hash-based filenames carry no package mapping and they are never hard-linked, so the link-count check below cannot apply to them.

Detection: hard-link counts

When Bun installs dependencies, it hard-links cache files into the project’s node_modules instead of copying them. A cache file referenced by one project therefore has a link count of 2 — one link in the cache, one in node_modules. This is verifiable with stat:

$ stat -c '%h %i %n' ~/.bun/install/cache/acorn@8.18.0@@@1/package.json
2 13703410 /home/user/.bun/install/cache/acorn@8.18.0@@@1/package.json
$ stat -c '%h %i %n' docs/node_modules/acorn/package.json
2 13703410 /home/user/docs/node_modules/acorn/package.json

Same inode (13703410), link count 2 — the two paths are the same data on disk. When every project using that version is upgraded or removed, the node_modules links disappear and the count drops back to 1.

That property is the entire detection mechanism:

linked_files=$(find "$dir" -type f -links +1 | wc -l)

if [ "$linked_files" -eq 0 ]; then
    echo "Removing: $dir"
    rm -rf "$dir"
fi

find -links +1 lists files with more than one hard link. A count of zero means no file in that extracted directory is referenced from anywhere else, so the directory is an orphan and safe to delete. Any directory with at least one linked file is kept. Because the check is per-file rather than per-directory, a partially shared directory is never removed.

Cleanup: dangling symlinks and empty directories

Deleting an extracted directory orphans the alias symlinks pointing at it. The first find pass removes them:

find "$BUN_CACHE_DIR/" -xtype l -delete

-xtype l matches symlinks whose target no longer exists (broken links), as opposed to -type l, which matches all symlinks. Only dangling aliases are deleted; healthy aliases pointing at still-used versions are preserved. -mindepth 1 keeps the cache root itself out of range on both find passes, so the root directory can never be deleted even if it were somehow empty.

Removing directories and symlinks can leave empty parent directories behind — for example, a scope directory such as @openai/codex/ after its last version is removed. The second pass clears those:

find "$BUN_CACHE_DIR/" -type d -empty -delete

What the script leaves alone

The .npm manifest files are never evaluated and remain in the cache. Since the cache holds no local tarballs, reinstalling a deleted version re-downloads the archive from the registry — that network cost is why the link-count check is conservative: a directory is removed only when zero files in it are referenced from anywhere else, and anything ambiguous (for example, filenames with newlines that inflate the wc -l count) fails closed toward keeping the directory.

Safety notes and limits

The check is idempotent. Re-running the script after a cleanup finds zero candidates and changes nothing.
BUN_CACHE_DIR resolves from the environment with fallbacks: an explicitly exported BUN_CACHE_DIR wins, otherwise ${BUN_INSTALL}/install/cache is used when BUN_INSTALL is set, otherwise the Bun default ~/.bun/install/cache. The script aborts with an error if the resolved directory does not exist, instead of running find against a bad path.
shopt -s nullglob makes an unmatched glob expand to nothing, so a cache with no entries of one shape is handled cleanly. The [ -d "$dir" ] guard remains as a second layer. Filenames cannot contain spaces in this cache layout (package names plus @@@ separators), so the intentional unquoted glob expansion is safe here.
rm -rf -- uses an end-of-options marker so a pathological directory name starting with - can never be parsed as a flag.
The script must not run concurrently with bun install. A package mid-extraction has a link count of 1 and would look like an orphan.

Deletion is irreversible outside of re-download. A dry run that lists candidates without deleting:

BUN_CACHE_DIR="${BUN_CACHE_DIR:-${BUN_INSTALL:-$HOME/.bun}/install/cache}"
for d in "$BUN_CACHE_DIR"/*@@@*/; do
    [ "$(find "$d" -type f -links +1 | wc -l)" -eq 0 ] && echo "$d"
done

Usage

chmod +x ~/.local/bin/bun-clear-cache
bun-clear-cache

The cache location is picked up from BUN_INSTALL automatically; override it per-run with BUN_CACHE_DIR=/path/to/cache bun-clear-cache when needed.

Running it after dependency upgrades or removals keeps the cache proportional to the actually installed dependency set.

Reducing SSD Wear with systemd-tmpfiles and tmpfs

Wed, 16 Sep 2026 00:00:00 GMT

Most of what lands on a disk every day does not need to survive a reboot: build artifacts, package caches, browser caches, logs, temp files. Moving those to tmpfs (/tmp) keeps them in memory instead of wearing out the SSD, and directories declared via user tmpfiles.d come back automatically at login — a reboot cleans up whatever is left.

User entries live in ~/.config/user-tmpfiles.d/*.conf:

d /tmp/build/cargo 0755 - - -
D /tmp/logs/app 0755 - - -

Apply without logging out:

systemd-tmpfiles --user --create

d creates the directory if missing; D additionally empties it on boot — suitable for build trees, unsuitable for anything with cross-boot value. See the tmpfiles reference for the full type list.

Build outputs

Compilers rewrite the same files on every invocation. Point the output directory at tmpfs:

export CARGO_TARGET_DIR=/tmp/build/cargo/myproject
cargo build

Use one subdirectory per project to avoid lock contention. The same pattern works for cmake -B /tmp/build/<project>, GOCACHE=/tmp/build/go-cache, Jest --cacheDirectory, or .pytest_cache — the next build recreates everything, so losing the directory on reboot only costs a rebuild.

Package manager temp and logs

Per-operation temp and log directories are never reused across boots, so they are free to move:

d /tmp/pkg/npm-logs 0755 - - -
d /tmp/pkg/prebuilds 0755 - - -

export npm_config_cache=/tmp/pkg/npm-cache

Moving the full download cache saves writes but costs re-downloads after reboot — worth it on fast networks, otherwise move only the logs and temp extraction dirs.

Browser and app caches

Browsers update disk cache, shader and GPU cache on nearly every page load. Declare the target and symlink or point the app’s cache setting at it:

d /tmp/cache/chromium 0700 - - -
d /tmp/cache/thumbnails 0755 - - -

ln -s /tmp/cache/thumbnails ~/.cache/thumbnails

Redirect only cache subdirectories (Cache, GPUCache, ShaderCache), never the whole profile — cookies and settings stay on disk. Use 0700 for paths that may hold session tokens, since /tmp is world-readable.

Logs and crash dumps

Append-heavy logs that are almost never read are safe to redirect wholesale, with age-based cleanup bounding tmpfs usage:

d /tmp/logs/app 0755 - - 7d -

The tradeoff for all of the above: tmpfs shares RAM with applications and is empty after reboot, so keep working sets comfortably below free RAM and expect a slower first build or page load after boot.

Lightweight Home Backup with Btrfs Snapshots and Rsync

Mon, 14 Sep 2026 00:00:00 GMT

This post describes a lightweight script that backs up /home to an external vault drive with minimal moving parts. No daemon, no database, no proprietary format — just a Btrfs snapshot plus rsync. The result on the backup drive is a plain directory tree that can be browsed, diffed, or synced back with rsync.

The full script, for reference:

#!/usr/bin/bash
set -eEuo pipefail

if [ "$EUID" -ne 0 ]; then
  exec sudo "$0" "$@"
fi

VAULT_DRIVES=("/mnt/vault/a" "/mnt/vault/b")
BTRFS_SRC_SUBVOL="/home"
BTRFS_SNAPSHOTS_PATH="/.snapshots"
RETENTION_DAYS=60
DATETIME=$(date +%Y-%m-%d_%H-%M)

BACKUP_ROOT_PATH=""

for path in "${VAULT_DRIVES[@]}"; do
    if [[ -f "${path}/.mounted" ]]; then
        BACKUP_ROOT_PATH="$path"
        break
    fi
done

if [[ -z "$BACKUP_ROOT_PATH" ]]; then
    echo "Error: No valid backup destination mounted." 1>&2
    exit 1
fi


mkdir -p "$BTRFS_SNAPSHOTS_PATH"
TMP_SNAPSHOT_PATH="$BTRFS_SNAPSHOTS_PATH/tmp-backup"
if [[ -d "$TMP_SNAPSHOT_PATH" ]]; then
    btrfs subvolume delete "$TMP_SNAPSHOT_PATH"
fi

cleanup() {
    if [[ -n "${TMP_SNAPSHOT_PATH:-}" && -d "$TMP_SNAPSHOT_PATH" ]]; then
        echo "Cleaning up temporary snapshot: $TMP_SNAPSHOT_PATH"
        btrfs subvolume delete "$TMP_SNAPSHOT_PATH" || echo "Warning: Failed to delete $TMP_SNAPSHOT_PATH" >&2
    fi
}
trap cleanup EXIT

echo "Creating local read-only snapshot..."
btrfs subvolume snapshot -r "$BTRFS_SRC_SUBVOL" "$TMP_SNAPSHOT_PATH"

BACKUP_PATH="$BACKUP_ROOT_PATH/backup/$DATETIME"
BACKUP_LATEST_PATH="$BACKUP_ROOT_PATH/backup/latest"

RSYNC_OPTS=(
    -aAXHS
    --delete
    --numeric-ids
    --filter=": .rsync-filter"
    --info=progress2
)

if [[ -L "$BACKUP_LATEST_PATH" && -e "$BACKUP_LATEST_PATH/" ]]; then
    RSYNC_OPTS+=(--link-dest="$BACKUP_LATEST_PATH")
elif [[ -L "$BACKUP_LATEST_PATH" ]]; then
    echo "Warning: ignoring broken 'latest' symlink for --link-dest." >&2
fi

echo "Starting backup to: $BACKUP_PATH"
mkdir -p "$BACKUP_PATH"
rsync "${RSYNC_OPTS[@]}" "$TMP_SNAPSHOT_PATH/" "$BACKUP_PATH"
touch "$BACKUP_PATH"

(
    cd "$BACKUP_ROOT_PATH/backup"
    ln -sfn "$(basename "$BACKUP_PATH")" "latest"
)

if [[ $(findmnt -no FSTYPE -T "$BACKUP_ROOT_PATH") == "btrfs" ]]; then
    echo "Starting btrfs scrub on $BACKUP_ROOT_PATH..."
    if btrfs scrub start -B -q "$BACKUP_ROOT_PATH"; then
        echo "Scrub complete: No corruption detected on the backup drive."
    else
        echo "CRITICAL: Btrfs scrub detected errors on $BACKUP_ROOT_PATH!"
        echo "Check 'dmesg' or 'btrfs scrub status $BACKUP_ROOT_PATH' for details."
    fi
fi

echo "Cleaning up backups older than $RETENTION_DAYS days..."
LATEST_TARGET=""
if [[ -L "$BACKUP_LATEST_PATH" ]]; then
    LATEST_TARGET="$(readlink "$BACKUP_LATEST_PATH" || true)"
fi
if [[ -n "$LATEST_TARGET" ]]; then
    find "$BACKUP_ROOT_PATH/backup/" -mindepth 1 -maxdepth 1 -type d -mtime +"$RETENTION_DAYS" ! -name "$LATEST_TARGET" -print -exec rm -rf -- {} +
else
    find "$BACKUP_ROOT_PATH/backup/" -mindepth 1 -maxdepth 1 -type d -mtime +"$RETENTION_DAYS" -print -exec rm -rf -- {} +
fi

echo "Backup finished"
echo "TIP: If backup drive is getting slow, run 'btrfs balance'"

Backup destination selection

VAULT_DRIVES=("/mnt/vault/a" "/mnt/vault/b")

The script supports multiple vault mount points and picks the first one that contains .mounted sentinel file:

for path in "${VAULT_DRIVES[@]}"; do
    if [[ -f "${path}/.mounted" ]]; then
        BACKUP_ROOT_PATH="$path"
        break
    fi
done

if [[ -z "$BACKUP_ROOT_PATH" ]]; then
    echo "Error: No valid backup destination mounted." 1>&2
    exit 1
fi

The .mounted sentinel file is the key detail. Checking only whether /mnt/vault/a exists is not enough — an empty mount point directory exists even when the drive is unplugged, and a backup would then silently fill the root filesystem. Requiring a marker file that only exists on the mounted filesystem itself makes “no drive plugged in” a hard error instead of a silent disaster.

Each run creates a timestamped directory under the chosen drive:

DATETIME=$(date +%Y-%m-%d_%H-%M)
BACKUP_PATH="$BACKUP_ROOT_PATH/backup/$DATETIME"
BACKUP_LATEST_PATH="$BACKUP_ROOT_PATH/backup/latest"

So the layout becomes backup/2026-09-14_10-30/, backup/2026-09-15_10-30/, plus a backup/latest symlink pointing at the most recent one.

Crash-consistent source: read-only Btrfs snapshot

Backing up a live /home directly with rsync races with running applications — files changing mid-transfer produce an inconsistent copy. The script freezes a point-in-time view first:

BTRFS_SRC_SUBVOL="/home"
BTRFS_SNAPSHOTS_PATH="/.snapshots"
TMP_SNAPSHOT_PATH="$BTRFS_SNAPSHOTS_PATH/tmp-backup"

mkdir -p "$BTRFS_SNAPSHOTS_PATH"
if [[ -d "$TMP_SNAPSHOT_PATH" ]]; then
    btrfs subvolume delete "$TMP_SNAPSHOT_PATH"
fi

cleanup() {
    if [[ -n "${TMP_SNAPSHOT_PATH:-}" && -d "$TMP_SNAPSHOT_PATH" ]]; then
        echo "Cleaning up temporary snapshot: $TMP_SNAPSHOT_PATH"
        btrfs subvolume delete "$TMP_SNAPSHOT_PATH" || echo "Warning: Failed to delete $TMP_SNAPSHOT_PATH" >&2
    fi
}
trap cleanup EXIT

btrfs subvolume snapshot -r "$BTRFS_SRC_SUBVOL" "$TMP_SNAPSHOT_PATH"

-r creates a read-only snapshot, which is both a safety measure (nothing during the backup can mutate the source view) and nearly free on Btrfs — snapshot creation is instant regardless of /home size because blocks are shared until they diverge.

The snapshot is temporary by design. A trap on EXIT deletes /.snapshots/tmp-backup when the script finishes or is interrupted, so a Ctrl-C never leaves a stale snapshot behind. Only one transient snapshot ever exists; history lives on the vault drive, not in a growing pile of local snapshots. The cleanup guard checks that the variable is set and the path is still a directory, and any failure warning goes to stderr. No explicit exit is needed in the handler — EXIT already preserves the script’s exit status.

This requires /home to be a Btrfs subvolume and /.snapshots to be writable by root.

Transfer: rsync with hard-link incrementals

RSYNC_OPTS=(
    -aAXHS
    --delete
    --numeric-ids
    --filter=": .rsync-filter"
    --info=progress2
)

if [[ -L "$BACKUP_LATEST_PATH" && -e "$BACKUP_LATEST_PATH/" ]]; then
    RSYNC_OPTS+=(--link-dest="$BACKUP_LATEST_PATH")
elif [[ -L "$BACKUP_LATEST_PATH" ]]; then
    echo "Warning: ignoring broken 'latest' symlink for --link-dest." >&2
fi

mkdir -p "$BACKUP_PATH"
rsync "${RSYNC_OPTS[@]}" "$TMP_SNAPSHOT_PATH/" "$BACKUP_PATH"

What each flag preserves or controls:

-a — archive mode: recursion, permissions, ownership, timestamps, symlinks, devices.
-A — ACLs, -X — extended attributes, -H — hard links, -S — sparse files. Without these, restores subtly differ from the original (broken SELinux labels, doubled disk usage for sparse VM images, split hard-linked files).
--delete — makes each timestamped copy a full mirror of the source, not an ever-growing union of deleted files.
--numeric-ids — compares users/groups by UID/GID rather than name, so restores are correct even if the target system’s /etc/passwd differs.
--filter=": .rsync-filter" — per-directory merge-file excludes, covered in detail in Filtering with per-directory .rsync-filter files.
--info=progress2 — single overall progress line instead of per-file noise.
--link-dest="$BACKUP_LATEST_PATH" — the incremental mechanism. Unchanged files are hard-linked from the previous latest backup instead of copied, so each timestamped directory looks like a full backup but only new or changed blocks consume space. It is only added when latest is a symlink to an existing directory, which keeps the very first backup (no predecessor) working without special-casing. A dangling latest symlink — for example after a manual delete — is ignored with a stderr warning instead of failing the rsync run.

Note the trailing slash in "$TMP_SNAPSHOT_PATH/" — it syncs the contents of the snapshot into $BACKUP_PATH rather than nesting an extra tmp-backup directory inside it.

After a successful transfer, latest is repointed:

(
    cd "$BACKUP_ROOT_PATH/backup"
    ln -sfn "$(basename "$BACKUP_PATH")" "latest"
)

ln -sfn atomically replaces the symlink target, so latest never dangles mid-update and --link-dest always has a valid reference for the next run.

Filtering with per-directory `.rsync-filter` files

The single most effective backup-size control in this setup is not compression or deduplication — it is never copying regenerable noise in the first place. That is what this line enables:

--filter=": .rsync-filter"

In rsync filter syntax, the : prefix means dir-merge: before transferring the contents of every directory, rsync looks for a file named .rsync-filter inside it on the sending side and merges its rules into the active filter list. Key properties:

Distributed. Rules live next to the files they describe instead of in one central exclude file passed on the command line. A project directory declares its own build outputs; a cache directory declares itself. Adding a new noisy tool to one directory never requires editing the backup script.
Inherited. Rules from a parent directory apply to all of its subdirectories. A subdirectory can add narrower rules, which take precedence over inherited ones because newer per-directory rules are evaluated first.
Snapshot-aware. Because the transfer source is the frozen snapshot at /.snapshots/tmp-backup, the filter files are read from the same point-in-time view as the data. A half-written exclude file cannot skew a run.
Transferred by default. No e modifier is used, so the .rsync-filter files themselves are part of the backup. Each timestamped copy therefore records exactly which rules produced it, and --delete stays consistent against the latest reference.

Rule pattern basics

Each line in a .rsync-filter file is a filter rule. The most common form is an exclude starting with - :

- /node_modules/***
- /packages/*/dist
- /packages/@sysopkit/*/dist
- /tests/fixtures/container/cache/*.tar
- tsconfig.tsbuildinfo

These lines come from this repository’s own .rsync-filter and illustrate the full pattern vocabulary:

- marks the rule as an exclude (vs. + for an include).
A leading / anchors the pattern to the directory containing the filter file. /node_modules/*** excludes only the top-level node_modules, not a nested one deeper in the tree.
*** matches across directory boundaries including the directory itself — /node_modules/*** excludes the directory and everything under it.
* matches within a single path component — /packages/*/dist excludes the dist directory of every top-level package.
No leading / means a floating match — tsconfig.tsbuildinfo excludes that filename at any depth below the filter file’s directory.

The same vocabulary maps directly onto home-directory noise. Typical per-directory filter files in a /home tree look like this:

~/projects/webapp/.rsync-filter

- /node_modules/***
- /dist/***
- /.vite/***

~/.cache/.rsync-filter

# everything under here is regenerable
- ***

~/vm/.rsync-filter

- /*.tmp
- /snapshots/***

Each file is small, local, and obvious to whoever owns that directory. The backup script itself stays untouched as new directories appear — placing a .rsync-filter file is sufficient to opt out of backup traffic.

Interaction with `--delete` and `--link-dest`

Excluded paths are hidden from the sender’s file list, so they are neither copied nor hard-linked into the new timestamped directory. With plain --delete (without --delete-excluded), files already present in older snapshots from before an exclude was added are left alone — history is immutable, which is the desired behavior — while new snapshots stop accumulating that noise. Old snapshots age out through the 60-day retention pass, so the saving compounds over time.

A practical consequence: before the first backup of a new workstation, dropping a handful of .rsync-filter files for caches, node_modules, and build outputs typically cuts the transferred volume more than any rsync flag tuning. Verifying with rsync -n (dry run) against a snapshot shows exactly which paths the filters remove, without touching the vault drive.

Integrity check: Btrfs scrub of the vault drive

if [[ $(findmnt -no FSTYPE -T "$BACKUP_ROOT_PATH") == "btrfs" ]]; then
    echo "Starting btrfs scrub on $BACKUP_ROOT_PATH..."
    if btrfs scrub start -B -q "$BACKUP_ROOT_PATH"; then
        echo "Scrub complete: No corruption detected on the backup drive."
    else
        echo "CRITICAL: Btrfs scrub detected errors on $BACKUP_ROOT_PATH!"
        echo "Check 'dmesg' or 'btrfs scrub status $BACKUP_ROOT_PATH' for details."
    fi
fi

If the vault filesystem is Btrfs, every backup ends with a full scrub: all data and metadata checksums are re-read and verified (-B blocks until it finishes). This catches bit rot and a dying drive early, while older timestamped copies may still be intact. The findmnt guard keeps the script working when the vault drive is formatted with something else — scrub is skipped instead of failing.

Retention: timestamped directories with time-based expiry

RETENTION_DAYS=60
LATEST_TARGET=""
if [[ -L "$BACKUP_LATEST_PATH" ]]; then
    LATEST_TARGET="$(readlink "$BACKUP_LATEST_PATH" || true)"
fi
if [[ -n "$LATEST_TARGET" ]]; then
    find "$BACKUP_ROOT_PATH/backup/" -mindepth 1 -maxdepth 1 -type d -mtime +"$RETENTION_DAYS" ! -name "$LATEST_TARGET" -print -exec rm -rf -- {} +
else
    find "$BACKUP_ROOT_PATH/backup/" -mindepth 1 -maxdepth 1 -type d -mtime +"$RETENTION_DAYS" -print -exec rm -rf -- {} +
fi

Backups older than 60 days are deleted at the end of each run, keeping only top-level directories under backup/. Because unchanged files are hard-links shared between snapshots, deleting an old directory only frees blocks unique to it — shared blocks stay alive through their remaining links. -mtime +60 keys off directory modification time, which matches the DATETIME naming scheme and avoids ctime bumps from metadata-only changes. The current latest target is explicitly excluded via ! -name, so a stale-but-current backup is never deleted when the vault was offline past retention — it stays available as the next --link-dest reference. -print lists what is removed, and -- keeps rm safe against names starting with -.

The closing hint addresses long-term Btrfs behavior on the vault drive: heavy hard-link and delete churn fragments free space over time, and an occasional btrfs balance compacts it when writes get slow.

Restoring

There is no restore subcommand because there is nothing to decode — each backup is a plain tree. Restoring a single file is a plain copy out of the timestamped directory or latest. Restoring everything is a reverse rsync of the desired snapshot. Picking a dated directory instead of latest provides point-in-time recovery.

SysopKit | Blog

Ephemeral Chrome Profiles in tmpfs

Why a snapshot clone

Keeping source profiles clean and lightweight

Why tmpfs

Script walkthrough

Persistent base directory with user tmpfiles

Desktop integration

Behavior summary

Clearing Orphaned Bun Cache Entries

Bun cache layout

Detection: hard-link counts

Cleanup: dangling symlinks and empty directories

What the script leaves alone

Safety notes and limits

Usage

Reducing SSD Wear with systemd-tmpfiles and tmpfs

Build outputs

Package manager temp and logs

Browser and app caches

Logs and crash dumps

Lightweight Home Backup with Btrfs Snapshots and Rsync

Backup destination selection

Crash-consistent source: read-only Btrfs snapshot

Transfer: rsync with hard-link incrementals

Filtering with per-directory .rsync-filter files

Rule pattern basics

Interaction with --delete and --link-dest

Integrity check: Btrfs scrub of the vault drive

Retention: timestamped directories with time-based expiry

Restoring

Filtering with per-directory `.rsync-filter` files

Interaction with `--delete` and `--link-dest`