Skip to content

FAQ

Jump to bottom
Chris Purcell edited this page Feb 7, 2026 · 1 revision

Frequently Asked Questions

Common questions about DFBU.

General Questions

What is DFBU?

DFBU (DotFiles Backup Utility) is a Linux desktop application for backing up and restoring configuration files (dotfiles). It provides mirror backups (readable directories) and archive backups (compressed .tar.gz files) with safety features like pre-restore backups and verification.

Why use DFBU instead of manual backups?

Advantages:

  • Automated: One-click backups vs. manual cp commands
  • Safe: Pre-restore backups prevent data loss
  • Verified: Optional integrity checking ensures backup success
  • Organized: Tag-based organization and profiles
  • Flexible: Mirror + archive dual-mode support

Is DFBU only for dotfiles?

No. While designed for dotfiles, DFBU can backup any files or directories:

  • Application configurations (~/.config/)
  • System configuration files (/etc/fstab)
  • Scripts and tools (~/scripts/)
  • Project-specific configs

What platforms does DFBU support?

Supported: Linux (64-bit) Tested: Fedora, Ubuntu, Debian, Arch Linux Not Supported: Windows, macOS (currently)

Cross-platform support is a potential future feature.

Installation & Setup

Which installation method should I use?

AppImage (recommended):

  • Self-contained, no dependencies
  • Works on all distributions
  • Easy updates via AppImageUpdate

Source (for developers):

  • Access to latest features
  • Customization and contribution
  • Development environment setup

Do I need Python 3.14?

AppImage: No, Python bundled inside Source: Yes, Python 3.14+ required

Where does DFBU store its configuration?

AppImage: ~/.config/dfbu/ Source: DFBU/data/ (development default)

Configuration includes:

  • settings.yaml: Global settings
  • dotfiles.yaml: Dotfile library
  • session.yaml: Temporary exclusions
  • profiles.yaml: Backup profiles

Usage Questions

How do I add dotfiles?

Method 1 (GUI):

  1. Click "Add" button
  2. Fill in application name, description, path
  3. Optionally add tags
  4. Click "OK"

Method 2 (Manual):

  1. Click "Edit Config" button
  2. Add entry to dotfiles.yaml: 
    Bash:
  description: Bash configuration
  paths:
    - ~/.bashrc
    - ~/.bash_aliases
  tags: shell, terminal
  3. Save and validate

Can I backup multiple files for one application?

Yes, use paths (plural) field:

Bash:
  description: Bash configuration
  paths:
    - ~/.bashrc
    - ~/.bash_profile
    - ~/.bash_aliases
  tags: shell

What's the difference between mirror and archive backups?

Mirror Backup:

  • Creates readable directory structure
  • Files remain uncompressed
  • Easy browsing and selective restore
  • Larger storage footprint

Archive Backup:

  • Creates compressed .tar.gz archive
  • Space-efficient (60-80% compression)
  • Single-file backup package
  • Requires extraction for restore

Recommendation: Enable both for flexibility

How do I exclude large files?

Method 1: .dfbuignore: Create ~/.config/dfbu/.dfbuignore:

# Exclude cache
.cache/
__pycache__/

# Exclude logs
*.log
logs/

Method 2: Temporary Exclusion:

  • Uncheck dotfile in Backup tab
  • Exclusion persists in session.yaml

Method 3: Don't Add to Library:

  • Simply don't add large directories to dotfiles.yaml

Can I schedule automatic backups?

Not directly. DFBU requires manual backup initiation.

Workaround (future feature consideration):

  • Use cron with DFBU CLI (when available)
  • Use systemd timers
  • Desktop environment schedulers

How do I backup only specific dotfiles?

Method 1: Exclusions:

  1. Uncheck unwanted dotfiles in Backup tab
  2. Execute backup

Method 2: Profiles:

  1. Create profile with specific exclusions
  2. Load profile before backup

Method 3: Filter:

  1. Use filter input to show subset
  2. Check only desired dotfiles

Backup Questions

How long does a backup take?

Depends on:

  • Number of files
  • Total size
  • Compression level
  • Disk speed
  • Verification enabled

Typical Times:

  • Small (< 100 files, < 10MB): 5-30 seconds
  • Medium (100-1000 files, 10-100MB): 30 seconds - 5 minutes
  • Large (> 1000 files, > 100MB): 5-30 minutes

Why are some files skipped?

Files are skipped when:

  • Unchanged: File identical to previous backup (size, timestamp match)
  • Missing: Source file doesn't exist
  • Excluded: File matches .dfbuignore pattern

Check verbose logging for detailed skip reasons.

How much disk space do backups require?

Mirror Backups: ~1:1 ratio (same size as originals) Archive Backups: 20-40% of original size (with compression level 5) Both: 1.2-1.4x original size

Example:

  • Original files: 100 MB
  • Mirror backup: ~100 MB
  • Archive backup: ~30 MB (level 5)
  • Total: ~130 MB

Can I backup to cloud storage?

Yes, if cloud storage is mounted as local directory:

Works With:

  • Nextcloud/ownCloud (mounted via davfs2)
  • Dropbox (sync client)
  • Google Drive (rclone mount)
  • pCloud Drive (mounted)

Set Paths:

  • Mirror: ~/Nextcloud/backups/mirror
  • Archive: ~/Dropbox/backups/archives

How many archive backups are kept?

Controlled by max_archives setting (default: 5).

When limit reached:

  • Oldest archive deleted automatically
  • Newest archives retained
  • Rotation happens after successful backup

Can I backup system-wide configurations?

Yes, if you have read permissions:

System:
  description: System-wide configs
  paths:
    - /etc/fstab
    - /etc/hosts
    - /etc/ssh/sshd_config
  tags: system

Note: Requires read permissions. Use sudo if needed, or copy to home directory first.

Restore Questions

How do I restore files?

  1. Navigate to Restore tab
  2. Browse backup (mirror or archive)
  3. Select files to restore
  4. Click "Restore" button
  5. Confirm restoration

Pre-restore backup created automatically for safety.

What happens to existing files during restore?

Default Behavior:

  1. Pre-restore backup created (if enabled)
  2. Existing files overwritten with backup versions
  3. Verification optional

Safety Backup Location: ~/.local/share/dfbu/restore-backups/

Can I undo a restore?

Yes, via pre-restore safety backup:

cd ~/.local/share/dfbu/restore-backups/
ls -lt  # Find most recent
cp -r restore-backup-YYYYMMDD-HHMMSS/* ~/

Can I restore to a different location?

Not directly via GUI (current limitation).

Workaround:

  1. Restore to original location
  2. Move files manually to desired location

Or use command line:

# From mirror backup
cp -r ~/backups/mirror/hostname/bash/.bashrc ~/new-location/

# From archive
tar -xzf backup.tar.gz -C /tmp/
cp /tmp/backup/bash/.bashrc ~/new-location/

Configuration Questions

How do I reset configuration to defaults?

# Backup existing
mv ~/.config/dfbu ~/.config/dfbu.backup

# Relaunch DFBU to generate defaults
./DFBU-x86_64.AppImage

Can I share my dotfile library with others?

Yes:

  1. Export Configuration:

    • Click "Export Config" button
    • Choose destination
    • Share dotfiles.yaml

  2. Recipients Import:

    • Copy dotfiles.yaml to ~/.config/dfbu/
    • Launch DFBU
    • Adjust paths as needed

What's the difference between excluded and disabled?

DFBU v0.6.1+ uses exclusion model:

  • All dotfiles included by default
  • Excluded dotfiles temporarily skipped
  • No "enabled/disabled" toggle

Exclusions:

  • Stored in session.yaml
  • Persist across sessions
  • Can be cleared

How do I validate my configuration?

Via GUI:

  • Click "Validate Config" button in Configuration tab
  • Reports YAML syntax errors and missing fields

Via Command Line:

python3 -c "import yaml; yaml.safe_load(open('~/.config/dfbu/settings.yaml'))"

Profile Questions

What are profiles?

Named backup configurations with:

  • Specific exclusion lists
  • Custom option overrides
  • Descriptive names and purposes

Use Cases:

  • Different machines (work, home)
  • Different scenarios (minimal, full)
  • Testing vs. production

How many profiles can I create?

No limit. Create as many as needed for different scenarios.

Do profiles override settings.yaml?

Partial Override:

  • Profile options override global settings
  • Unspecified options use global defaults
  • Exclusions are profile-specific

Example:

  • Global: compression_level: 5
  • Profile: compression_level: 9 (overrides)
  • Used: 9 when profile active

Verification Questions

Should I enable verification?

Enable When:

  • Critical configuration backups
  • First-time backup setup
  • Network/cloud destinations
  • After system changes

Disable When:

  • Very large backups (> 1GB)
  • Frequent automated backups
  • Performance is critical

Recommendation: Enable for peace of mind

What does hash verification do?

Computes SHA-256 hash of source and backup files:

  • Match: Files identical
  • Mismatch: Backup corrupted or files changed

More thorough than size comparison but slower.

What if verification fails?

Retry Backup:

  1. Close applications that might modify files
  2. Execute backup again
  3. Check verification results

If Persistent Failures:

  • Check disk health
  • Verify sufficient disk space
  • Check file permissions
  • Report as bug if unexplained

Technical Questions

What compression format does DFBU use?

Current: gzip (.tar.gz) Compression Levels: 1-9 (configurable) Future: May support bzip2, xz, zstd

Does DFBU preserve file permissions?

Yes:

  • File permissions (rwx)
  • Ownership (user:group)
  • Timestamps (mtime, atime)
  • Extended attributes (where supported)

Uses Python 3.14's Path.copy(preserve_metadata=True) or shutil.copy2().

Can I use DFBU with Git?

Yes, excellent combination:

Workflow:

  1. Set mirror_dir to Git repository
  2. DFBU creates backups in Git repo
  3. Commit and push to remote: 
    cd ~/dotfiles-repo
git add -A
git commit -m "Update dotfiles"
git push

Benefits:

  • Version history via Git
  • Easy synchronization across machines
  • Diff tracking for configuration changes

Is DFBU suitable for large data backups?

Designed For: Configuration files (typically < 1GB) Works With: Larger data sets but:

  • Size warnings for files > 1GB
  • Slower hash verification for large files
  • Consider dedicated backup tools for TB-scale data

Better Tools for Large Data: rsync, restic, borg, duplicity

Troubleshooting Questions

Why can't DFBU find my dotfiles?

Check:

  1. Source paths exist: ls -la ~/.bashrc
  2. Paths correct in dotfiles.yaml
  3. Tilde expansion enabled (~ → /home/user)
  4. Permissions allow reading

Enable Verbose Logging for detailed diagnostic info.

DFBU is slow, how can I speed it up?

Optimization:

  1. Reduce compression level (9 → 5 or lower)
  2. Disable hash verification
  3. Use .dfbuignore to exclude large files
  4. Use SSD for backup destination
  5. Reduce backup selection

Where can I get help?

  1. Documentation: Wiki Home
  2. Troubleshooting: Troubleshooting
  3. Discussions: GitHub Discussions
  4. Issues: GitHub Issues

Navigation: Home | User Guide | Troubleshooting | Installation

Clone this wiki locally