Compression delta binaire : UXC v3 vs xdelta3 vs bsdiff4

Qu'est-ce qu'un patch delta binaire ?

Un patch delta binaire encode uniquement la différence entre deux versions d'un fichier binaire. Mettre à jour une application de 80 MB qui n'a changé qu'à 5% ne devrait pas nécessiter de retélécharger 80 MB. Un bon algorithme delta réduit cette mise à jour à 3–5 MB.

Trois algorithmes dominent en 2026 : bsdiff4 (référence académique), xdelta3 (standard de l'industrie du jeu vidéo) et UXC v3 (format propriétaire de Universal Installer avec delta intégré).

Le choix d'un algorithme delta n'est pas qu'une question de ratio : la mémoire requise, la tolérance aux corruptions partielles et la vitesse d'application sur la machine cliente sont souvent plus critiques.

bsdiff / bsdiff4

bsdiff est l'algorithme de référence académique créé par Colin Percival. Il utilise un suffix array pour comparer les deux fichiers et produit des patches très compacts, particulièrement efficaces sur les fichiers compilés (EXE, DLL, SO).

• Points forts : excellent ratio de compression, patches très compacts sur les binaires compilés, implémentation Python via bsdiff4.
• Limites : consommation mémoire élevée (9× la taille du fichier source pendant la génération), lent à générer sur les gros fichiers, pas de résumption en cas d'interruption.

import bsdiff4

# Générer le patch
patch = bsdiff4.diff(open('app_v1.exe', 'rb').read(),
                     open('app_v2.exe', 'rb').read())
open('patch_v1_v2.bsdiff', 'wb').write(patch)

# Appliquer le patch
v2 = bsdiff4.patch(open('app_v1.exe', 'rb').read(), patch)
open('app_v2.exe', 'wb').write(v2)

xdelta3

xdelta3 est l'algorithme utilisé par l'industrie du jeu vidéo (Steam, GOG) et de nombreux gestionnaires de paquets Linux. Il utilise un algorithme de fenêtre glissante (VCDIFF standard RFC 3284) qui consomme beaucoup moins de mémoire que bsdiff.

• Points forts : faible consommation mémoire, streaming possible (pas besoin de charger le fichier entier), standard VCDIFF interopérable, très rapide à appliquer.
• Limites : ratio légèrement inférieur à bsdiff sur les petits fichiers, binaire C requis (pas de pure Python), pas de support natif des archives multi-fichiers.

UXC v3 — format .uxcd

UXC v3 introduit le format .uxcd (UXC Delta). Il combine bsdiff4 pour les blocs modifiés avec une optimisation clé : les blocs identiques entre deux versions sont référencés sans être re-encodés (taille 0 dans le patch).

# Format .uxcd — structure
[8B]  magic    : 55 58 43 44 00 03 00 00  ("UXCD" v3)
[4B]  n_blocks : nombre de blocs (64 KB chacun)
[N×] block_entries :
  [4B] block_id   : index du bloc dans le fichier cible
  [1B] block_type : IDENTICAL(0) | BSDIFF(1) | FULL(2)
  [4B] patch_size : taille du patch pour ce bloc
  [?B] patch_data : vide si IDENTICAL, bsdiff sinon
[32B] hmac_sha256 : intégrité du patch complet

Le bloc IDENTICAL permet d'ignorer complètement les parties inchangées — pour un EXE Python où seules les ressources ont changé, 80% des blocs sont IDENTICAL et occupent 0 byte dans le patch.

Comparatif sur un EXE Python 80 MB (5% modifié)

Critère	UXC v3 (.uxcd)	bsdiff4	xdelta3
Taille du patch	~3.2 MB	~2.8 MB	~4.1 MB
Mémoire génération	~200 MB	~720 MB	~80 MB
Temps génération	~18s	~22s	~8s
Temps application	~2s	~4s	~1.5s
Résumption partielle	✓ par bloc	✗	Partielle
Vérification intégrité	HMAC-SHA256	CRC32	Adler32
Multi-fichiers natif	✓	✗	✗
Pure Python	✓	✓	✗ (binaire C)

Implémentation Python avec Universal Installer

from universal_installer.delta import UXCDelta

delta = UXCDelta()

# Générer un patch .uxcd
stats = delta.create_patch(
    source="app_v1.0.uxc",
    target="app_v1.1.uxc",
    output="patch_v1.0_to_v1.1.uxcd",
    block_size=65536  # 64 KB par bloc
)
print(stats)
# {'identical_blocks': 1024, 'patched_blocks': 51,
#  'full_blocks': 5, 'patch_size_mb': 3.2, 'ratio': 0.04}

# Appliquer le patch
delta.apply_patch(
    source="app_v1.0.uxc",
    patch="patch_v1.0_to_v1.1.uxcd",
    output="app_v1.1.uxc",
    verify_hmac=True
)

Cas d'usage pratiques

• Mises à jour logicielles classiques (EXE, DLL, SO) → UXC v3 ou bsdiff4. Ratio optimal, intégrité HMAC.
• Gros fichiers (> 500 MB), mémoire contrainte → xdelta3. Streaming sans chargement complet.
• Archives multi-fichiers (packages Python) → UXC v3 obligatoirement. Le seul à gérer nativement les archives complètes.
• Environnement sans binaire C installable → UXC v3 ou bsdiff4 (pure Python).

Conclusion

UXC v3 est le meilleur choix pour les mises à jour de packages Python et d'archives multi-fichiers. bsdiff4 reste supérieur sur le ratio brut pour les fichiers uniques. xdelta3 domine en mémoire et en vitesse de génération. Universal Installer V2 implémente UXC v3 nativement avec génération automatique de patches lors des uploads cloud.