1.0.0 Release

CyberPatchMaker v1.0.0 - Initial Release

I am excited to announce the first official release of CyberPatchMaker, a powerful tool I designed to create tiny, efficient update files for large applications. Instead of requiring users to download entire applications for small updates, CyberPatchMaker generates binary patch files that contain only the changes, saving bandwidth and time for both developers and end-users.

Why I Created CyberPatchMaker

For large applications, such as games or enterprise software, delivering updates can be a significant challenge. A minor change could necessitate a multi-gigabyte download for every user. CyberPatchMaker addresses this by comparing two versions of an application and creating a compact patch file.

Example Scenario:

• Version 1.0.0: 5GB application
• Version 1.0.1: 5GB application with minor changes
• Traditional Update: Users download the full 5GB again.
• CyberPatchMaker Update: Users download a patch file that is often just a few megabytes.

Key Features in this Release:

• Efficient Patch Generation: Utilizes the bsdiff algorithm to create minimal binary patches, resulting in significantly smaller update sizes.
• Multiple Compression Options:
  • zstd: A modern, high-performance compression algorithm that provides an excellent balance of speed and compression ratio (default).
  • gzip: A widely supported and compatible compression option.
  • none: The ability to generate uncompressed patches, useful for debugging or in scenarios where compression is handled externally.
• Safe and Reliable Patching:
  • SHA-256 Verification: Employs robust SHA-256 hash verification at multiple stages (pre-patch, during-patch, and post-patch) to ensure data integrity and prevent corruption.
  • Key File System: Uniquely identifies application versions using a designated "key file" (typically the main executable) to prevent the application of incorrect patches.
• Bidirectional Patching:
  • Upgrades: Generate patches to move to a newer version (e.g., 1.0.0 to 1.0.1).
  • Downgrades: Generate patches to revert to a previous version (e.g., 1.0.1 to 1.0.0).
• Intelligent Backup System:
  • Selective Backups: Before applying a patch, a backup of only the files that will be modified or deleted is created. This minimizes disk space and backup time.
  • Mirror Structure: The backup directory mirrors the original file structure, making manual rollback intuitive and straightforward.
• Developer-Friendly Command-Line Tools:
  • generator: A powerful tool to create patch files. It supports generating a single patch between two versions or batch-generating patches from all previous versions to a new release.
  • applier: A tool for end-users to apply patch files. It includes a --dry-run mode to simulate a patch application without making any changes.
• Cross-Platform Compatibility: The core logic is platform-agnostic, with compiled binaries for Windows, and the potential to build for macOS and Linux.
• Comprehensive Testing: The project includes an extensive test suite (advanced-test.ps1) with 34 tests covering complex scenarios like nested directories, various compression formats, multi-hop patching, and corruption detection to ensure reliability.
• Experimental GUI: An initial graphical user interface for the patch generator and applier is included for demonstration and future development, though the CLI tools are the primary supported interface for this release.

Getting Started

To get started with CyberPatchMaker, you'll need Go 1.21 or later.

1. Clone the repository:

   git clone https://github.com/cyberofficial/CyberPatchMaker.git
   cd CyberPatchMaker

2. Build the tools:

   go build ./cmd/generator
   go build ./cmd/applier

For detailed usage, please refer to the project's documentation.

What's Next?

Future releases will focus on enhancing the GUI, improving the automatic rollback mechanism, and expanding support for different platforms and edge cases.

I welcome your feedback and contributions!