BackupForge

Open-source backup and disaster recovery solution - A modern, enterprise-grade alternative to Acronis, MSP360, and Axcient.

Built with Rust for maximum performance, security, and reliability.

Features

Core Capabilities

Content-Defined Chunking (CDC) - Efficient deduplication using rolling hash algorithm
AES-256-GCM Encryption - Military-grade encryption for data at rest and in transit
Zstd/LZ4 Compression - Fast compression with excellent ratios
Incremental Backups - Only backup changed data
Multi-tenancy - Support for MSPs managing multiple clients
Web Dashboard - Modern REST API with web-based management interface
MCP Server - AI assistant integration via Model Context Protocol

Backup Sources

Local files and directories
Remote servers via SSH
Proxmox VMs and LXC containers
(Planned) Docker containers, databases, cloud VMs

Storage Backends

Local filesystem
S3-compatible storage (AWS S3, MinIO, Backblaze B2)
(Planned) Azure Blob, Google Cloud Storage

Architecture

┌─────────────────────────────────────────────────────────────┐
│                      BackupForge                             │
├─────────────────────────────────────────────────────────────┤
│                                                              │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐     │
│  │   Web UI     │  │   REST API   │  │   CLI Tool   │     │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘     │
│         │                 │                  │              │
│         └─────────────────┴──────────────────┘              │
│                           │                                 │
│                    ┌──────▼───────┐                        │
│                    │ Backup Agent │                        │
│                    └──────┬───────┘                        │
│                           │                                 │
│         ┌─────────────────┼─────────────────┐              │
│         │                 │                 │              │
│  ┌──────▼───────┐  ┌──────▼───────┐  ┌─────▼──────┐      │
│  │  Filesystem  │  │     SSH      │  │  Proxmox   │      │
│  │   Backup     │  │    Backup    │  │   Backup   │      │
│  └──────┬───────┘  └──────┬───────┘  └─────┬──────┘      │
│         │                 │                 │              │
│         └─────────────────┴─────────────────┘              │
│                           │                                 │
│                    ┌──────▼───────┐                        │
│                    │ Backup Engine│                        │
│                    └──────┬───────┘                        │
│                           │                                 │
│         ┌─────────────────┼─────────────────┐              │
│         │                 │                 │              │
│  ┌──────▼───────┐  ┌──────▼───────┐  ┌─────▼──────┐      │
│  │   Chunking   │  │ Compression  │  │ Encryption │      │
│  │     (CDC)    │  │  (Zstd/LZ4)  │  │(AES-256-GCM)│      │
│  └──────┬───────┘  └──────┬───────┘  └─────┬──────┘      │
│         │                 │                 │              │
│         └─────────────────┴─────────────────┘              │
│                           │                                 │
│                    ┌──────▼───────┐                        │
│                    │Dedup Index   │                        │
│                    └──────┬───────┘                        │
│                           │                                 │
│                    ┌──────▼───────┐                        │
│                    │   Storage    │                        │
│                    │   Backend    │                        │
│                    └──────┬───────┘                        │
│                           │                                 │
│         ┌─────────────────┼─────────────────┐              │
│         │                 │                 │              │
│  ┌──────▼───────┐  ┌──────▼───────┐  ┌─────▼──────┐      │
│  │    Local     │  │      S3      │  │  Backblaze │      │
│  │  Filesystem  │  │  Compatible  │  │     B2     │      │
│  └──────────────┘  └──────────────┘  └────────────┘      │
│                                                              │
└─────────────────────────────────────────────────────────────┘

Quick Start

Prerequisites

Install Rust (1.70+):

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Note: BackupForge uses vendored OpenSSL - no system OpenSSL libraries required! Just Rust and a C compiler.

Installation

Clone the repository:

git clone https://github.com/consigcody94/backupforge.git
cd backupforge

Build the project:

cargo build --release

Install the CLI tool:

cargo install --path crates/cli

Basic Usage

Initialize a backup repository

backupforge init --storage /var/backups/repo --encrypt

Backup a directory

backupforge backup \
  --source /home/user/documents \
  --storage /var/backups/repo \
  --exclude ".cache" \
  --exclude "*.tmp" \
  --encrypt \
  --compression 3

List snapshots

backupforge list --storage /var/backups/repo

Restore a backup

backupforge restore \
  --storage /var/backups/repo \
  --snapshot <snapshot-id> \
  --target /home/user/restored

Run the server/dashboard

backupforge server --config /etc/backupforge/config.toml --port 8080

MCP Server (AI Assistant Integration)

BackupForge includes an MCP (Model Context Protocol) server for AI assistant integration:

# Build the MCP server
cargo build --release --bin backupforge-mcp

# Configure in Claude Desktop (see docs/MCP_SETUP.md)

Once configured, you can interact with BackupForge through Claude:

"Backup my Documents folder with encryption"
"Show me all my backup snapshots"
"How much storage am I using?"
"Help me create a disaster recovery plan"

See MCP Setup Guide for detailed instructions.

Configuration

Storage Configuration

Create a configuration file at /etc/backupforge/config.toml:

[storage]
type = "local"
path = "/var/backups/repo"

# Or for S3:
# [storage]
# type = "s3"
# bucket = "my-backups"
# region = "us-east-1"
# access_key = "YOUR_ACCESS_KEY"
# secret_key = "YOUR_SECRET_KEY"

[backup]
compression = "zstd"
compression_level = 3
encryption_enabled = true

[server]
bind_address = "0.0.0.0"
port = 8080
database_url = "sqlite:///var/lib/backupforge/db.sqlite"

Backup Job Configuration

Jobs can be configured via the web UI or API. Example job JSON:

{
  "name": "Daily Documents Backup",
  "source": {
    "type": "LocalPath",
    "path": "/home/user/documents",
    "excludes": [".cache", "*.tmp"]
  },
  "destination": "/var/backups/repo",
  "schedule": "0 2 * * *",
  "retention_days": 30,
  "enabled": true,
  "encryption_enabled": true,
  "compression_level": 3
}

API Documentation

Authentication

# Register a new user
curl -X POST http://localhost:8080/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username": "admin", "password": "secure123", "email": "admin@example.com"}'

# Login
curl -X POST http://localhost:8080/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username": "admin", "password": "secure123"}'

Backup Jobs

# Create a backup job
curl -X POST http://localhost:8080/api/jobs \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d @job.json

# List all jobs
curl http://localhost:8080/api/jobs \
  -H "Authorization: Bearer <token>"

# Run a job
curl -X POST http://localhost:8080/api/jobs/<job-id>/run \
  -H "Authorization: Bearer <token>"

Snapshots

# List snapshots
curl http://localhost:8080/api/snapshots \
  -H "Authorization: Bearer <token>"

# Get snapshot details
curl http://localhost:8080/api/snapshots/<snapshot-id> \
  -H "Authorization: Bearer <token>"

Project Structure

backupforge/
├── crates/
│   ├── common/          # Shared types and utilities
│   ├── core/            # Core backup engine
│   │   ├── chunking     # Content-defined chunking
│   │   ├── dedup        # Deduplication index
│   │   ├── compression  # Compression algorithms
│   │   └── encryption   # AES-256-GCM encryption
│   ├── storage/         # Storage backends
│   │   ├── local        # Local filesystem
│   │   ├── s3           # S3-compatible storage
│   │   └── manager      # Storage abstraction
│   ├── agent/           # Backup agents
│   │   ├── filesystem   # Local file backup
│   │   ├── ssh          # Remote SSH backup
│   │   └── proxmox      # Proxmox VM/CT backup
│   ├── server/          # REST API server
│   │   ├── api          # API routes
│   │   ├── handlers     # Request handlers
│   │   └── auth         # Authentication
│   └── cli/             # Command-line interface
├── web-dashboard/       # React frontend (planned)
├── docs/                # Documentation
└── scripts/             # Helper scripts

Development

Running Tests

cargo test

Running with Debug Logging

RUST_LOG=debug cargo run --bin backupforge -- backup --source /path/to/data --storage /path/to/repo

Building for Production

cargo build --release --all

Binaries will be in target/release/.

Roadmap

v0.2.0

Complete restore functionality
Snapshot management (list, delete, prune)
Retention policy enforcement
PostgreSQL support for metadata
Web dashboard frontend (React)

v0.3.0

v1.0.0

Performance

BackupForge is designed for high performance:

Chunking: ~500 MB/s (content-defined chunking)
Compression: ~400 MB/s (Zstd level 3)
Encryption: ~2 GB/s (AES-256-GCM with hardware acceleration)
Deduplication: O(1) chunk lookup using hash index

Security

Encryption: AES-256-GCM for data at rest and in transit
Key Derivation: Argon2 for password-based encryption
Hash Algorithm: BLAKE3 for chunk hashing (faster than SHA-256)
Authentication: JWT tokens for API access
Zero-Knowledge: Optional client-side encryption

Contributing

Contributions are welcome! Please see CONTRIBUTING.md for guidelines.

License

Licensed under the Apache License, Version 2.0. See LICENSE for details.

Comparison with Alternatives

Feature	BackupForge	Acronis	MSP360	Restic	Duplicati
Open Source	✅	❌	❌	✅	✅
Deduplication	✅ CDC	✅	✅	✅ Fixed	✅
Encryption	✅ AES-256	✅	✅	✅	✅
Multi-tenancy	✅	✅	✅	❌	❌
Web Dashboard	✅	✅	✅	❌	✅
VM Backup	✅ Proxmox	✅ All	✅	❌	❌
SSH Backup	✅	✅	✅	✅	❌
S3 Support	✅	✅	✅	✅	✅
Written in	Rust	C++	.NET	Go	C#
Performance	⚡⚡⚡	⚡⚡⚡	⚡⚡	⚡⚡⚡	⚡⚡

Support

Documentation: docs/
Issues: GitHub Issues
Discussions: GitHub Discussions

Acknowledgments

Built with:

Rust - Systems programming language
Tokio - Async runtime
Axum - Web framework
BLAKE3 - Cryptographic hash function
Zstd - Compression algorithm

Inspired by: Restic, Borg Backup, Duplicati, and commercial solutions like Acronis and Veeam.

Name		Name	Last commit message	Last commit date
Latest commit History 7 Commits
.github		.github
crates		crates
docs		docs
scripts		scripts
web-dashboard		web-dashboard
.dockerignore		.dockerignore
.editorconfig		.editorconfig
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Cargo.toml		Cargo.toml
DASHBOARD.md		DASHBOARD.md
DEPENDENCIES.md		DEPENDENCIES.md
Dockerfile		Dockerfile
LICENSE		LICENSE
Makefile		Makefile
QUICKSTART.md		QUICKSTART.md
README.md		README.md
SECURITY.md		SECURITY.md
docker-compose.yml		docker-compose.yml
rustfmt.toml		rustfmt.toml

License

consigcody94/backupforge

Folders and files

Latest commit

History

Repository files navigation

BackupForge

Features

Core Capabilities

Backup Sources

Storage Backends

Architecture

Quick Start

Prerequisites

Installation

Basic Usage

Initialize a backup repository

Backup a directory

List snapshots

Restore a backup

Run the server/dashboard

MCP Server (AI Assistant Integration)

Configuration

Storage Configuration

Backup Job Configuration

API Documentation

Authentication

Backup Jobs

Snapshots

Project Structure

Development

Running Tests

Running with Debug Logging

Building for Production

Roadmap

v0.2.0

v0.3.0

v1.0.0

Performance

Security

Contributing

License

Comparison with Alternatives

Support

Acknowledgments

About

Topics

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Languages

Packages