🎮 DeckSaves - Advanced Multi-Platform Game Save Synchronization

DeckSaves is a powerful, cross-platform application built with Rust and Tauri that provides intelligent game save file synchronization with advanced versioning capabilities. Perfect for Steam Deck users, PC gamers, and anyone who wants to keep their game saves safe and synchronized across multiple devices.

🌟 Key Features

🔄 Intelligent Save Synchronization

• Multi-Platform Support: Works on Windows, macOS, and Linux
• Bidirectional Sync: Automatically chooses the newest save files
• Conflict Resolution: Smart timestamp-based conflict resolution
• Real-time Monitoring: Watch folders for automatic sync on file changes
• Batch Processing: Efficient handling of multiple save files

📚 Advanced Versioning System

• Complete Version History: Never lose a save file again - every sync creates a recoverable version
• Directory Snapshots: Unified versioning treats entire save directories as single units
• Pin Important Versions: Mark critical saves (before boss fights, achievements, etc.) to prevent cleanup
• One-Click Restore: Easily restore any previous save state with full directory restoration
• Smart Cleanup: Automatic removal of old versions while preserving pinned saves
• Timestamp Tracking: Detailed version history with creation times and metadata

☁️ Flexible Storage Options

• Local Storage: Secure local file storage with no internet dependency
• AWS S3 Integration: Cloud backup and sync across multiple devices
• Encrypted Credentials: Secure storage of AWS credentials with encryption
• Storage Testing: Built-in connection testing before saving configurations
• Smart Sync: Intelligent merging of local and cloud data without data loss

🎯 Game Detection & Management

• Steam Integration: Automatic discovery of Steam games and save locations
• Manual Game Addition: Add any game with custom save paths
• Multiple Save Paths: Support for games with multiple save locations
• Game-Specific Settings: Individual sync settings per game
• Save Path Validation: Verify save paths before adding games

🛡️ Safety & Security Features

• No Data Loss: Versioning ensures you can always recover previous saves
• Conflict Prevention: Smart sync logic prevents accidental overwrites
• Encrypted Storage: AWS credentials stored with AES encryption
• File Integrity: SHA256 hashing for version verification
• Backup Validation: Verify backup integrity before sync operations

🚀 Quick Start

Installation

Option 1: Download Pre-built Binary

1. Download the latest release from GitHub Releases
2. Extract and run the executable
3. Follow the setup wizard

Option 2: Build from Source

# Clone the repository
git clone https://github.com/yourusername/DeckSaves.git
cd DeckSaves

# Install dependencies
npm install

# Build and run
npm run tauri dev

Initial Setup

1. Launch DeckSaves and navigate to the Storage tab
2. Choose Storage Type:
   • Local Storage (Recommended): Stores saves on your local machine
   • AWS S3: Cloud storage for multi-device synchronization
3. Configure Storage Settings:
   • Local: Set your preferred storage directory (default: ~/.decksaves)
   • S3: Enter bucket name, region, and AWS credentials
4. Test Connection (S3 only) and Save Configuration

📖 Detailed Feature Guide

🎮 Game Management

Adding Games Manually

1. Click "Add Game Manually" in the Games tab
2. Fill in the game details:
   • Game Name: Identifier for your game
   • Save Paths: Directories containing save files (can add multiple)
   • Sync Enabled: Toggle automatic synchronization
3. Click Save to add the game

Steam Game Discovery

1. Click "Discover Steam Games"
2. DeckSaves automatically scans your Steam installation
3. Review detected games and save paths
4. Click "Add Selected Games" to import them

Game Settings

• Enable/Disable Sync: Toggle synchronization per game
• Auto-Watch: Monitor save directories for real-time sync
• Multiple Save Paths: Add multiple directories for games with complex save structures

🔄 Synchronization Types

Standard Sync

• Purpose: Basic file synchronization without versioning
• Best For: Simple backup needs
• How to Use: Click the sync button (🔄) next to any game

Versioned Sync

• Purpose: Advanced sync with complete version history
• Best For: Critical saves, experimental gameplay, speedrunning
• How to Use: Click the "🕒 Versioned Sync" button
• Benefits:
  • Every sync creates a recoverable checkpoint
  • Directory-level snapshots preserve complete game state
  • Automatic pinning of important versions

Smart Sync

• Purpose: Intelligent merging of local and cloud data
• Best For: Setting up on new devices, switching storage types
• How to Use: Click the "🔄 Smart Sync" button
• Features:
  • Safely merges conflicting data
  • Never loses existing saves
  • Resolves conflicts using timestamps

📚 Version Management

Viewing Version History

1. Click the "📋 History" button next to any game
2. Browse all available versions with timestamps
3. See file details, sizes, and version metadata
4. Identify pinned versions (marked with 📌)

Restoring Previous Versions

1. Open version history for the desired game
2. Find the version you want to restore
3. Click "↩️ Restore" next to the version
4. Confirm the restoration
5. Result: Complete directory state restored to that point in time

Pinning Important Versions

1. Open version history
2. Click the "📌 Pin" button next to important versions
3. Use Cases:
   • Before attempting difficult boss fights
   • After achieving major milestones
   • Before trying experimental strategies
   • After completing achievements
4. Benefit: Pinned versions are protected from automatic cleanup

Managing Storage Space

1. Automatic Cleanup: Old versions are automatically removed based on:
   • Age (default: 30 days)
   • Count (default: 10 versions per game)
   • Pinned status (pinned versions are never auto-deleted)
2. Manual Cleanup:
   • Click "🧹 Cleanup Old Versions" to remove old versions
   • Click "🗑️ Delete" next to specific versions
   • Note: Pinned versions must be unpinned before deletion

☁️ Storage Configuration

Local Storage

• Path: ~/.decksaves (customizable)
• Structure:

  ~/.decksaves/
  ├── local_storage/
  │   ├── versions/
  │   │   ├── GameName/
  │   │   │   ├── 20250725_120000_hash123.tar.gz
  │   │   │   └── 20250725_130000_hash456.tar.gz
  │   │   └── manifests/
  │   └── config/
  

• Benefits: No internet required, full privacy, unlimited storage (As long as you have space)
• Limitations: Single device only (unless using shared network storage)

AWS S3 Storage

• Requirements: AWS account, S3 bucket, IAM credentials
• Configuration:
  • Bucket Name: Your S3 bucket name
  • Region: Choose closest AWS region for best performance
  • Access Key ID: IAM user access key
  • Secret Access Key: IAM user secret key
• Benefits: Multi-device sync, automatic backups, virtually unlimited storage
• Costs: AWS S3 pricing applies (typically very low for save files)

Storage Security

• Local: Files stored with standard filesystem permissions
• S3:
  • Credentials encrypted with AES-256 before local storage
  • Data transmitted over HTTPS
  • Server-side encryption available (configure in S3 bucket settings)

🔧 Advanced Features

Real-time File Watching

1. Enable Auto-Watch for a game
2. DeckSaves monitors save directories for changes
3. Automatic sync triggered when saves are modified
4. Use Case: Seamless backup during gameplay

Batch Operations

• Sync All: Sync all enabled games with one click
• Bulk Enable/Disable: Manage multiple games simultaneously
• Status Monitoring: Real-time sync status for all operations

Import/Export Configuration

• Export: Backup your game configuration and settings
• Import: Restore configuration on new devices
• Format: JSON format for easy editing and sharing

🛠️ Technical Details

System Requirements

• Operating System: Windows 10+, macOS 10.15+, Linux (modern distributions)
• Memory: 100MB RAM minimum
• Storage: 50MB for application, additional space for save backups
• Network: Internet connection required for S3 sync only

Architecture

• Frontend: Vue.js 3 with TypeScript
• Backend: Rust with Tauri framework
• Storage: Local filesystem or AWS S3
• Encryption: AES-256 for credential storage
• Compression: gzip compression for version archives

File Formats

• Configuration: JSON format in ~/.decksaves/config.json
• Version Archives: tar.gz format for directory snapshots
• Manifests: JSON format tracking version metadata

Performance

• Sync Speed: Optimized for small save files (typical: <1MB/sec)
• Memory Usage: Low memory footprint (~50MB typical)
• CPU Usage: Minimal impact during sync operations
• Startup Time: Fast startup (<2 seconds typical)

🐛 Troubleshooting

Common Issues

"Failed to sync: dispatch failure"

Cause: AWS S3 connection issue Solutions:

1. Verify AWS credentials in Storage settings
2. Check internet connection
3. Test S3 connection using the built-in test feature
4. Switch to Local Storage temporarily

"Version not found in manifest"

Cause: Version data corruption or missing files Solutions:

1. Check storage location for corrupted files
2. Run "Smart Sync" to rebuild version manifests
3. Verify storage permissions

"Game not found in configuration"

Cause: Game configuration issue Solutions:

1. Re-add the game manually
2. Check game name spelling
3. Verify save paths exist

Steam Games Not Detected

Solutions:

1. Ensure Steam is installed in default location
2. Run DeckSaves as administrator/sudo if needed
3. Manually add games if auto-detection fails

Debug Information

• Log Location: Application logs available in the UI Sync Status tab
• Verbose Logging: Set RUST_LOG=debug environment variable
• Configuration: Located at ~/.decksaves/config.json

🤝 Contributing

We welcome contributions! Please see our Contributing Guide for details.

Development Setup

# Clone and install dependencies
git clone https://github.com/yourusername/DeckSaves.git
cd DeckSaves
npm install

# Install Rust dependencies
cargo build

# Run in development mode
npm run tauri dev

Code Structure

DeckSaves/
├── src/                    # Vue.js frontend
├── tauri-ui/src/          # Tauri Rust backend
├── core/src/              # Core sync logic
├── cli/src/               # Command-line interface
└── docs/                  # Documentation

📄 License

This project is licensed under the MIT License - see the LICENSE file for details.

🙏 Acknowledgments

• Built with Tauri for the application framework
• Uses AWS SDK for Rust for S3 integration
• Inspired by the Steam Deck community's need for better save management

📞 Support

• GitHub Issues: Report bugs or request features
• Documentation: Wiki
• Community: Discord Server

---

DeckSaves - Because your save files are irreplaceable! 🎮✨