diff --git a/.cargo/config.toml b/.cargo/config.toml
index f714b6d..8149ba4 100644
--- a/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,5 +1,5 @@
-# Les cibles musl embarquent leur CRT (self-contained) : rust-lld suffit pour
-# lier un binaire statique, y compris en compilation croisée depuis arm64.
+# musl targets ship their own CRT (self-contained): rust-lld is enough to link
+# a static binary, including when cross-compiling from arm64.
 [target.x86_64-unknown-linux-musl]
 linker = "rust-lld"
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c007afc..a51bc74 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -31,7 +31,7 @@ jobs:
           targets: x86_64-unknown-linux-musl
       - uses: Swatinem/rust-cache@v2
       - run: cargo build --release --target x86_64-unknown-linux-musl
-      - name: Vérifier que le binaire est statique
+      - name: Check that the binary is static
         run: |
           bin=target/x86_64-unknown-linux-musl/release/envprobe
           file "$bin"
@@ -51,25 +51,25 @@ jobs:
         with:
           name: envprobe-x86_64-linux-musl
       - run: chmod +x envprobe
-      - name: Utilisateur normal
+      - name: Normal user
         run: ./envprobe | tee user.txt
       - name: Root
         run: sudo ./envprobe | tee root.txt
-      - name: La sortie diffère selon les privilèges
+      - name: Output differs with privileges
         run: |
           ! diff -q user.txt root.txt
-          grep -E '^  CAP_BPF +non' user.txt
-          grep -E '^  CAP_BPF +oui' root.txt
-      - name: Conteneurs Docker par défaut
+          grep -E '^  CAP_BPF +no' user.txt
+          grep -E '^  CAP_BPF +yes' root.txt
+      - name: Default Docker containers
         run: |
           for image in debian:12 alpine:3.20 rockylinux:9; do
             echo "::group::$image"
             docker run --rm -v "$PWD/envprobe:/envprobe:ro" "$image" /envprobe | tee "docker-${image%%:*}.txt"
             grep -E '^  container +docker' "docker-${image%%:*}.txt"
-            grep -E '^  seccomp +filtre' "docker-${image%%:*}.txt"
+            grep -E '^  seccomp +filter' "docker-${image%%:*}.txt"
             echo "::endgroup::"
           done
-      - name: Rapports JSON et diff hôte / Alpine
+      - name: JSON reports and host / Alpine diff
         run: |
           ./envprobe --json > host.json
           sudo ./envprobe --json > host-root.json
@@ -85,8 +85,8 @@ jobs:
           grep -q '^\[libc\]' diff.txt
           grep -q '^\[shell\]' diff.txt
           grep -q '^\[packages\]' diff.txt
-          # Même noyau : la release ne change pas. La config peut manquer dans
-          # le conteneur (/boot absent), d'où la vérification sur release seule.
+          # Same kernel: the release does not change. The config can be missing in
+          # the container (no /boot), hence the check on release only.
           ! grep -qE '^[-+] release ' diff.txt
       - uses: actions/upload-artifact@v4
         with:
diff --git a/.github/workflows/matrix.yml b/.github/workflows/matrix.yml
index d72dce9..a2cd488 100644
--- a/.github/workflows/matrix.yml
+++ b/.github/workflows/matrix.yml
@@ -1,7 +1,7 @@
-name: Matrice
+name: Matrix
 
-# Dogfooding : distroproof lance envprobe dans des VM de chaque distro cible
-# (distroproof.toml) et publie un résumé Markdown sur la PR.
+# Dogfooding: distroproof runs envprobe in VMs of each target distro
+# (distroproof.toml) and posts a Markdown summary on the PR.
 
 on:
   pull_request:
@@ -21,7 +21,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: Activer KVM
+      - name: Enable KVM
         run: |
           echo 'KERNEL=="kvm", GROUP="kvm", MODE="0666", OPTIONS+="static_node=kvm"' \
             | sudo tee /etc/udev/rules.d/99-kvm4all.rules
@@ -29,7 +29,7 @@ jobs:
           sudo udevadm trigger --name-match=kvm
           ls -l /dev/kvm
 
-      - name: Installer QEMU et OVMF
+      - name: Install QEMU and OVMF
         run: |
           sudo apt-get update
           sudo apt-get install -y --no-install-recommends qemu-system-x86 qemu-utils ovmf
@@ -40,8 +40,8 @@ jobs:
       - uses: Swatinem/rust-cache@v2
       - run: cargo build --release --target x86_64-unknown-linux-musl
 
-      # Images cloud et noyaux extraits : renouvelés chaque semaine pour
-      # suivre les mises à jour des distros.
+      # Cloud images and extracted kernels: renewed every week to follow
+      # distro updates.
       - id: week
         run: echo "week=$(date +%G-%V)" >> "$GITHUB_OUTPUT"
       - uses: actions/cache@v4
@@ -50,18 +50,18 @@ jobs:
           key: distroproof-images-${{ steps.week.outputs.week }}-${{ hashFiles('distroproof.toml') }}
           restore-keys: distroproof-images-
 
-      - name: Lancer la matrice
+      - name: Run the matrix
         run: |
           set +e
           target/x86_64-unknown-linux-musl/release/distroproof up --no-tui --jobs 3 \
             --json matrix.json --junit junit.xml --markdown summary.md
           echo "code=$?" >> "$GITHUB_ENV"
 
-      - name: Résumé
+      - name: Summary
         if: always()
         run: cat summary.md >> "$GITHUB_STEP_SUMMARY"
 
-      - name: Commentaire de PR
+      - name: PR comment
         if: always() && github.event_name == 'pull_request'
         continue-on-error: true
         env:
@@ -79,5 +79,5 @@ jobs:
             junit.xml
             summary.md
 
-      - name: Code de sortie de la matrice
+      - name: Matrix exit code
         run: exit "$code"
diff --git a/Cargo.toml b/Cargo.toml
index cd6c762..f2339bd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -6,7 +6,7 @@ members = ["crates/envprobe-core", "crates/envprobe", "crates/distroproof"]
 version = "0.1.0"
 edition = "2021"
 license = "MIT OR Apache-2.0"
-repository = "https://github.com/moha-bekh/distroproof"
+repository = "https://github.com/devutils-org/distroproof"
 
 [workspace.dependencies]
 envprobe-core = { path = "crates/envprobe-core" }
@@ -25,7 +25,7 @@ toml = "1"
 tui-term = "0.3"
 vt100 = "0.16"
 
-# Le hachage des images (plusieurs centaines de Mio) reste rapide en debug.
+# Keeps image hashing (several hundred MiB) fast in debug builds.
 [profile.dev.package.sha2]
 opt-level = 3
 
diff --git a/README.md b/README.md
index e59db85..b0d9e8f 100644
--- a/README.md
+++ b/README.md
@@ -1,72 +1,71 @@
 # distroproof
 
-[![CI](https://github.com/moha-bekh/distroproof/actions/workflows/ci.yml/badge.svg)](https://github.com/moha-bekh/distroproof/actions/workflows/ci.yml)
+[![CI](https://github.com/devutils-org/distroproof/actions/workflows/ci.yml/badge.svg)](https://github.com/devutils-org/distroproof/actions/workflows/ci.yml)
 
-> distroless retire la distro de ton image. distroproof vérifie que ton
-> programme tient sur toutes les distros.
+> distroless takes the distro out of your image. distroproof checks that your
+> program holds up on every distro.
 
-Un programme qui marche sur ta machine peut casser ailleurs : musl au lieu de
-glibc, noyau RHEL 4.18, BTF absent, `perf_event_paranoid` à 3, lockdown actif…
-distroproof décrit précisément un environnement Linux (userspace et noyau),
-lance ton programme dans des VM qui tournent avec le **vrai noyau** de chaque
-distro cible, puis relie chaque échec à la différence d'environnement qui
-l'explique.
+A program that works on your machine can break elsewhere: musl instead of
+glibc, a RHEL 4.18 kernel, no BTF, `perf_event_paranoid` set to 3, lockdown
+enabled… distroproof describes a Linux environment precisely (userspace and
+kernel), runs your program in VMs booted on the **real kernel** of each target
+distro, then ties every failure to the environment difference that explains
+it.
 
-Toutes les phases du POC sont implémentées : la sonde `envprobe` (utilisable
-seule) et l'orchestrateur `distroproof` (VM, matrice, rapport, TUI).
+Every phase of the POC is implemented: the `envprobe` probe (usable on its
+own) and the `distroproof` orchestrator (VMs, matrix, report, TUI).
 
-## Avancement
+## Status
 
-| Phase | Contenu | État |
+| Phase | Scope | Status |
 | --- | --- | --- |
-| 0 | Workspace, binaire statique musl, CI | ✅ |
-| 1 | Sonde `envprobe` : 18 catégories (kernel, BPF, perf, LSM, libc…) | ✅ |
-| 2 | Rapport JSON versionné, schéma publié, `envprobe diff` | ✅ |
-| 3 | VM QEMU/KVM avec noyau et rootfs de distro | ✅ |
-| 4 | Matrice déclarative `distroproof.toml` | ✅ |
-| 5 | Rapport de matrice, corrélation des échecs, JUnit / Markdown | ✅ |
-| 6 | TUI de monitoring | ✅ |
-
-Détail et critères de sortie : [docs/ROADMAP.md](docs/ROADMAP.md). Démo de bout en bout
-sur de vraies VM : [`scripts/demo.sh`](scripts/demo.sh) et
+| 0 | Workspace, static musl binary, CI | ✅ |
+| 1 | `envprobe` probe: 18 categories (kernel, BPF, perf, LSM, libc…) | ✅ |
+| 2 | Versioned JSON report, published schema, `envprobe diff` | ✅ |
+| 3 | QEMU/KVM VMs with the distro's kernel and rootfs | ✅ |
+| 4 | Declarative matrix in `distroproof.toml` | ✅ |
+| 5 | Matrix report, failure correlation, JUnit / Markdown | ✅ |
+| 6 | Monitoring TUI | ✅ |
+
+Details and exit criteria: [docs/ROADMAP.md](docs/ROADMAP.md). End-to-end
+demo on real VMs: [`scripts/demo.sh`](scripts/demo.sh) and
 [docs/how-to-use/demo.md](docs/how-to-use/demo.md).
 
 ## Crates
 
-| Crate | Rôle |
+| Crate | Role |
 | --- | --- |
-| `envprobe-core` | Bibliothèque des sondes, modèle du rapport, diff |
-| `envprobe` | CLI de la sonde |
-| `distroproof` | Orchestrateur de VM, matrice, rapport et TUI |
+| `envprobe-core` | Probe library, report model, diff |
+| `envprobe` | Probe CLI |
+| `distroproof` | VM orchestrator, matrix, report and TUI |
 
 ## envprobe
 
-`envprobe` liste tout ce qui peut changer le comportement d'un programme
-userspace ou kernel-facing :
+`envprobe` lists everything that can change how a userspace or kernel-facing
+program behaves:
 
-- **Identité** : distro, famille, arch, virtualisation, conteneur.
-- **Noyau** : release, cmdline, config (`CONFIG_BPF*`, `KPROBES`, `DEBUG_INFO_BTF`…), modules.
-- **Sécurité et privilèges** : sysctls, LSM, SELinux, AppArmor, lockdown, Secure Boot,
-  capabilities, seccomp, user namespace.
-- **BPF et perf** : types de programmes, types de maps et helpers, sondés par de
-  vrais appels `bpf()` ; `perf_event_open` logiciel et matériel, PMU ; tracefs, kallsyms, BTF.
-- **Userspace** : libc et sa version, bibliothèques courantes, FHS (merged-usr,
-  multiarch), `/bin/sh`, coreutils, init, gestionnaire de paquets, cgroups, XDG.
+- **Identity**: distro, family, arch, virtualization, container.
+- **Kernel**: release, cmdline, config (`CONFIG_BPF*`, `KPROBES`, `DEBUG_INFO_BTF`…), modules.
+- **Security and privileges**: sysctls, LSM, SELinux, AppArmor, lockdown, Secure Boot,
+  capabilities, seccomp, user namespaces.
+- **BPF and perf**: program types, map types and helpers, probed with real
+  `bpf()` calls; software and hardware `perf_event_open`, PMU; tracefs, kallsyms, BTF.
+- **Userspace**: libc and its version, common libraries, FHS (merged-usr,
+  multiarch), `/bin/sh`, coreutils, init, package manager, cgroups, XDG.
 
-Les fonctionnalités sont sondées directement, jamais déduites d'un numéro de
-version, car les noyaux RHEL rétroportent beaucoup. La sonde est en lecture
-seule et ne plante jamais : une information absente ou refusée apparaît avec
-sa raison.
+Features are probed directly, never inferred from a version number, because
+RHEL kernels backport a lot. The probe is read-only and never crashes: missing
+or denied information shows up with its reason.
 
 ```sh
-envprobe                              # résumé lisible
-envprobe --json                       # rapport complet
-envprobe --json --section kernel,bpf  # sections choisies
-envprobe diff a.json b.json           # différences, code de sortie 1 s'il y en a
-envprobe schema                       # schéma JSON du rapport
+envprobe                              # human-readable summary
+envprobe --json                       # full report
+envprobe --json --section kernel,bpf  # selected sections
+envprobe diff a.json b.json           # differences, exit code 1 if any
+envprobe schema                       # JSON schema of the report
 ```
 
-Extrait d'un diff entre un hôte Arch et un rootfs Alpine (même noyau) :
+Excerpt of a diff between an Arch host and an Alpine rootfs (same kernel):
 
 ```text
 [libc]
@@ -84,84 +83,83 @@ Extrait d'un diff entre un hôte Arch et un rootfs Alpine (même noyau) :
 + managers  apk
 ```
 
-### Format du rapport
+### Report format
 
-Chaque entrée porte un statut :
+Each entry carries a status:
 
-- `ok` : la valeur.
-- `unavailable` : information absente, avec la raison (fichier absent, syscall inexistant…).
-- `denied` : accès refusé (EPERM, EACCES, seccomp…).
+- `ok`: the value.
+- `unavailable`: information missing, with the reason (file absent, syscall not implemented…).
+- `denied`: access refused (EPERM, EACCES, seccomp…).
 
-Le champ `privileged` signale les résultats qui changent selon les droits du
-processus. Le format est versionné (`schema_version`) et son schéma est publié
-dans [`schema/envprobe-report.schema.json`](schema/envprobe-report.schema.json).
+The `privileged` field flags results that depend on the process's privileges.
+The format is versioned (`schema_version`) and its schema is published in
+[`schema/envprobe-report.schema.json`](schema/envprobe-report.schema.json).
 
-### Sonder une autre distro sans VM
+### Probing another distro without a VM
 
-Pour comparer l'userspace d'une autre distro sans VM ni Docker (le noyau reste
-celui de l'hôte) :
+To compare another distro's userspace without a VM or Docker (the kernel stays
+the host's):
 
 ```sh
-scripts/probe-rootfs.sh <rootfs extrait> <envprobe statique> --json
+scripts/probe-rootfs.sh <extracted rootfs> <static envprobe> --json
 ```
 
-Le script lance la sonde dans des namespaces user, mount et pid, sans root.
+The script runs the probe in user, mount and pid namespaces, without root.
 
 ## distroproof
 
-`distroproof` démarre de vraies VM QEMU/KVM sur les images cloud officielles
-de chaque distro : c'est **le noyau de la distro** qui tourne (4.18 sur
-Rocky 8, 5.14 sur Rocky 9…), pas celui de l'hôte.
+`distroproof` boots real QEMU/KVM VMs from each distro's official cloud
+images: it is **the distro's kernel** that runs (4.18 on Rocky 8, 5.14 on
+Rocky 9…), not the host's.
 
 ```sh
 distroproof run --target rocky-8 -- envprobe --json > rocky8.json
-distroproof up                        # matrice de distroproof.toml
-distroproof check                     # valide le fichier sans lancer de VM
-distroproof images                    # catalogue et état du cache
+distroproof up                        # matrix from distroproof.toml
+distroproof check                     # validate the file without starting VMs
+distroproof images                    # catalog and cache status
 distroproof report matrix.json --format markdown
 ```
 
-Prérequis sur l'hôte : `qemu-system-x86_64`, `qemu-img`, `curl`, KVM
-(`/dev/kvm`, repli automatique sur TCG sinon) et OVMF (`edk2-ovmf`, `ovmf`)
-pour les images qui ne démarrent qu'en UEFI. Les binaires se choisissent avec `DISTROPROOF_QEMU`,
-`DISTROPROOF_QEMU_IMG`, `DISTROPROOF_OVMF_CODE` et `DISTROPROOF_OVMF_VARS`.
+Host requirements: `qemu-system-x86_64`, `qemu-img`, `curl`, KVM (`/dev/kvm`,
+automatic fallback to TCG otherwise) and OVMF (`edk2-ovmf`, `ovmf`) for images
+that only boot with UEFI. Binaries can be chosen with `DISTROPROOF_QEMU`,
+`DISTROPROOF_QEMU_IMG`, `DISTROPROOF_OVMF_CODE` and `DISTROPROOF_OVMF_VARS`.
 
-### Cibles
+### Targets
 
-| Image | Noyau observé | Remarque |
+| Image | Observed kernel | Notes |
 | --- | --- | --- |
-| `debian-10`, `debian-11`, `debian-12`, `debian-13` | 4.19, 5.10, 6.1, 6.12 | 4.19 sans BTF ; 13 démarre en UEFI |
-| `ubuntu-18.04`, `ubuntu-20.04`, `ubuntu-22.04`, `ubuntu-24.04` | 4.15, 5.4, 5.15, 6.8 | 4.15 sans BTF |
-| `rocky-8`, `rocky-9` | 4.18, 5.14 | noyaux RHEL avec backports ; 9 démarre en UEFI |
-| `fedora-latest` | 6.19 (Fedora 44) | dernière release, résolue en ligne |
+| `debian-10`, `debian-11`, `debian-12`, `debian-13` | 4.19, 5.10, 6.1, 6.12 | 4.19 without BTF; 13 boots with UEFI |
+| `ubuntu-18.04`, `ubuntu-20.04`, `ubuntu-22.04`, `ubuntu-24.04` | 4.15, 5.4, 5.15, 6.8 | 4.15 without BTF |
+| `rocky-8`, `rocky-9` | 4.18, 5.14 | RHEL kernels with backports; 9 boots with UEFI |
+| `fedora-latest` | 6.19 (Fedora 44) | latest release, resolved online |
 | `arch` | rolling | |
 | `alpine` | 6.18 `virt` | musl, busybox |
 
-Les images sont téléchargées une fois, vérifiées contre le checksum publié
-par la distro et gardées dans `$XDG_CACHE_HOME/distroproof/images`. Chaque
-exécution travaille sur un overlay qcow2 jetable, supprimé à la fin, même
-après un timeout ou un Ctrl+C ; QEMU meurt avec distroproof.
-
-### Fonctionnement
-
-- QEMU démarre en pause (`-S`), distroproof se connecte à son socket QMP et
-  aux deux ports série (console sur ttyS0, canal de l'agent sur ttyS1), puis
-  lance la VM.
-- cloud-init (seed NoCloud écrit en Rust) extrait un disque payload (archive
-  tar brute : agent, `envprobe` statique, répertoire de travail) et lance
-  l'agent. Celui-ci applique les sysctls, crée l'utilisateur de test, lance
-  `envprobe` puis la commande, et relaie stdout et stderr ligne à ligne.
-- Les sorties complètes, les codes de retour et le rapport sont écrits sur un
-  disque de sortie (tar brut), puis la VM s'éteint. Pas de 9p ni de virtiofs,
-  absents des noyaux RHEL.
-- Au premier boot, l'agent extrait aussi noyau et initramfs : les exécutions
-  suivantes bootent en direct (`-kernel`), en 6 à 13 s, et peuvent modifier
-  la ligne de commande du noyau.
-- L'orchestrateur n'écrit jamais dans le terminal : il émet des événements
-  typés (`Booting`, `Output`, `Metrics`, `Finished`…) que la sortie texte,
-  la sortie JSON (`--progress json`) et la TUI consomment.
-
-### Matrice : `distroproof.toml`
+Images are downloaded once, verified against the checksum published by the
+distro and kept in `$XDG_CACHE_HOME/distroproof/images`. Each run works on a
+throwaway qcow2 overlay that is deleted at the end, even after a timeout or a
+Ctrl+C; QEMU dies with distroproof.
+
+### How it works
+
+- QEMU starts paused (`-S`); distroproof connects to its QMP socket and to the
+  two serial ports (console on ttyS0, agent channel on ttyS1), then starts the
+  VM.
+- cloud-init (NoCloud seed written in Rust) extracts a payload disk (raw tar
+  archive: agent, static `envprobe`, working directory) and starts the agent.
+  The agent applies the sysctls, creates the test user, runs `envprobe` then
+  the command, and relays stdout and stderr line by line.
+- Full outputs, exit codes and the report are written to an output disk (raw
+  tar), then the VM shuts down. No 9p or virtiofs, which RHEL kernels lack.
+- On first boot, the agent also extracts the kernel and initramfs: later runs
+  boot directly (`-kernel`) in 6 to 13 s and can change the kernel command
+  line.
+- The orchestrator never writes to the terminal: it emits typed events
+  (`Booting`, `Output`, `Metrics`, `Finished`…) consumed by the text output,
+  the JSON output (`--progress json`) and the TUI.
+
+### Matrix: `distroproof.toml`
 
 ```toml
 [defaults]
@@ -187,64 +185,64 @@ kernel_cmdline = "lockdown=confidentiality"
 name = "debian-nopmu"
 image = "debian-12"
 pmu = false                 # -cpu host,pmu=off
-caps = ["perfmon", "bpf"]   # capabilities de l'utilisateur de test
+caps = ["perfmon", "bpf"]   # capabilities of the test user
 
 [run]
-setup = "./scripts/install-deps.sh"   # en root, avant la sonde
-command = "./target/release/montool --selftest"
-as_user = "test"                      # ou "root"
-# exclude = [".git", "target"]        # copié dans /distroproof/work
-# include = ["target/release/montool"]
+setup = "./scripts/install-deps.sh"   # as root, before the probe
+command = "./target/release/mytool --selftest"
+as_user = "test"                      # or "root"
+# exclude = [".git", "target"]        # copied to /distroproof/work
+# include = ["target/release/mytool"]
 ```
 
-Une erreur (clé inconnue, image inexistante, durée invalide…) est signalée
-avec sa ligne et sa colonne, sans lancer de VM. `distroproof up` lance les
-cibles en parallèle (`--jobs`), joint à chaque résultat le rapport `envprobe`
-pris juste avant la commande, puis :
+Errors (unknown key, nonexistent image, invalid duration…) are reported with
+their line and column, without starting any VM. `distroproof up` runs the
+targets in parallel (`--jobs`), attaches to each result the `envprobe` report
+taken right before the command, then:
 
-- affiche le tableau cibles × résultat, avec durée, temps de boot, noyau et
-  extrait de stderr ;
-- compare chaque cible en échec à la cible réussie la plus proche et désigne
-  la différence suspecte (BTF absent, paranoid à 3, musl…) ;
-- écrit si demandé `--json`, `--junit` (CI) et `--markdown` (commentaire de PR).
+- prints the targets × result table, with duration, boot time, kernel and a
+  stderr excerpt;
+- compares each failed target with the closest successful one and points out
+  the suspicious difference (missing BTF, paranoid set to 3, musl…);
+- writes `--json`, `--junit` (CI) and `--markdown` (PR comment) on request.
 
 ```text
-[ubuntu-18.04] échec (code 1)
-  comparée à ubuntu-22.04 : 65 différences significatives
-  cause probable : btf.vmlinux : présent, 5286152 octets → indisponible (/sys/kernel/btf/vmlinux absent)
-  aussi : kernel.CONFIG_DEBUG_INFO_BTF : y → absente de la config
+[ubuntu-18.04] failed (code 1)
+  compared with ubuntu-22.04: 65 significant differences
+  probable cause: btf.vmlinux: present, 5286152 bytes → unavailable (/sys/kernel/btf/vmlinux missing)
+  also: kernel.CONFIG_DEBUG_INFO_BTF: y → not in the config
 ```
 
-Exemples : [`distroproof.toml`](distroproof.toml) (dogfooding d'envprobe sur
-10 cibles, lancé en CI par [`matrix.yml`](.github/workflows/matrix.yml)) et
-[`examples/require-btf`](examples/require-btf) (échec volontaire sans BTF).
+Examples: [`distroproof.toml`](distroproof.toml) (envprobe dogfooding on 10
+targets, run in CI by [`matrix.yml`](.github/workflows/matrix.yml)) and
+[`examples/require-btf`](examples/require-btf) (deliberate failure without BTF).
 
 ### TUI
 
-Dans un terminal, `distroproof up` ouvre une TUI (`--no-tui` pour la sortie
-texte, automatique sans TTY) : une carte par cible avec état, temps de boot,
-jauges CPU et mémoire et graphe Braille ; logs série en direct avec
-recherche ; rapport `envprobe` replié par section et diff contre une autre
-cible ; console série interactive. Avec `--hold`, chaque VM reste allumée
-après la commande avec un shell root sur la console.
+In a terminal, `distroproof up` opens a TUI (`--no-tui` for text output,
+automatic without a TTY): one card per target with state, boot time, CPU and
+memory gauges and a Braille graph; live serial logs with search; `envprobe`
+report folded by section and diff against another target; interactive serial
+console. With `--hold`, each VM stays up after the command with a root shell
+on the console.
 
-| Touche | Action |
+| Key | Action |
 | --- | --- |
-| `hjkl`, flèches | sélection, défilement |
-| `espace`, `r`, `x` | pause / reprise (QMP), relance, kill |
-| `c`, `i`, `Ctrl+]` | ouvrir la console, saisir, sortir |
-| `/`, `n`, `N` | recherche dans les logs |
-| `p` | épingler le panneau sur la cible sélectionnée |
-| `d`, `D` | diff du rapport contre une autre cible |
-| `D L R C` | vue dashboard, logs, rapport, console du panneau |
-| `Ctrl+W` `s` `v` `q` `hjkl` `<>+-` | tiling : découper, fermer, focus, taille |
-| `1`…`9` | workspaces (un par fichier avec plusieurs `-f`) |
-| `f` | filtre : toutes, en cours, échecs, terminées |
-| `:` ou `Ctrl+P` | palette de commandes |
-| `?`, `q` | aide, quitter |
-
-Couleurs dans `$XDG_CONFIG_HOME/distroproof/theme.toml` (true color, repli
-256 couleurs) :
+| `hjkl`, arrows | selection, scrolling |
+| `space`, `r`, `x` | pause / resume (QMP), restart, kill |
+| `c`, `i`, `Ctrl+]` | open the console, type, leave |
+| `/`, `n`, `N` | search the logs |
+| `p` | pin the pane to the selected target |
+| `d`, `D` | diff the report against another target |
+| `D L R C` | pane view: dashboard, logs, report, console |
+| `Ctrl+W` `s` `v` `q` `hjkl` `<>+-` | tiling: split, close, focus, resize |
+| `1`…`9` | workspaces (one per file with several `-f`) |
+| `f` | filter: all, running, failed, finished |
+| `:` or `Ctrl+P` | command palette |
+| `?`, `q` | help, quit |
+
+Colors live in `$XDG_CONFIG_HOME/distroproof/theme.toml` (true color, 256-color
+fallback):
 
 ```toml
 [colors]
@@ -260,13 +258,15 @@ rustup target add x86_64-unknown-linux-musl
 cargo build --release --target x86_64-unknown-linux-musl
 ```
 
-Les binaires sont statiques : `envprobe` tourne tel quel dans n'importe quelle
-VM ou conteneur x86_64, et `distroproof` trouve l'`envprobe` posé à côté de lui. L'édition de liens passe par `rust-lld` (voir
-`.cargo/config.toml`), ce qui permet aussi de compiler depuis arm64 vers x86_64.
+The binaries are static: `envprobe` runs as is in any x86_64 VM or container,
+and `distroproof` finds the `envprobe` sitting next to it. Linking goes
+through `rust-lld` (see `.cargo/config.toml`), which also allows building for
+x86_64 from arm64.
 
-Tests : `cargo test --workspace`. Pour régénérer le schéma après un changement
-du modèle : `UPDATE_SCHEMA=1 cargo test -p envprobe-core --test reports`.
+Tests: `cargo test --workspace`. To regenerate the schema after changing the
+model: `UPDATE_SCHEMA=1 cargo test -p envprobe-core --test reports`.
 
-## Licence
+## License
 
-Au choix, sous [MIT](LICENSE-MIT) ou [Apache 2.0](LICENSE-APACHE).
+Licensed under either [MIT](LICENSE-MIT) or [Apache 2.0](LICENSE-APACHE), at
+your option.
diff --git a/crates/distroproof/Cargo.toml b/crates/distroproof/Cargo.toml
index 9b0e807..43863da 100644
--- a/crates/distroproof/Cargo.toml
+++ b/crates/distroproof/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "distroproof"
-description = "Lance un programme dans une matrice de VM de distros"
+description = "Runs a program across a matrix of distro VMs"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
diff --git a/crates/distroproof/src/agent.sh b/crates/distroproof/src/agent.sh
index 1adb661..59594d7 100644
--- a/crates/distroproof/src/agent.sh
+++ b/crates/distroproof/src/agent.sh
@@ -1,18 +1,18 @@
 #!/bin/sh
-# Agent invité de distroproof, lancé en root par cloud-init (runcmd) depuis le
-# disque payload extrait dans /distroproof.
+# distroproof guest agent, run as root by cloud-init (runcmd) from the payload
+# disk extracted into /distroproof.
 #
-# Canal vers l'hôte : /dev/ttyS1, une ligne par message.
-#   @ READY <uptime>          agent démarré
-#   @ STAGE <étape>           début d'étape (setup, probe, command, kernel)
-#   @ EXIT <étape> <code>     fin d'étape
-#   @ WARN <message>          problème non bloquant (sysctl refusé…)
-#   @ DONE                    disque de sortie écrit, extinction imminente
-#   > <ligne>                 stdout de l'étape en cours
-#   ! <ligne>                 stderr de l'étape en cours
+# Channel to the host: /dev/ttyS1, one line per message.
+#   @ READY <uptime>          agent started
+#   @ STAGE <stage>           stage start (setup, probe, command, kernel)
+#   @ EXIT <stage> <code>     stage end
+#   @ WARN <message>          non-blocking problem (sysctl refused…)
+#   @ DONE                    output disk written, shutting down soon
+#   > <line>                  stdout of the current stage
+#   ! <line>                  stderr of the current stage
 #
-# Les sorties complètes, les codes de retour et le rapport envprobe sont
-# écrits dans une archive tar sur le disque de sortie (série dp-output).
+# Full outputs, exit codes and the envprobe report are written to a tar
+# archive on the output disk (serial dp-output).
 set -u
 D=/distroproof
 OUT=$D/out
@@ -28,8 +28,8 @@ warn() { say WARN "$*"; echo "$*" >>"$OUT/warnings"; }
 mkdir -p "$OUT"
 say READY "$(cut -d' ' -f1 /proc/uptime)"
 
-# Paramètres de la tâche : DP_USER, DP_CAPS, DP_PROBE, DP_EXTRACT_KERNEL,
-# DP_SETUP, DP_COMMAND (1 si job/setup.sh, job/command.sh existent).
+# Job parameters: DP_USER, DP_CAPS, DP_PROBE, DP_EXTRACT_KERNEL,
+# DP_SETUP, DP_COMMAND (1 if job/setup.sh, job/command.sh exist).
 . $D/job/env
 
 disk() {
@@ -48,8 +48,8 @@ relay() {
     done
 }
 
-# run <étape> <commande shell> : sorties copiées dans $OUT/<étape>.{out,err}
-# et relayées ligne à ligne sur le canal.
+# run <stage> <shell command>: outputs copied to $OUT/<stage>.{out,err}
+# and relayed line by line on the channel.
 run() {
     stage=$1
     shift
@@ -68,19 +68,19 @@ run() {
     return $rc
 }
 
-# Utilisateur de test. as_user <script> donne la commande qui lance le script
-# sous son identité, avec les capabilities demandées.
+# Test user. as_user <script> gives the command that runs the script under
+# that user's identity, with the requested capabilities.
 as_user() { echo "sh $1"; }
 if [ "$DP_USER" != root ]; then
     if ! id "$DP_USER" >/dev/null 2>&1; then
         useradd -m -s /bin/sh "$DP_USER" 2>/dev/null ||
             adduser -D -s /bin/sh "$DP_USER" 2>/dev/null ||
-            warn "création de l'utilisateur $DP_USER impossible"
+            warn "cannot create user $DP_USER"
     fi
     home=$(getent passwd "$DP_USER" 2>/dev/null | cut -d: -f6)
     [ -n "$home" ] || home=/home/$DP_USER
     envs="HOME=$home USER=$DP_USER LOGNAME=$DP_USER PATH=$PATH"
-    # setpriv de util-linux seulement : celui de busybox ignore --reuid.
+    # util-linux setpriv only: busybox's ignores --reuid.
     full_setpriv() { setpriv --help 2>&1 | grep -q -- --reuid; }
     if [ -n "$DP_CAPS" ] && ! full_setpriv; then
         command -v apk >/dev/null 2>&1 && apk add -q setpriv >/dev/null 2>&1
@@ -94,18 +94,18 @@ if [ "$DP_USER" != root ]; then
         prefix="setpriv --reuid=$DP_USER --regid=$(id -g "$DP_USER") --init-groups $caps env $envs"
         as_user() { echo "$prefix sh $1"; }
     else
-        [ -n "$DP_CAPS" ] && warn "setpriv absent : capabilities $DP_CAPS non accordées"
+        [ -n "$DP_CAPS" ] && warn "setpriv missing: capabilities $DP_CAPS not granted"
         as_user() { echo "su -s /bin/sh $DP_USER -c 'export $envs; sh $1'"; }
     fi
     chown -R "$DP_USER" $D/work 2>/dev/null
 fi
 
-# Variantes noyau à chaud.
+# Runtime kernel variants.
 if [ -f $D/job/sysctl ]; then
     while IFS='=' read -r key value; do
         [ -n "$key" ] || continue
         if ! printf '%s\n' "$value" >"/proc/sys/$(echo "$key" | tr . /)" 2>/dev/null; then
-            warn "sysctl $key=$value refusé"
+            warn "sysctl $key=$value refused"
         fi
     done <$D/job/sysctl
 fi
@@ -127,7 +127,7 @@ fi
 
 [ -n "$DP_COMMAND" ] && run command "$(as_user $D/job/command.sh)"
 
-# Noyau et initramfs pour les boots directs suivants.
+# Kernel and initramfs for the following direct boots.
 if [ "$DP_EXTRACT_KERNEL" = 1 ]; then
     say STAGE kernel
     r=$(uname -r)
@@ -149,29 +149,29 @@ if [ "$DP_EXTRACT_KERNEL" = 1 ]; then
         echo "$r" >"$OUT/kernel/release"
         say EXIT kernel 0
     else
-        warn "noyau introuvable dans /boot pour $r"
+        warn "kernel not found in /boot for $r"
         say EXIT kernel 1
     fi
 fi
 
 if out=$(disk dp-output); then
-    tar -cf "$out" -C "$OUT" . 2>/dev/null || warn "écriture du disque de sortie impossible"
+    tar -cf "$out" -C "$OUT" . 2>/dev/null || warn "cannot write the output disk"
 else
-    warn "disque de sortie introuvable"
+    warn "output disk not found"
 fi
 sync
 say DONE
 
 if [ "${DP_HOLD:-0}" = 1 ]; then
-    # VM gardée pour le débogage : shell root sur la console série, à la
-    # place du getty.
+    # VM kept up for debugging: root shell on the serial console, instead
+    # of the getty.
     systemctl stop serial-getty@ttyS0.service 2>/dev/null
     if grep -q ttyS0 /etc/inittab 2>/dev/null; then
         sed -i '/ttyS0/d' /etc/inittab && kill -HUP 1
         pkill -f 'getty.*ttyS0' 2>/dev/null
     fi
     stty -F /dev/ttyS0 sane 2>/dev/null
-    printf '\r\ndistroproof : commande terminée, shell root sur la console.\r\n' >/dev/ttyS0
+    printf '\r\ndistroproof: command finished, root shell on the console.\r\n' >/dev/ttyS0
     while :; do
         setsid sh -c 'exec sh -i </dev/ttyS0 >/dev/ttyS0 2>&1' || sleep 1
     done
diff --git a/crates/distroproof/src/config.rs b/crates/distroproof/src/config.rs
index 8a759a5..b4e4155 100644
--- a/crates/distroproof/src/config.rs
+++ b/crates/distroproof/src/config.rs
@@ -1,7 +1,7 @@
-//! Fichier déclaratif `distroproof.toml` : la matrice de test du projet.
+//! Declarative `distroproof.toml` file: the project's test matrix.
 //!
-//! Toute erreur (syntaxe, clé inconnue, image inexistante, durée invalide…)
-//! est signalée avec sa ligne et sa colonne, avant de lancer la moindre VM.
+//! Every error (syntax, unknown key, nonexistent image, invalid duration…)
+//! is reported with its line and column, before any VM is started.
 
 use std::collections::{BTreeMap, HashSet};
 use std::fmt;
@@ -17,10 +17,10 @@ use crate::model::VmSpec;
 
 pub const DEFAULT_FILE: &str = "distroproof.toml";
 
-/// Exclusions par défaut du répertoire de travail copié dans l'invité.
+/// Default exclusions for the working directory copied into the guest.
 pub const DEFAULT_EXCLUDE: &[&str] = &[".git", "target", ".distroproof"];
 
-/// Capabilities qu'on peut accorder à l'utilisateur de test.
+/// Capabilities that can be granted to the test user.
 const CAPABILITIES: &[&str] = &[
     "audit_control",
     "audit_read",
@@ -117,14 +117,14 @@ struct RawConfig {
     run: Option<Spanned<RawRun>>,
 }
 
-/// Erreur localisée dans le fichier.
+/// Error located in the file.
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ConfigError {
     pub path: PathBuf,
     pub line: usize,
     pub column: usize,
     pub message: String,
-    /// Ligne fautive et soulignement.
+    /// Offending line and underline.
     snippet: Option<(String, usize, usize)>,
 }
 
@@ -181,7 +181,7 @@ impl Ctx<'_> {
     }
 }
 
-/// Matrice validée.
+/// Validated matrix.
 #[derive(Debug, Clone)]
 pub struct Config {
     pub targets: Vec<VmSpec>,
@@ -192,7 +192,7 @@ pub fn load(path: &Path) -> Result<Config, ConfigError> {
         path: path.to_path_buf(),
         line: 0,
         column: 0,
-        message: format!("lecture impossible : {e}"),
+        message: format!("cannot read: {e}"),
         snippet: None,
     })?;
     parse(path, &text)
@@ -239,17 +239,14 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
     if run.command.is_none() && !probe {
         return Err(ctx.error(
             run_spanned.span(),
-            "rien à exécuter : [run] n'a ni command ni probe = true",
+            "nothing to run: [run] has neither command nor probe = true",
         ));
     }
     let workdir = match &run.workdir {
         Some(w) => {
             let dir = base.join(w.get_ref());
             if !dir.is_dir() {
-                return Err(ctx.error(
-                    w.span(),
-                    format!("répertoire introuvable : {}", dir.display()),
-                ));
+                return Err(ctx.error(w.span(), format!("directory not found: {}", dir.display())));
             }
             dir
         }
@@ -260,14 +257,14 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
         if !valid_env_name(k.get_ref()) {
             return Err(ctx.error(
                 k.span(),
-                format!("nom de variable invalide « {} »", k.get_ref()),
+                format!("invalid variable name \"{}\"", k.get_ref()),
             ));
         }
         env.insert(k.get_ref().clone(), v.clone());
     }
 
     if raw.target.is_empty() {
-        return Err(ctx.error(0..0, "aucune cible : ajoutez au moins un bloc [[target]]"));
+        return Err(ctx.error(0..0, "no targets: add at least one [[target]] block"));
     }
     let mut names = HashSet::new();
     let mut targets = Vec::new();
@@ -280,17 +277,17 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
         {
             return Err(ctx.error(
                 t.name.span(),
-                "nom de cible invalide (lettres, chiffres, « . », « _ » et « - »)",
+                "invalid target name (letters, digits, \".\", \"_\" and \"-\")",
             ));
         }
         if !names.insert(name.clone()) {
-            return Err(ctx.error(t.name.span(), format!("cible « {name} » déjà définie")));
+            return Err(ctx.error(t.name.span(), format!("target \"{name}\" already defined")));
         }
         if images::find(t.image.get_ref()).is_none() {
             return Err(ctx.error(
                 t.image.span(),
                 format!(
-                    "image inconnue « {} » (connues : {})",
+                    "unknown image \"{}\" (known: {})",
                     t.image.get_ref(),
                     images::names().join(", ")
                 ),
@@ -318,7 +315,7 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
                 || key.starts_with('.')
                 || key.contains("..")
             {
-                return Err(ctx.error(k.span(), format!("clé sysctl invalide « {key} »")));
+                return Err(ctx.error(k.span(), format!("invalid sysctl key \"{key}\"")));
             }
             let value = match v.get_ref() {
                 toml::Value::String(s) => s.clone(),
@@ -327,7 +324,7 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
                 _ => {
                     return Err(ctx.error(
                         v.span(),
-                        "valeur sysctl attendue : chaîne, entier ou booléen",
+                        "expected a sysctl value: string, integer or boolean",
                     ))
                 }
             };
@@ -335,7 +332,7 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
         }
         let kernel_cmdline = match &t.kernel_cmdline {
             Some(c) if c.get_ref().trim().is_empty() => {
-                return Err(ctx.error(c.span(), "kernel_cmdline vide"))
+                return Err(ctx.error(c.span(), "empty kernel_cmdline"))
             }
             Some(c) => Some(c.get_ref().trim().to_string()),
             None => None,
@@ -354,10 +351,9 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
             Some(c) => {
                 check_caps(c, &ctx)?;
                 if user == "root" && !c.get_ref().is_empty() {
-                    return Err(ctx.error(
-                        c.span(),
-                        "caps ne s'applique qu'à un utilisateur non root (as_user)",
-                    ));
+                    return Err(
+                        ctx.error(c.span(), "caps only applies to a non-root user (as_user)")
+                    );
                 }
                 c.get_ref().iter().map(|s| normalize_cap(s)).collect()
             }
@@ -393,7 +389,7 @@ pub fn parse(path: &Path, text: &str) -> Result<Config, ConfigError> {
 fn check_cpus(c: &Spanned<i64>, ctx: &Ctx) -> Result<u32, ConfigError> {
     match u32::try_from(*c.get_ref()) {
         Ok(n @ 1..=64) => Ok(n),
-        _ => Err(ctx.error(c.span(), "cpus doit être compris entre 1 et 64")),
+        _ => Err(ctx.error(c.span(), "cpus must be between 1 and 64")),
     }
 }
 
@@ -401,10 +397,7 @@ fn check_user(u: &Spanned<String>, ctx: &Ctx) -> Result<(), ConfigError> {
     if valid_user(u.get_ref()) {
         Ok(())
     } else {
-        Err(ctx.error(
-            u.span(),
-            format!("nom d'utilisateur invalide « {} »", u.get_ref()),
-        ))
+        Err(ctx.error(u.span(), format!("invalid user name \"{}\"", u.get_ref())))
     }
 }
 
@@ -437,11 +430,11 @@ pub fn check_cap(cap: &str) -> Result<(), String> {
     if CAPABILITIES.contains(&normalize_cap(cap).as_str()) {
         Ok(())
     } else {
-        Err(format!("capability inconnue « {cap} »"))
+        Err(format!("unknown capability \"{cap}\""))
     }
 }
 
-/// `512M`, `1G`, `1.5G`, `2048` (Mio par défaut).
+/// `512M`, `1G`, `1.5G`, `2048` (MiB by default).
 pub fn parse_size_mib(s: &str) -> Result<u64, String> {
     let t = s.trim();
     let (num, mult) = match t.char_indices().find(|(_, c)| c.is_ascii_alphabetic()) {
@@ -451,7 +444,7 @@ pub fn parse_size_mib(s: &str) -> Result<u64, String> {
                 "M" => 1.0,
                 "G" => 1024.0,
                 "T" => 1024.0 * 1024.0,
-                _ => return Err(format!("unité de taille inconnue dans « {s} » (M ou G)")),
+                _ => return Err(format!("unknown size unit in \"{s}\" (M or G)")),
             };
             (&t[..i], mult)
         }
@@ -460,18 +453,18 @@ pub fn parse_size_mib(s: &str) -> Result<u64, String> {
     let n: f64 = num
         .trim()
         .parse()
-        .map_err(|_| format!("taille invalide « {s} » (par exemple 512M ou 2G)"))?;
+        .map_err(|_| format!("invalid size \"{s}\" (for example 512M or 2G)"))?;
     let mib = (n * mult).round() as u64;
     if mib < 128 {
-        return Err(format!("{s} : au moins 128M de mémoire"));
+        return Err(format!("{s}: at least 128M of memory"));
     }
     Ok(mib)
 }
 
-/// `90s`, `5m`, `1h30m`, `300` (secondes).
+/// `90s`, `5m`, `1h30m`, `300` (seconds).
 pub fn parse_duration(s: &str) -> Result<Duration, String> {
     let t = s.trim();
-    let err = || format!("durée invalide « {s} » (par exemple 90s, 5m, 1h30m)");
+    let err = || format!("invalid duration \"{s}\" (for example 90s, 5m, 1h30m)");
     if t.is_empty() {
         return Err(err());
     }
@@ -544,7 +537,7 @@ kernel_cmdline = "lockdown=confidentiality"
 
 [run]
 setup = "./scripts/install-deps.sh"
-command = "./target/release/montool --selftest"
+command = "./target/release/mytool --selftest"
 as_user = "test"
 "#,
         )
@@ -569,7 +562,7 @@ as_user = "test"
         )
         .unwrap_err();
         assert_eq!((err.line, err.column), (3, 9));
-        assert!(err.message.contains("image inconnue"));
+        assert!(err.message.contains("unknown image"));
         let shown = err.to_string();
         assert!(shown.contains("distroproof.toml:3:9"));
         assert!(shown.contains("^^^^^^^^^"), "{shown}");
@@ -592,17 +585,17 @@ as_user = "test"
         assert!(parse_str(&dup)
             .unwrap_err()
             .message
-            .contains("déjà définie"));
+            .contains("already defined"));
         let bad_timeout = format!("{base}timeout = \"5 minutes\"\n");
         assert!(parse_str(&bad_timeout)
             .unwrap_err()
             .message
-            .contains("durée"));
+            .contains("duration"));
         let caps_root = format!("{base}caps = [\"bpf\"]\n");
         assert!(parse_str(&caps_root)
             .unwrap_err()
             .message
-            .contains("non root"));
+            .contains("non-root"));
         let caps_user = format!("{base}caps = [\"CAP_BPF\", \"perfmon\"]\nas_user = \"test\"\n");
         assert_eq!(
             parse_str(&caps_user).unwrap().targets[0].caps,
@@ -610,12 +603,12 @@ as_user = "test"
         );
         let bad_cap = format!("{base}caps = [\"fly\"]\nas_user = \"test\"\n");
         assert!(parse_str(&bad_cap).unwrap_err().message.contains("fly"));
-        assert!(parse_str("").unwrap_err().message.contains("aucune cible"));
+        assert!(parse_str("").unwrap_err().message.contains("no targets"));
         let nothing = format!("{base}[run]\nprobe = false\n");
         assert!(parse_str(&nothing)
             .unwrap_err()
             .message
-            .contains("rien à exécuter"));
+            .contains("nothing to run"));
         let int_sysctl = format!("{base}sysctl = {{ \"kernel.perf_event_paranoid\" = 3 }}\n");
         assert_eq!(
             parse_str(&int_sysctl).unwrap().targets[0].sysctl["kernel.perf_event_paranoid"],
diff --git a/crates/distroproof/src/dirs.rs b/crates/distroproof/src/dirs.rs
index 96125e3..cfd2be0 100644
--- a/crates/distroproof/src/dirs.rs
+++ b/crates/distroproof/src/dirs.rs
@@ -1,4 +1,4 @@
-//! Répertoires XDG utilisés par distroproof.
+//! XDG directories used by distroproof.
 
 use std::env;
 use std::path::PathBuf;
@@ -22,12 +22,12 @@ pub fn images() -> PathBuf {
     cache().join("images")
 }
 
-/// Répertoires de travail des VM en cours (overlays, disques jetables).
+/// Working directories of running VMs (overlays, throwaway disks).
 pub fn runs() -> PathBuf {
     cache().join("runs")
 }
 
-/// Répertoire court pour les sockets unix (108 octets maximum par chemin).
+/// Short directory for unix sockets (108 bytes at most per path).
 pub fn sockets() -> PathBuf {
     match env::var_os("XDG_RUNTIME_DIR") {
         Some(v) if !v.is_empty() => PathBuf::from(v).join("distroproof"),
diff --git a/crates/distroproof/src/event.rs b/crates/distroproof/src/event.rs
index 0c7f188..660d430 100644
--- a/crates/distroproof/src/event.rs
+++ b/crates/distroproof/src/event.rs
@@ -1,8 +1,8 @@
-//! Bus d'événements de l'orchestrateur.
+//! The orchestrator's event bus.
 //!
-//! L'orchestrateur n'écrit jamais dans le terminal : il émet des [`Event`]
-//! dans un channel tokio. La sortie texte, la sortie JSON et la TUI ne sont
-//! que des consommateurs de ce flux.
+//! The orchestrator never writes to the terminal: it emits [`Event`]s on a
+//! tokio channel. The text output, the JSON output and the TUI are only
+//! consumers of this stream.
 
 use std::path::PathBuf;
 
@@ -14,7 +14,7 @@ use crate::model::TargetResult;
 pub type EventTx = mpsc::UnboundedSender<Event>;
 pub type EventRx = mpsc::UnboundedReceiver<Event>;
 
-/// Un événement concernant une cible de la matrice.
+/// An event about one target of the matrix.
 #[derive(Debug, Clone, Serialize)]
 pub struct Event {
     pub target: String,
@@ -22,7 +22,7 @@ pub struct Event {
     pub kind: VmEvent,
 }
 
-/// Flux de sortie d'une commande dans l'invité.
+/// Output stream of a command in the guest.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Stream {
@@ -30,7 +30,7 @@ pub enum Stream {
     Stderr,
 }
 
-/// Étape exécutée par l'agent invité.
+/// Stage run by the guest agent.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Stage {
@@ -55,30 +55,30 @@ impl Stage {
         match self {
             Stage::Setup => "setup",
             Stage::Probe => "envprobe",
-            Stage::Command => "commande",
-            Stage::Kernel => "extraction du noyau",
+            Stage::Command => "command",
+            Stage::Kernel => "kernel extraction",
         }
     }
 }
 
-/// Métriques du processus QEMU et de la VM, rafraîchies chaque seconde.
+/// Metrics of the QEMU process and the VM, refreshed every second.
 #[derive(Debug, Clone, Copy, Default, Serialize)]
 pub struct Metrics {
-    /// CPU consommé par QEMU, en pourcentage d'un cœur (peut dépasser 100).
+    /// CPU used by QEMU, as a percentage of one core (can exceed 100).
     pub cpu_percent: f64,
     pub rss_bytes: u64,
     pub disk_read_bytes: u64,
     pub disk_write_bytes: u64,
-    /// Mémoire vue par l'invité selon le ballon virtio, si disponible.
+    /// Memory seen by the guest according to the virtio balloon, if available.
     pub guest_memory_bytes: Option<u64>,
 }
 
 #[derive(Debug, Clone, Serialize)]
 #[serde(tag = "event", rename_all = "snake_case")]
 pub enum VmEvent {
-    /// Cible mise en file, en attente d'un slot d'exécution.
+    /// Target queued, waiting for an execution slot.
     Queued,
-    /// Message informatif (résolution d'image, avertissement…).
+    /// Informational message (image resolution, warning…).
     Info {
         message: String,
     },
@@ -87,12 +87,12 @@ pub enum VmEvent {
         total: Option<u64>,
     },
     Verifying,
-    /// Image prête, issue du cache ou fraîchement téléchargée.
+    /// Image ready, from the cache or freshly downloaded.
     ImageReady {
         file: String,
         cached: bool,
     },
-    /// Boot préalable pour extraire noyau et initramfs (boot direct).
+    /// Preliminary boot to extract the kernel and initramfs (direct boot).
     Preparing,
     Booting {
         pid: u32,
@@ -100,7 +100,7 @@ pub enum VmEvent {
         console: PathBuf,
         direct_kernel: bool,
     },
-    /// L'agent invité a répondu : temps depuis le démarrage de la VM.
+    /// The guest agent answered: time since the VM started.
     Booted {
         boot_ms: u64,
     },
@@ -115,32 +115,32 @@ pub enum VmEvent {
         stream: Stream,
         line: String,
     },
-    /// Octets bruts de la console série (séquences ANSI comprises).
+    /// Raw serial console bytes (ANSI sequences included).
     #[serde(skip)]
     Console(Vec<u8>),
     Metrics(Metrics),
     Paused,
     Resumed,
-    /// Résultat disponible (la VM peut rester allumée avec --hold).
+    /// Result available (the VM may stay up with --hold).
     Finished(Box<TargetResult>),
-    /// VM gardée après la commande : shell root sur la console série.
+    /// VM kept up after the command: root shell on the serial console.
     Holding,
-    /// Processus QEMU terminé.
+    /// QEMU process exited.
     Stopped,
 }
 
-/// Commandes envoyées à une cible depuis un consommateur (TUI).
+/// Commands sent to a target by a consumer (TUI).
 #[derive(Debug, Clone)]
 pub enum Control {
     Pause,
     Resume,
     Kill,
     Restart,
-    /// Octets à écrire sur la console série.
+    /// Bytes to write to the serial console.
     ConsoleInput(Vec<u8>),
 }
 
-/// Émetteur lié à une cible.
+/// Sender bound to one target.
 #[derive(Clone)]
 pub struct Emitter {
     target: String,
@@ -156,8 +156,8 @@ impl Emitter {
     }
 
     pub fn emit(&self, kind: VmEvent) {
-        // Un consommateur parti (Ctrl+C) n'empêche pas l'orchestrateur de
-        // terminer proprement.
+        // A consumer that went away (Ctrl+C) does not stop the orchestrator from
+        // finishing cleanly.
         let _ = self.tx.send(Event {
             target: self.target.clone(),
             kind,
diff --git a/crates/distroproof/src/guest.rs b/crates/distroproof/src/guest.rs
index 5d11065..0296b7f 100644
--- a/crates/distroproof/src/guest.rs
+++ b/crates/distroproof/src/guest.rs
@@ -1,10 +1,9 @@
-//! Ce qui est injecté dans l'invité (seed cloud-init, disque payload) et ce
-//! qui en revient (disque de sortie).
+//! What goes into the guest (cloud-init seed, payload disk) and what comes
+//! back (output disk).
 //!
-//! Les disques payload et sortie sont des archives tar brutes posées sur un
-//! disque virtio : l'invité les lit et les écrit avec `tar -f /dev/vdX`, sans
-//! système de fichiers ni module noyau particulier (9p et virtiofs manquent
-//! sur les noyaux RHEL).
+//! The payload and output disks are raw tar archives on a virtio disk: the
+//! guest reads and writes them with `tar -f /dev/vdX`, with no filesystem and
+//! no special kernel module (RHEL kernels lack 9p and virtiofs).
 
 use std::fs::{self, File};
 use std::io::{self, Read};
@@ -15,10 +14,10 @@ use crate::model::VmSpec;
 
 pub const AGENT: &str = include_str!("agent.sh");
 
-/// Taille du disque de sortie (fichier creux) : sorties, rapport, noyau extrait.
+/// Size of the output disk (sparse file): outputs, report, extracted kernel.
 pub const OUTPUT_DISK_BYTES: u64 = 1 << 30;
 
-/// Seed NoCloud : cloud-init extrait le payload puis lance l'agent.
+/// NoCloud seed: cloud-init extracts the payload, then starts the agent.
 pub fn seed_iso(instance: &str) -> Vec<u8> {
     let user_data = r#"#cloud-config
 runcmd:
@@ -30,7 +29,7 @@ runcmd:
           mkdir -p /distroproof && tar -xf "/dev/${d##*/}" -C /distroproof && exec sh /distroproof/agent.sh
         fi
       done
-      echo "@ FATAL disque payload introuvable" > /dev/ttyS1
+      echo "@ FATAL payload disk not found" > /dev/ttyS1
 "#;
     let meta_data = format!("instance-id: {instance}\nlocal-hostname: {instance}\n");
     iso::build(
@@ -42,7 +41,7 @@ runcmd:
     )
 }
 
-/// Quote une valeur pour un script POSIX.
+/// Quotes a value for a POSIX script.
 pub fn shell_quote(s: &str) -> String {
     if !s.is_empty()
         && s.chars()
@@ -58,14 +57,14 @@ pub struct Payload<'a> {
     pub spec: &'a VmSpec,
     pub envprobe: &'a Path,
     pub extract_kernel: bool,
-    /// Boot de préparation : aucune étape, seulement l'extraction du noyau.
+    /// Preparation boot: no stages, only kernel extraction.
     pub prepare_only: bool,
 }
 
 impl Payload<'_> {
-    /// Écrit l'archive payload dans `path`.
+    /// Writes the payload archive to `path`.
     pub fn write(&self, path: &Path) -> Result<(), String> {
-        let file = File::create(path).map_err(|e| format!("{} : {e}", path.display()))?;
+        let file = File::create(path).map_err(|e| format!("{}: {e}", path.display()))?;
         let mut tar = tar::Builder::new(file);
         tar.follow_symlinks(false);
         let spec = self.spec;
@@ -126,7 +125,7 @@ impl Payload<'_> {
                 .map_err(|e| e.to_string())?;
         }
         tar.append_path_with_name(self.envprobe, "bin/envprobe")
-            .map_err(|e| format!("{} : {e}", self.envprobe.display()))?;
+            .map_err(|e| format!("{}: {e}", self.envprobe.display()))?;
 
         let mut dir = tar::Header::new_gnu();
         dir.set_entry_type(tar::EntryType::Directory);
@@ -137,11 +136,11 @@ impl Payload<'_> {
             .map_err(|e| e.to_string())?;
         if let (Some(workdir), true) = (&spec.workdir, run_steps) {
             for rel in work_files(workdir, &spec.exclude, &spec.include)
-                .map_err(|e| format!("{} : {e}", workdir.display()))?
+                .map_err(|e| format!("{}: {e}", workdir.display()))?
             {
                 let full = workdir.join(&rel);
                 tar.append_path_with_name(&full, Path::new("work").join(&rel))
-                    .map_err(|e| format!("{} : {e}", full.display()))?;
+                    .map_err(|e| format!("{}: {e}", full.display()))?;
             }
         }
         tar.into_inner()
@@ -154,7 +153,7 @@ fn script(body: &str) -> Vec<u8> {
     format!("#!/bin/sh\n{body}\n").into_bytes()
 }
 
-/// `*` et `?` sans traverser `/`.
+/// `*` and `?` without crossing `/`.
 fn glob(pat: &[u8], s: &[u8]) -> bool {
     match (pat.first(), s.first()) {
         (None, None) => true,
@@ -167,7 +166,7 @@ fn glob(pat: &[u8], s: &[u8]) -> bool {
     }
 }
 
-/// Un motif désigne un chemin ou l'un de ses parents.
+/// A pattern matches a path or one of its parents.
 fn matches(pattern: &str, rel: &Path) -> bool {
     let pattern = pattern.trim_start_matches("./").trim_end_matches('/');
     let mut prefix = PathBuf::new();
@@ -180,8 +179,8 @@ fn matches(pattern: &str, rel: &Path) -> bool {
     false
 }
 
-/// Fichiers du répertoire de travail à copier, chemins relatifs triés.
-/// `include` l'emporte sur `exclude`.
+/// Files of the working directory to copy, as sorted relative paths.
+/// `include` wins over `exclude`.
 pub fn work_files(root: &Path, exclude: &[String], include: &[String]) -> io::Result<Vec<PathBuf>> {
     let mut out = Vec::new();
     let mut stack = vec![PathBuf::new()];
@@ -209,7 +208,7 @@ pub fn work_files(root: &Path, exclude: &[String], include: &[String]) -> io::Re
     Ok(out)
 }
 
-/// Contenu du disque de sortie écrit par l'agent.
+/// Contents of the output disk written by the agent.
 #[derive(Debug, Default)]
 pub struct GuestOutput {
     files: Vec<(String, Vec<u8>)>,
diff --git a/crates/distroproof/src/images.rs b/crates/distroproof/src/images.rs
index d6492b6..2ad8e8b 100644
--- a/crates/distroproof/src/images.rs
+++ b/crates/distroproof/src/images.rs
@@ -1,9 +1,9 @@
-//! Catalogue des images cloud officielles et cache local.
+//! Catalog of official cloud images, and local cache.
 //!
-//! Les images cloud (qcow2) contiennent le noyau, l'initramfs et la config
-//! d'origine de la distro : c'est ce noyau qui tourne dans la VM. Elles sont
-//! téléchargées avec `curl`, vérifiées contre le checksum publié par la distro
-//! puis gardées dans `$XDG_CACHE_HOME/distroproof/images/<image>/`.
+//! Cloud images (qcow2) contain the distro's original kernel, initramfs and
+//! config: that kernel is what runs in the VM. They are downloaded with
+//! `curl`, verified against the checksum published by the distro, then kept
+//! in `$XDG_CACHE_HOME/distroproof/images/<image>/`.
 
 use std::collections::HashMap;
 use std::fs;
@@ -20,22 +20,22 @@ use tokio::sync::Mutex;
 use crate::dirs;
 use crate::event::{Emitter, VmEvent};
 
-/// Où trouver la dernière version d'une image.
+/// Where to find the latest version of an image.
 enum Source {
-    /// URL fixe et fichier de checksums publié à côté.
+    /// Fixed URL and the checksums file published next to it.
     Direct {
         url: &'static str,
         checksums: &'static str,
     },
-    /// Index HTML : le fichier le plus récent qui commence par `prefix` et
-    /// finit par `suffix`. Le checksum est dans `<fichier><checksum_suffix>`.
+    /// HTML index: the most recent file that starts with `prefix` and ends
+    /// with `suffix`. The checksum is in `<file><checksum_suffix>`.
     Listing {
         index: &'static str,
         prefix: &'static str,
         suffix: &'static str,
         checksum_suffix: &'static str,
     },
-    /// Dernière release Fedora qui publie une image Cloud Generic.
+    /// Latest Fedora release that publishes a Cloud Generic image.
     FedoraLatest,
 }
 
@@ -43,15 +43,15 @@ pub struct ImageDef {
     pub name: &'static str,
     pub description: &'static str,
     source: Source,
-    /// Le boot sur le disque exige UEFI : le grub BIOS de l'image redémarre
-    /// la machine aussitôt (Rocky 9, Debian 13). Le boot direct s'en passe.
+    /// Booting from disk requires UEFI: the image's BIOS grub reboots the
+    /// machine right away (Rocky 9, Debian 13). Direct boot does without it.
     pub uefi: bool,
 }
 
 pub const CATALOG: &[ImageDef] = &[
     ImageDef {
         name: "debian-10",
-        description: "Debian 10 buster (archive), noyau 4.19 sans BTF",
+        description: "Debian 10 buster (archive), kernel 4.19 without BTF",
         source: Source::Direct {
             url: "https://cloud.debian.org/images/cloud/buster/latest/debian-10-generic-amd64.qcow2",
             checksums: "https://cloud.debian.org/images/cloud/buster/latest/SHA512SUMS",
@@ -60,7 +60,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "debian-11",
-        description: "Debian 11 bullseye, noyau 5.10",
+        description: "Debian 11 bullseye, kernel 5.10",
         source: Source::Direct {
             url: "https://cloud.debian.org/images/cloud/bullseye/latest/debian-11-generic-amd64.qcow2",
             checksums: "https://cloud.debian.org/images/cloud/bullseye/latest/SHA512SUMS",
@@ -69,7 +69,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "debian-12",
-        description: "Debian 12 bookworm, noyau generic",
+        description: "Debian 12 bookworm, generic kernel",
         source: Source::Direct {
             url: "https://cloud.debian.org/images/cloud/bookworm/latest/debian-12-generic-amd64.qcow2",
             checksums: "https://cloud.debian.org/images/cloud/bookworm/latest/SHA512SUMS",
@@ -78,17 +78,17 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "debian-13",
-        description: "Debian 13 trixie, noyau generic",
+        description: "Debian 13 trixie, generic kernel",
         source: Source::Direct {
             url: "https://cloud.debian.org/images/cloud/trixie/latest/debian-13-generic-amd64.qcow2",
             checksums: "https://cloud.debian.org/images/cloud/trixie/latest/SHA512SUMS",
         },
-        // Le grub BIOS de l'image redémarre la machine dès le chargement du noyau.
+        // The image's BIOS grub reboots the machine as soon as the kernel loads.
         uefi: true,
     },
     ImageDef {
         name: "ubuntu-18.04",
-        description: "Ubuntu 18.04 bionic, noyau 4.15 sans BTF",
+        description: "Ubuntu 18.04 bionic, kernel 4.15 without BTF",
         source: Source::Direct {
             url: "https://cloud-images.ubuntu.com/releases/18.04/release/ubuntu-18.04-server-cloudimg-amd64.img",
             checksums: "https://cloud-images.ubuntu.com/releases/18.04/release/SHA256SUMS",
@@ -97,7 +97,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "ubuntu-20.04",
-        description: "Ubuntu 20.04 focal, noyau 5.4",
+        description: "Ubuntu 20.04 focal, kernel 5.4",
         source: Source::Direct {
             url: "https://cloud-images.ubuntu.com/releases/20.04/release/ubuntu-20.04-server-cloudimg-amd64.img",
             checksums: "https://cloud-images.ubuntu.com/releases/20.04/release/SHA256SUMS",
@@ -124,7 +124,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "rocky-9",
-        description: "Rocky Linux 9 (RHEL 9, noyau 5.14)",
+        description: "Rocky Linux 9 (RHEL 9, kernel 5.14)",
         source: Source::Direct {
             url: "https://dl.rockylinux.org/pub/rocky/9/images/x86_64/Rocky-9-GenericCloud-Base.latest.x86_64.qcow2",
             checksums: "https://dl.rockylinux.org/pub/rocky/9/images/x86_64/Rocky-9-GenericCloud-Base.latest.x86_64.qcow2.CHECKSUM",
@@ -133,7 +133,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "rocky-8",
-        description: "Rocky Linux 8 (RHEL 8, noyau 4.18)",
+        description: "Rocky Linux 8 (RHEL 8, kernel 4.18)",
         source: Source::Direct {
             url: "https://dl.rockylinux.org/pub/rocky/8/images/x86_64/Rocky-8-GenericCloud-Base.latest.x86_64.qcow2",
             checksums: "https://dl.rockylinux.org/pub/rocky/8/images/x86_64/Rocky-8-GenericCloud-Base.latest.x86_64.qcow2.CHECKSUM",
@@ -142,13 +142,13 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "fedora-latest",
-        description: "Dernière Fedora Cloud Base Generic",
+        description: "Latest Fedora Cloud Base Generic",
         source: Source::FedoraLatest,
         uefi: false,
     },
     ImageDef {
         name: "arch",
-        description: "Arch Linux, image cloud officielle",
+        description: "Arch Linux, official cloud image",
         source: Source::Direct {
             url: "https://geo.mirror.pkgbuild.com/images/latest/Arch-Linux-x86_64-cloudimg.qcow2",
             checksums: "https://geo.mirror.pkgbuild.com/images/latest/Arch-Linux-x86_64-cloudimg.qcow2.SHA256",
@@ -157,7 +157,7 @@ pub const CATALOG: &[ImageDef] = &[
     },
     ImageDef {
         name: "alpine",
-        description: "Alpine stable, image generic BIOS avec cloud-init",
+        description: "Alpine stable, generic BIOS image with cloud-init",
         source: Source::Listing {
             index: "https://dl-cdn.alpinelinux.org/alpine/latest-stable/releases/cloud/",
             prefix: "generic_alpine-",
@@ -176,16 +176,16 @@ pub fn names() -> Vec<&'static str> {
     CATALOG.iter().map(|d| d.name).collect()
 }
 
-/// Version précise d'une image, telle que résolue en ligne.
+/// Exact version of an image, as resolved online.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 struct Resolved {
     url: String,
     file: String,
-    /// Checksum hexadécimal publié (sha256 ou sha512 selon la longueur).
+    /// Published hex checksum (sha256 or sha512 depending on its length).
     checksum: String,
 }
 
-/// Image prête à l'emploi.
+/// Image ready to use.
 #[derive(Debug, Clone)]
 pub struct Image {
     pub name: String,
@@ -195,7 +195,7 @@ pub struct Image {
 }
 
 impl Image {
-    /// Noyau et initramfs extraits de l'image pour le boot direct.
+    /// Kernel and initramfs extracted from the image for direct boot.
     pub fn kernel_dir(&self) -> PathBuf {
         self.path.with_extension("kernel")
     }
@@ -205,12 +205,12 @@ impl Image {
     }
 }
 
-/// Noyau extrait par l'agent lors d'un premier boot depuis le disque.
+/// Kernel extracted by the agent during a first boot from disk.
 #[derive(Debug, Clone)]
 pub struct DirectKernel {
     pub kernel: PathBuf,
     pub initrd: Option<PathBuf>,
-    /// Ligne de commande d'origine, sans `BOOT_IMAGE` ni `console=`.
+    /// Original command line, without `BOOT_IMAGE` or `console=`.
     pub cmdline: String,
 }
 
@@ -230,7 +230,7 @@ impl DirectKernel {
     }
 }
 
-/// Retire de la ligne de commande d'origine ce que distroproof fixe lui-même.
+/// Removes from the original command line what distroproof sets itself.
 pub fn clean_cmdline(cmdline: &str) -> String {
     cmdline
         .split_whitespace()
@@ -248,8 +248,8 @@ pub fn clean_cmdline(cmdline: &str) -> String {
         .join(" ")
 }
 
-/// Cache partagé par toutes les cibles : une image n'est téléchargée qu'une
-/// fois même si plusieurs cibles l'utilisent en parallèle.
+/// Cache shared by every target: an image is downloaded only once, even when
+/// several targets use it in parallel.
 #[derive(Clone, Default)]
 pub struct Store {
     locks: Arc<StdMutex<HashMap<String, Arc<Mutex<()>>>>>,
@@ -265,36 +265,32 @@ impl Store {
     }
 
     fn lock(&self, name: &str) -> Arc<Mutex<()>> {
-        let mut locks = self.locks.lock().expect("verrou du cache");
+        let mut locks = self.locks.lock().expect("cache lock");
         locks.entry(name.to_string()).or_default().clone()
     }
 
-    /// Verrou exclusif sur une image, pour préparer son noyau sans course.
+    /// Exclusive lock on an image, to prepare its kernel without races.
     pub async fn exclusive(&self, name: &str) -> tokio::sync::OwnedMutexGuard<()> {
         self.lock(name).lock_owned().await
     }
 
-    /// Image locale vérifiée, téléchargée si besoin.
+    /// Verified local image, downloaded if needed.
     pub async fn ensure(&self, name: &str, ev: &Emitter) -> Result<Image, String> {
-        let def = find(name).ok_or_else(|| {
-            format!(
-                "image inconnue « {name} » (connues : {})",
-                names().join(", ")
-            )
-        })?;
+        let def = find(name)
+            .ok_or_else(|| format!("unknown image \"{name}\" (known: {})", names().join(", ")))?;
         let lock = self.lock(name);
         let _guard = lock.lock().await;
         let dir = dirs::images().join(name);
-        fs::create_dir_all(&dir).map_err(|e| format!("{} : {e}", dir.display()))?;
-        // Verrou entre processus : deux distroproof ne téléchargent pas la
-        // même image en même temps.
+        fs::create_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
+        // Inter-process lock: two distroproof instances never download the
+        // same image at the same time.
         let lock_file = fs::File::create(dir.join(".lock")).map_err(|e| e.to_string())?;
         let _flock = tokio::task::spawn_blocking(move || {
             crate::sys::lock_exclusive(&lock_file).map(|()| lock_file)
         })
         .await
         .map_err(|e| e.to_string())?
-        .map_err(|e| format!("verrou du cache : {e}"))?;
+        .map_err(|e| format!("cache lock: {e}"))?;
         let current_path = dir.join("current.json");
         let current: Option<Resolved> = fs::read_to_string(&current_path)
             .ok()
@@ -303,18 +299,16 @@ impl Store {
         let resolved = if self.offline {
             current
                 .clone()
-                .ok_or_else(|| format!("{name} : absente du cache (mode hors ligne)"))?
+                .ok_or_else(|| format!("{name}: not in the cache (offline mode)"))?
         } else {
             match resolve(def).await {
                 Ok(r) => r,
                 Err(err) => match &current {
                     Some(c) if dir.join(&c.file).is_file() => {
-                        ev.info(format!(
-                            "résolution impossible ({err}), image du cache utilisée"
-                        ));
+                        ev.info(format!("cannot resolve ({err}), using the cached image"));
                         c.clone()
                     }
-                    _ => return Err(format!("{name} : {err}")),
+                    _ => return Err(format!("{name}: {err}")),
                 },
             }
         };
@@ -332,21 +326,21 @@ impl Store {
             let actual = tokio::task::spawn_blocking(move || hash_file(&part2, expected.len()))
                 .await
                 .map_err(|e| e.to_string())?
-                .map_err(|e| format!("lecture de {} : {e}", part.display()))?;
+                .map_err(|e| format!("reading {}: {e}", part.display()))?;
             if actual != resolved.checksum {
                 let _ = fs::remove_file(&part);
                 return Err(format!(
-                    "{} : checksum invalide (attendu {}, obtenu {actual})",
+                    "{}: checksum mismatch (expected {}, got {actual})",
                     resolved.file, resolved.checksum
                 ));
             }
             fs::rename(&part, &path).map_err(|e| e.to_string())?;
-            // Le noyau extrait d'une version précédente n'est plus valable.
+            // A kernel extracted from a previous version is no longer valid.
             let _ = fs::remove_dir_all(path.with_extension("kernel"));
             fs::write(&verified, &resolved.checksum).map_err(|e| e.to_string())?;
         }
         if current.as_ref() != Some(&resolved) {
-            let json = serde_json::to_string_pretty(&resolved).expect("sérialisable");
+            let json = serde_json::to_string_pretty(&resolved).expect("serializable");
             fs::write(&current_path, json).map_err(|e| e.to_string())?;
         }
         remove_stale(&dir, &resolved.file);
@@ -363,7 +357,7 @@ impl Store {
     }
 }
 
-/// Supprime les anciennes versions d'une image pour garder le cache propre.
+/// Removes old versions of an image to keep the cache clean.
 fn remove_stale(dir: &Path, keep: &str) {
     let Ok(entries) = fs::read_dir(dir) else {
         return;
@@ -395,7 +389,7 @@ async fn resolve(def: &ImageDef) -> Result<Resolved, String> {
             let file = url.rsplit('/').next().unwrap_or(url).to_string();
             let sums = fetch_text(checksums).await?;
             let checksum = find_checksum(&sums, &file)
-                .ok_or_else(|| format!("checksum de {file} absent de {checksums}"))?;
+                .ok_or_else(|| format!("checksum of {file} missing from {checksums}"))?;
             Ok(Resolved {
                 url: url.to_string(),
                 file,
@@ -410,11 +404,11 @@ async fn resolve(def: &ImageDef) -> Result<Resolved, String> {
         } => {
             let html = fetch_text(index).await?;
             let file = latest_listed(&html, prefix, suffix)
-                .ok_or_else(|| format!("aucun fichier {prefix}*{suffix} dans {index}"))?;
+                .ok_or_else(|| format!("no {prefix}*{suffix} file in {index}"))?;
             let url = format!("{index}{file}");
             let sums = fetch_text(&format!("{url}{checksum_suffix}")).await?;
             let checksum = find_checksum(&sums, &file)
-                .ok_or_else(|| format!("checksum de {file} introuvable"))?;
+                .ok_or_else(|| format!("checksum of {file} not found"))?;
             Ok(Resolved {
                 url,
                 file,
@@ -422,16 +416,16 @@ async fn resolve(def: &ImageDef) -> Result<Resolved, String> {
             })
         }
         Source::FedoraLatest => {
-            // Le miroir principal plutôt que le redirecteur
-            // download.fedoraproject.org : un miroir pas encore synchronisé
-            // liste la nouvelle release sans ses images.
+            // The primary mirror rather than the download.fedoraproject.org
+            // redirector: a mirror that is not yet in sync lists the new
+            // release without its images.
             let base = "https://dl.fedoraproject.org/pub/fedora/linux/releases/";
             let html = fetch_text(base).await?;
             let mut releases: Vec<u32> = hrefs(&html)
                 .filter_map(|h| h.strip_suffix('/')?.parse().ok())
                 .collect();
             releases.sort_unstable_by(|a, b| b.cmp(a));
-            let mut last = "aucune release listée".to_string();
+            let mut last = "no release listed".to_string();
             for release in releases.into_iter().take(3) {
                 let index = format!("{base}{release}/Cloud/x86_64/images/");
                 let html = match fetch_text(&index).await {
@@ -443,16 +437,16 @@ async fn resolve(def: &ImageDef) -> Result<Resolved, String> {
                 };
                 let Some(file) = latest_listed(&html, "Fedora-Cloud-Base-Generic-", ".qcow2")
                 else {
-                    last = format!("pas d'image Cloud Generic dans {index}");
+                    last = format!("no Cloud Generic image in {index}");
                     continue;
                 };
                 let Some(sums_file) = hrefs(&html).find(|h| h.ends_with("-CHECKSUM")) else {
-                    last = format!("pas de fichier CHECKSUM dans {index}");
+                    last = format!("no CHECKSUM file in {index}");
                     continue;
                 };
                 let sums = fetch_text(&format!("{index}{sums_file}")).await?;
                 let checksum = find_checksum(&sums, &file)
-                    .ok_or_else(|| format!("checksum de {file} absent de {sums_file}"))?;
+                    .ok_or_else(|| format!("checksum of {file} missing from {sums_file}"))?;
                 return Ok(Resolved {
                     url: format!("{index}{file}"),
                     file,
@@ -460,20 +454,20 @@ async fn resolve(def: &ImageDef) -> Result<Resolved, String> {
                 });
             }
             Err(format!(
-                "aucune release Fedora avec une image Cloud Generic ({last})"
+                "no Fedora release with a Cloud Generic image ({last})"
             ))
         }
     }
 }
 
-/// Liens `href="…"` d'un index HTML.
+/// `href="…"` links of an HTML index.
 fn hrefs(html: &str) -> impl Iterator<Item = &str> {
     html.split("href=\"")
         .skip(1)
         .filter_map(|rest| rest.split('"').next())
 }
 
-/// Fichier listé le plus récent selon un tri de versions naturel.
+/// Most recent listed file, by natural version sort.
 fn latest_listed(html: &str, prefix: &str, suffix: &str) -> Option<String> {
     let mut files: Vec<&str> = hrefs(html)
         .map(|h| h.rsplit('/').next().unwrap_or(h))
@@ -484,7 +478,7 @@ fn latest_listed(html: &str, prefix: &str, suffix: &str) -> Option<String> {
     files.last().map(|s| s.to_string())
 }
 
-/// Compare en traitant les suites de chiffres comme des nombres (3.9 < 3.10).
+/// Compares treating digit runs as numbers (3.9 < 3.10).
 fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
     fn chunks(s: &str) -> Vec<Result<u64, String>> {
         let mut out = Vec::new();
@@ -514,9 +508,9 @@ fn natural_cmp(a: &str, b: &str) -> std::cmp::Ordering {
     chunks(a).cmp(&chunks(b))
 }
 
-/// Cherche le checksum de `file` dans un fichier de sommes, quel qu'en soit
-/// le format : GNU (`hash  fichier`, `hash *fichier`), BSD
-/// (`SHA256 (fichier) = hash`) ou un hash seul.
+/// Finds the checksum of `file` in a sums file, whatever its format: GNU
+/// (`hash  file`, `hash *file`), BSD (`SHA256 (file) = hash`) or a bare
+/// hash.
 pub fn find_checksum(sums: &str, file: &str) -> Option<String> {
     let is_hash =
         |w: &str| (w.len() == 64 || w.len() == 128) && w.chars().all(|c| c.is_ascii_hexdigit());
@@ -575,10 +569,10 @@ async fn fetch_text(url: &str) -> Result<String, String> {
         .kill_on_drop(true)
         .output()
         .await
-        .map_err(|e| format!("curl introuvable : {e}"))?;
+        .map_err(|e| format!("curl not found: {e}"))?;
     if !out.status.success() {
         return Err(format!(
-            "{url} : {}",
+            "{url}: {}",
             String::from_utf8_lossy(&out.stderr).trim()
         ));
     }
@@ -602,7 +596,7 @@ async fn content_length(url: &str) -> Option<u64> {
         })
 }
 
-/// Télécharge dans `<fichier>.part`, avec reprise si un fichier partiel existe.
+/// Downloads to `<file>.part`, resuming if a partial file exists.
 async fn download(resolved: &Resolved, path: &Path, ev: &Emitter) -> Result<(), String> {
     let part = path.with_extension("part");
     let total = content_length(&resolved.url).await;
@@ -623,7 +617,7 @@ async fn download(resolved: &Resolved, path: &Path, ev: &Emitter) -> Result<(),
         .kill_on_drop(true)
         .stderr(std::process::Stdio::piped())
         .spawn()
-        .map_err(|e| format!("curl introuvable : {e}"))?;
+        .map_err(|e| format!("curl not found: {e}"))?;
     let mut tick = tokio::time::interval(Duration::from_millis(500));
     let status = loop {
         tokio::select! {
@@ -640,15 +634,11 @@ async fn download(resolved: &Resolved, path: &Path, ev: &Emitter) -> Result<(),
             use tokio::io::AsyncReadExt;
             let _ = stderr.read_to_string(&mut err).await;
         }
-        // Code 33 : le serveur refuse la reprise, on repart de zéro au prochain essai.
+        // Code 33: the server refuses to resume, start from scratch on the next try.
         if status.code() == Some(33) {
             let _ = fs::remove_file(&part);
         }
-        return Err(format!(
-            "téléchargement de {} : {}",
-            resolved.url,
-            err.trim()
-        ));
+        return Err(format!("downloading {}: {}", resolved.url, err.trim()));
     }
     if let Some(total) = total {
         ev.emit(VmEvent::Downloading {
@@ -659,7 +649,7 @@ async fn download(resolved: &Resolved, path: &Path, ev: &Emitter) -> Result<(),
     Ok(())
 }
 
-/// État du cache, pour `distroproof images`.
+/// Cache status, for `distroproof images`.
 pub struct CacheEntry {
     pub name: &'static str,
     pub description: &'static str,
diff --git a/crates/distroproof/src/iso.rs b/crates/distroproof/src/iso.rs
index 6af5b9f..aee2a49 100644
--- a/crates/distroproof/src/iso.rs
+++ b/crates/distroproof/src/iso.rs
@@ -1,8 +1,8 @@
-//! Écriture d'une image ISO 9660 minimale avec extension Joliet.
+//! Writes a minimal ISO 9660 image with the Joliet extension.
 //!
-//! Sert uniquement au seed cloud-init (NoCloud) : quelques petits fichiers à
-//! la racine et un label de volume `cidata`. Joliet conserve les noms en
-//! minuscules (`user-data`, `meta-data`), que Linux préfère à la table ISO.
+//! Only used for the cloud-init (NoCloud) seed: a few small files at the root
+//! and a `cidata` volume label. Joliet keeps lowercase names (`user-data`,
+//! `meta-data`), which Linux prefers over the ISO table.
 
 const SECTOR: usize = 2048;
 
@@ -18,7 +18,7 @@ fn both32(v: u32) -> [u8; 8] {
     [le[0], le[1], le[2], le[3], be[0], be[1], be[2], be[3]]
 }
 
-/// Encodage des noms : ISO (a-characters en majuscules) ou Joliet (UCS-2 BE).
+/// Name encoding: ISO (uppercase a-characters) or Joliet (UCS-2 BE).
 #[derive(Clone, Copy)]
 enum Names {
     Iso,
@@ -79,7 +79,7 @@ fn dir_record(extent: u32, size: u32, is_dir: bool, id: &[u8]) -> Vec<u8> {
     r[0] = len as u8;
     r[2..10].copy_from_slice(&both32(extent));
     r[10..18].copy_from_slice(&both32(size));
-    // 1er janvier 2000, UTC.
+    // January 1st, 2000, UTC.
     r[18..25].copy_from_slice(&[100, 1, 1, 0, 0, 0, 0]);
     r[25] = if is_dir { 2 } else { 0 };
     r[28..32].copy_from_slice(&both16(1));
@@ -124,7 +124,7 @@ fn volume_descriptor(
     d[40..72].copy_from_slice(&names.text(label, 32));
     d[80..88].copy_from_slice(&both32(total));
     if let Names::Joliet = names {
-        // Séquence d'échappement UCS-2 niveau 3.
+        // UCS-2 level 3 escape sequence.
         d[88..91].copy_from_slice(b"%/E");
     }
     d[120..124].copy_from_slice(&both16(1));
@@ -142,7 +142,7 @@ fn volume_descriptor(
         let len = range.len();
         d[range].copy_from_slice(&names.text("", len));
     }
-    // Dates « non précisées » : seize chiffres zéro et fuseau 0.
+    // "Not specified" dates: sixteen zero digits and time zone 0.
     for start in [813, 830, 847, 864] {
         d[start..start + 16].copy_from_slice(b"0000000000000000");
     }
@@ -157,21 +157,18 @@ fn root_dir(names: Names, root: u32, files: &[(String, u32, u32)]) -> Vec<u8> {
     for (name, extent, size) in files {
         dir.extend(dir_record(*extent, *size, false, &names.file_id(name)));
     }
-    assert!(
-        dir.len() <= SECTOR,
-        "trop de fichiers pour un seed cloud-init"
-    );
+    assert!(dir.len() <= SECTOR, "too many files for a cloud-init seed");
     dir.resize(SECTOR, 0);
     dir
 }
 
-/// Construit une ISO contenant `files` à la racine.
+/// Builds an ISO holding `files` at its root.
 pub fn build(label: &str, files: &[(&str, &[u8])]) -> Vec<u8> {
     let mut files: Vec<(&str, &[u8])> = files.to_vec();
     files.sort_by(|a, b| a.0.cmp(b.0));
 
-    // 0-15 zone système, 16 PVD, 17 SVD Joliet, 18 terminateur,
-    // 19-22 tables de chemins, 23-24 répertoires racine, puis les données.
+    // 0-15 system area, 16 PVD, 17 Joliet SVD, 18 terminator,
+    // 19-22 path tables, 23-24 root directories, then the data.
     let (pvd, svd, term) = (16u32, 17u32, 18u32);
     let (iso_l, iso_m, jol_l, jol_m) = (19u32, 20u32, 21u32, 22u32);
     let (iso_root, jol_root) = (23u32, 24u32);
@@ -228,7 +225,7 @@ mod tests {
         assert_eq!(&img[16 * SECTOR + 40..16 * SECTOR + 46], b"cidata");
         let total = u32::from_le_bytes(img[16 * SECTOR + 80..16 * SECTOR + 84].try_into().unwrap());
         assert_eq!(total as usize * SECTOR, img.len());
-        // meta-data trié avant user-data : secteur 25, puis 26.
+        // meta-data sorts before user-data: sector 25, then 26.
         assert_eq!(img[26 * SECTOR], b'#');
         assert_eq!(img[25 * SECTOR], b'x');
         let joliet_root = &img[24 * SECTOR..25 * SECTOR];
diff --git a/crates/distroproof/src/main.rs b/crates/distroproof/src/main.rs
index dc46501..389c0ab 100644
--- a/crates/distroproof/src/main.rs
+++ b/crates/distroproof/src/main.rs
@@ -1,5 +1,5 @@
-//! distroproof : lance un programme dans des VM qui tournent avec le vrai
-//! noyau de chaque distro cible, et récupère sa sortie.
+//! distroproof: runs a program in VMs booted on the real kernel of each
+//! target distro, and collects its output.
 
 mod config;
 mod dirs;
@@ -30,8 +30,8 @@ use crate::model::{Outcome, VmSpec};
 use crate::progress::{fmt_bytes, Progress};
 use crate::vm::Runner;
 
-/// Lance un programme dans une matrice de VM de distros, chacune avec son
-/// propre noyau.
+/// Runs a program across a matrix of distro VMs, each one on its own
+/// kernel.
 #[derive(Parser, Debug)]
 #[command(version, about)]
 struct Cli {
@@ -41,24 +41,24 @@ struct Cli {
 
 #[derive(Subcommand, Debug)]
 enum Command {
-    /// Lance une commande dans une VM et renvoie sa sortie et son code.
+    /// Runs a command in a VM and returns its output and exit code.
     Run(RunArgs),
-    /// Lance toute la matrice décrite dans distroproof.toml.
+    /// Runs the whole matrix described in distroproof.toml.
     Up(UpArgs),
-    /// Valide distroproof.toml sans lancer de VM.
+    /// Validates distroproof.toml without starting any VM.
     Check {
-        /// Fichier de matrice.
+        /// Matrix file.
         #[arg(short, long, default_value = config::DEFAULT_FILE)]
         file: PathBuf,
     },
-    /// Réaffiche un rapport de matrice JSON dans un autre format.
+    /// Renders a JSON matrix report again in another format.
     Report {
-        /// Rapport écrit par `distroproof up --json`.
+        /// Report written by `distroproof up --json`.
         file: PathBuf,
         #[arg(long, value_enum, default_value_t = Format::Text)]
         format: Format,
     },
-    /// Gère le cache des images.
+    /// Manages the image cache.
     Images {
         #[command(subcommand)]
         action: Option<ImagesAction>,
@@ -67,35 +67,35 @@ enum Command {
 
 #[derive(Subcommand, Debug)]
 enum ImagesAction {
-    /// Catalogue et état du cache (défaut).
+    /// Catalog and cache status (default).
     List,
-    /// Télécharge et vérifie des images.
+    /// Downloads and verifies images.
     Pull {
-        /// Images à télécharger (toutes si vide).
+        /// Images to download (all of them if empty).
         names: Vec<String>,
     },
-    /// Vide le cache des images et les exécutions abandonnées.
+    /// Empties the image cache and abandoned runs.
     Prune,
 }
 
 #[derive(Args, Debug, Clone)]
 struct Common {
-    /// Binaire envprobe statique à copier dans l'invité.
+    /// Static envprobe binary to copy into the guest.
     #[arg(long, env = "DISTROPROOF_ENVPROBE")]
     envprobe: Option<PathBuf>,
-    /// N'accède pas au réseau : images du cache uniquement.
+    /// No network access: cached images only.
     #[arg(long)]
     offline: bool,
-    /// Toujours booter sur le disque, sans noyau extrait.
+    /// Always boot from disk, without an extracted kernel.
     #[arg(long)]
     no_direct_boot: bool,
-    /// Garde les répertoires d'exécution (overlay, disques) pour déboguer.
+    /// Keeps the run directories (overlay, disks) for debugging.
     #[arg(long)]
     keep: bool,
-    /// Affichage de la progression sur stderr.
+    /// Progress display on stderr.
     #[arg(long, value_enum, default_value_t = Progress::Text)]
     progress: Progress,
-    /// Relaie aussi la sortie de la commande dans la progression.
+    /// Also relays the command's output in the progress display.
     #[arg(short, long)]
     verbose: bool,
 }
@@ -110,33 +110,33 @@ enum Format {
 
 #[derive(Args, Debug)]
 struct UpArgs {
-    /// Fichier de matrice ; répétable, un workspace de TUI par fichier.
+    /// Matrix file; repeatable, one TUI workspace per file.
     #[arg(short, long, default_value = config::DEFAULT_FILE)]
     file: Vec<PathBuf>,
-    /// Force la TUI (par défaut si stdout est un terminal).
+    /// Forces the TUI (the default when stdout is a terminal).
     #[arg(long, conflicts_with = "no_tui")]
     tui: bool,
-    /// Sortie texte même dans un terminal.
+    /// Text output even in a terminal.
     #[arg(long)]
     no_tui: bool,
-    /// Garde chaque VM allumée après la commande, avec un shell root sur la
-    /// console série (TUI : touche c).
+    /// Keeps each VM up after the command, with a root shell on the serial
+    /// console (TUI: key c).
     #[arg(long)]
     hold: bool,
-    /// Nombre de VM lancées en parallèle (défaut : moitié des cœurs, 8 au plus).
+    /// Number of VMs run in parallel (default: half the cores, 8 at most).
     #[arg(short, long)]
     jobs: Option<usize>,
-    /// Ne lance que ces cibles (noms séparés par des virgules).
+    /// Runs only these targets (comma-separated names).
     #[arg(long, value_delimiter = ',')]
     only: Vec<String>,
-    /// Rapport de matrice JSON.
-    #[arg(long, value_name = "FICHIER")]
+    /// JSON matrix report.
+    #[arg(long, value_name = "FILE")]
     json: Option<PathBuf>,
-    /// Rapport JUnit XML, pour la CI.
-    #[arg(long, value_name = "FICHIER")]
+    /// JUnit XML report, for CI.
+    #[arg(long, value_name = "FILE")]
     junit: Option<PathBuf>,
-    /// Résumé Markdown, pour un commentaire de PR.
-    #[arg(long, value_name = "FICHIER")]
+    /// Markdown summary, for a PR comment.
+    #[arg(long, value_name = "FILE")]
     markdown: Option<PathBuf>,
     #[command(flatten)]
     common: Common,
@@ -144,7 +144,7 @@ struct UpArgs {
 
 #[derive(Args, Debug)]
 struct RunArgs {
-    /// Image cible (voir `distroproof images`).
+    /// Target image (see `distroproof images`).
     #[arg(long, short)]
     target: String,
     #[arg(long, default_value = "1G")]
@@ -153,33 +153,33 @@ struct RunArgs {
     cpus: u32,
     #[arg(long, default_value = "10m")]
     timeout: String,
-    /// Utilisateur qui lance la commande : root ou un compte créé à la volée.
+    /// User that runs the command: root or an account created on the fly.
     #[arg(long, default_value = "root")]
     as_user: String,
-    /// Capabilities accordées à l'utilisateur non root (bpf,perfmon…).
+    /// Capabilities granted to the non-root user (bpf,perfmon…).
     #[arg(long, value_delimiter = ',')]
     caps: Vec<String>,
-    /// Sysctl appliqué avant la commande (clé=valeur), répétable.
-    #[arg(long = "sysctl", value_name = "CLÉ=VALEUR")]
+    /// Sysctl applied before the command (key=value), repeatable.
+    #[arg(long = "sysctl", value_name = "KEY=VALUE")]
     sysctl: Vec<String>,
-    /// Arguments ajoutés à la ligne de commande du noyau.
+    /// Arguments appended to the kernel command line.
     #[arg(long)]
     kernel_cmdline: Option<String>,
-    /// Masque la PMU à l'invité.
+    /// Hides the PMU from the guest.
     #[arg(long)]
     no_pmu: bool,
-    /// Répertoire copié dans l'invité (/distroproof/work), où tourne la commande.
+    /// Directory copied into the guest (/distroproof/work), where the command runs.
     #[arg(long)]
     workdir: Option<PathBuf>,
-    /// Lance aussi envprobe avant la commande et joint le rapport au résultat.
+    /// Also runs envprobe before the command and attaches the report to the result.
     #[arg(long)]
     probe: bool,
-    /// Écrit le résultat complet (JSON) dans ce fichier.
+    /// Writes the full result (JSON) to this file.
     #[arg(long)]
     result: Option<PathBuf>,
     #[command(flatten)]
     common: Common,
-    /// Commande à lancer ; `envprobe` est dans le PATH de l'invité.
+    /// Command to run; `envprobe` is in the guest's PATH.
     #[arg(last = true, required = true)]
     command: Vec<String>,
 }
@@ -200,8 +200,8 @@ async fn main() -> ExitCode {
     })
 }
 
-/// Cherche un envprobe statique : option, puis à côté de distroproof, puis
-/// dans la cible musl du workspace.
+/// Looks for a static envprobe: the option, then next to distroproof, then in
+/// the workspace's musl target.
 fn find_envprobe(explicit: Option<&Path>) -> Result<PathBuf, String> {
     let mut candidates = Vec::new();
     if let Some(p) = explicit {
@@ -228,15 +228,12 @@ fn find_envprobe(explicit: Option<&Path>) -> Result<PathBuf, String> {
             return Ok(c.clone());
         }
         if explicit.is_some() {
-            return Err(format!(
-                "{} n'est pas un binaire x86_64 statique",
-                c.display()
-            ));
+            return Err(format!("{} is not a static x86_64 binary", c.display()));
         }
     }
     Err(
-        "envprobe statique introuvable : `cargo build --release --target \
-         x86_64-unknown-linux-musl -p envprobe` ou --envprobe <chemin>"
+        "static envprobe not found: `cargo build --release --target \
+         x86_64-unknown-linux-musl -p envprobe` or --envprobe <path>"
             .into(),
     )
 }
@@ -257,7 +254,7 @@ fn parse_sysctls(items: &[String]) -> Result<BTreeMap<String, String>, String> {
         .map(|s| {
             s.split_once('=')
                 .map(|(k, v)| (k.trim().to_string(), v.trim().to_string()))
-                .ok_or_else(|| format!("--sysctl attend clé=valeur, reçu « {s} »"))
+                .ok_or_else(|| format!("--sysctl expects key=value, got \"{s}\""))
         })
         .collect()
 }
@@ -265,19 +262,19 @@ fn parse_sysctls(items: &[String]) -> Result<BTreeMap<String, String>, String> {
 async fn cmd_run(args: RunArgs) -> Result<ExitCode, String> {
     if images::find(&args.target).is_none() {
         return Err(format!(
-            "image inconnue « {} » (connues : {})",
+            "unknown image \"{}\" (known: {})",
             args.target,
             images::names().join(", ")
         ));
     }
     if !config::valid_user(&args.as_user) {
-        return Err(format!("nom d'utilisateur invalide « {} »", args.as_user));
+        return Err(format!("invalid user name \"{}\"", args.as_user));
     }
     for cap in &args.caps {
         config::check_cap(cap)?;
     }
     if !args.caps.is_empty() && args.as_user == "root" {
-        return Err("--caps ne s'applique qu'avec --as-user <non root>".into());
+        return Err("--caps only applies with --as-user <non-root>".into());
     }
     let command = args
         .command
@@ -322,7 +319,7 @@ async fn cmd_run(args: RunArgs) -> Result<ExitCode, String> {
         r = run => r,
         _ = tokio::signal::ctrl_c() => {
             drop(ctrl_tx);
-            eprintln!("distroproof: interrompu");
+            eprintln!("distroproof: interrupted");
             return Ok(ExitCode::from(130));
         }
     };
@@ -331,8 +328,8 @@ async fn cmd_run(args: RunArgs) -> Result<ExitCode, String> {
     let _ = printer.await;
 
     if let Some(path) = &args.result {
-        let json = serde_json::to_string_pretty(&result).expect("sérialisable");
-        std::fs::write(path, json).map_err(|e| format!("{} : {e}", path.display()))?;
+        let json = serde_json::to_string_pretty(&result).expect("serializable");
+        std::fs::write(path, json).map_err(|e| format!("{}: {e}", path.display()))?;
     }
     if let Some(cmd) = &result.command {
         let _ = io::stdout().write_all(cmd.stdout.as_bytes());
@@ -356,7 +353,7 @@ fn cmd_check(path: &Path) -> Result<ExitCode, String> {
     let mut out = io::stdout().lock();
     let _ = writeln!(
         out,
-        "{} : {} cible(s) valides",
+        "{}: {} valid target(s)",
         path.display(),
         cfg.targets.len()
     );
@@ -366,20 +363,20 @@ fn cmd_check(path: &Path) -> Result<ExitCode, String> {
             variants.push(format!("{k}={v}"));
         }
         if let Some(c) = &t.kernel_cmdline {
-            variants.push(format!("cmdline « {c} »"));
+            variants.push(format!("cmdline \"{c}\""));
         }
         if t.user != "root" {
-            variants.push(format!("utilisateur {}", t.user));
+            variants.push(format!("user {}", t.user));
         }
         if !t.caps.is_empty() {
             variants.push(format!("caps {}", t.caps.join(",")));
         }
         if !t.pmu {
-            variants.push("sans PMU".into());
+            variants.push("no PMU".into());
         }
         let _ = writeln!(
             out,
-            "  {:<20} {:<14} {} Mio, {} CPU, timeout {}{}",
+            "  {:<20} {:<14} {} MiB, {} CPU, timeout {}{}",
             t.name,
             t.image,
             t.memory_mib,
@@ -404,7 +401,7 @@ fn write_reports(m: &report::MatrixReport, args: &UpArgs) -> Result<(), String>
     for (path, format) in outputs {
         if let Some(path) = path {
             std::fs::write(path, render(m, format))
-                .map_err(|e| format!("{} : {e}", path.display()))?;
+                .map_err(|e| format!("{}: {e}", path.display()))?;
         }
     }
     Ok(())
@@ -420,10 +417,10 @@ fn render(m: &report::MatrixReport, format: Format) -> String {
 }
 
 fn cmd_report(path: &Path, format: Format) -> Result<ExitCode, String> {
-    let text = std::fs::read_to_string(path).map_err(|e| format!("{} : {e}", path.display()))?;
+    let text = std::fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
     let saved: report::MatrixReport =
-        serde_json::from_str(&text).map_err(|e| format!("{} : {e}", path.display()))?;
-    // L'analyse est recalculée : elle profite des améliorations de l'heuristique.
+        serde_json::from_str(&text).map_err(|e| format!("{}: {e}", path.display()))?;
+    // The analysis is recomputed: it benefits from heuristic improvements.
     let mut m = report::MatrixReport::build(saved.targets, saved.config);
     m.generated_at = saved.generated_at;
     let out = match format {
@@ -445,7 +442,7 @@ fn default_jobs() -> usize {
 }
 
 async fn cmd_up(args: UpArgs) -> Result<ExitCode, String> {
-    // Toutes les matrices sont validées avant de lancer la moindre VM.
+    // Every matrix is validated before any VM starts.
     let mut specs: Vec<(VmSpec, usize)> = Vec::new();
     let mut groups = Vec::new();
     for (group, path) in args.file.iter().enumerate() {
@@ -453,7 +450,7 @@ async fn cmd_up(args: UpArgs) -> Result<ExitCode, String> {
         for t in cfg.targets {
             if let Some((_, g)) = specs.iter().find(|(s, _)| s.name == t.name) {
                 return Err(format!(
-                    "cible « {} » définie dans {} et {}",
+                    "target \"{}\" defined in both {} and {}",
                     t.name,
                     args.file[*g].display(),
                     path.display()
@@ -477,7 +474,7 @@ async fn cmd_up(args: UpArgs) -> Result<ExitCode, String> {
             .iter()
             .find(|n| !specs.iter().any(|(s, _)| &s.name == *n))
         {
-            return Err(format!("cible inconnue « {bad} » dans --only"));
+            return Err(format!("unknown target \"{bad}\" in --only"));
         }
         specs.retain(|(s, _)| args.only.contains(&s.name));
     }
@@ -500,9 +497,9 @@ async fn cmd_up(args: UpArgs) -> Result<ExitCode, String> {
         );
         let controls = matrix.controls.clone();
         let ui = tui::run(specs, groups, controls, rx).await;
-        // Quitter la TUI arrête les VM encore allumées.
+        // Quitting the TUI stops the VMs still running.
         let results = matrix.shutdown().await;
-        ui.map_err(|e| format!("TUI : {e}"))?;
+        ui.map_err(|e| format!("TUI: {e}"))?;
         return finish_up(results, &args);
     }
 
@@ -524,7 +521,7 @@ async fn cmd_up(args: UpArgs) -> Result<ExitCode, String> {
     let results = tokio::select! {
         r = &mut wait => r,
         _ = tokio::signal::ctrl_c() => {
-            eprintln!("distroproof: interrompu, arrêt des VM");
+            eprintln!("distroproof: interrupted, stopping the VMs");
             for tx in controls.values() {
                 let _ = tx.send(event::Control::Kill);
             }
@@ -565,16 +562,16 @@ async fn cmd_images(action: ImagesAction) -> Result<ExitCode, String> {
                         "{file} ({}{})",
                         fmt_bytes(e.bytes),
                         if e.direct_kernel {
-                            ", noyau extrait"
+                            ", kernel extracted"
                         } else {
                             ""
                         }
                     ),
-                    None => "absente du cache".into(),
+                    None => "not cached".into(),
                 };
                 let _ = writeln!(out, "{:<width$}  {:<45}  {state}", e.name, e.description);
             }
-            let _ = writeln!(out, "\ncache : {}", dirs::images().display());
+            let _ = writeln!(out, "\ncache: {}", dirs::images().display());
             Ok(ExitCode::SUCCESS)
         }
         ImagesAction::Pull { names } => {
@@ -593,7 +590,7 @@ async fn cmd_images(action: ImagesAction) -> Result<ExitCode, String> {
                 tasks.push(tokio::spawn(async move {
                     let r = store.ensure(&name, &ev).await;
                     if let Err(e) = &r {
-                        ev.info(format!("erreur : {e}"));
+                        ev.info(format!("error: {e}"));
                     }
                     r.is_ok()
                 }));
@@ -615,9 +612,9 @@ async fn cmd_images(action: ImagesAction) -> Result<ExitCode, String> {
             let dir = dirs::images();
             let freed: u64 = images::cache_status().iter().map(|e| e.bytes).sum();
             if dir.exists() {
-                std::fs::remove_dir_all(&dir).map_err(|e| format!("{} : {e}", dir.display()))?;
+                std::fs::remove_dir_all(&dir).map_err(|e| format!("{}: {e}", dir.display()))?;
             }
-            println!("{} libérés ({})", fmt_bytes(freed), dir.display());
+            println!("{} freed ({})", fmt_bytes(freed), dir.display());
             Ok(ExitCode::SUCCESS)
         }
     }
diff --git a/crates/distroproof/src/matrix.rs b/crates/distroproof/src/matrix.rs
index 9a6f7b5..0d5b7bb 100644
--- a/crates/distroproof/src/matrix.rs
+++ b/crates/distroproof/src/matrix.rs
@@ -1,4 +1,4 @@
-//! Exécution parallèle bornée d'une matrice de cibles.
+//! Bounded parallel execution of a target matrix.
 
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -10,16 +10,16 @@ use crate::event::{Control, Emitter, EventTx, VmEvent};
 use crate::model::{Outcome, TargetResult, VmSpec};
 use crate::vm::{Runner, Stop};
 
-/// Poignée sur une matrice en cours : contrôle de chaque cible et attente.
+/// Handle on a running matrix: control of each target, and waiting.
 pub struct Matrix {
     pub controls: HashMap<String, mpsc::UnboundedSender<Control>>,
     handles: Vec<JoinHandle<Option<TargetResult>>>,
 }
 
 impl Matrix {
-    /// Lance les cibles, au plus `jobs` à la fois. En mode `interactive`, une
-    /// cible terminée peut être relancée (`Control::Restart`) tant que son
-    /// canal de contrôle reste ouvert.
+    /// Starts the targets, at most `jobs` at a time. In `interactive` mode, a
+    /// finished target can be restarted (`Control::Restart`) as long as its
+    /// control channel stays open.
     pub fn start(
         runner: Runner,
         specs: Vec<VmSpec>,
@@ -47,14 +47,14 @@ impl Matrix {
         Matrix { controls, handles }
     }
 
-    /// Attend la fin de toutes les cibles. Les résultats suivent l'ordre du fichier.
+    /// Waits for every target to finish. Results follow the file order.
     pub async fn wait(self) -> Vec<TargetResult> {
         let _controls = self.controls;
         join(self.handles).await
     }
 
-    /// Ferme les canaux de contrôle : les VM en cours sont tuées et les
-    /// cibles en attente abandonnées.
+    /// Closes the control channels: running VMs are killed and queued targets
+    /// are dropped.
     pub async fn shutdown(self) -> Vec<TargetResult> {
         drop(self.controls);
         join(self.handles).await
@@ -80,7 +80,7 @@ async fn supervise(
     interactive: bool,
 ) -> Option<TargetResult> {
     loop {
-        // Attente d'un slot ; un Kill reçu entre-temps annule la cible.
+        // Wait for a slot; a Kill received meanwhile cancels the target.
         let permit = tokio::select! {
             p = slots.clone().acquire_owned() => p.ok(),
             cmd = ctrl.recv() => match cmd {
@@ -97,7 +97,7 @@ async fn supervise(
             None => {
                 let mut r = TargetResult::new(&spec);
                 r.outcome = Outcome::Killed;
-                r.error = Some("interrompue avant son lancement".into());
+                r.error = Some("interrupted before it started".into());
                 ev.emit(VmEvent::Finished(Box::new(r.clone())));
                 (r, Some(Stop::Kill))
             }
@@ -110,7 +110,7 @@ async fn supervise(
     }
 }
 
-/// Après la fin d'une cible : attend une demande de relance ou la fermeture.
+/// After a target finishes: waits for a restart request or for shutdown.
 async fn wait_restart(ctrl: &mut mpsc::UnboundedReceiver<Control>) -> bool {
     loop {
         match ctrl.recv().await {
diff --git a/crates/distroproof/src/metrics.rs b/crates/distroproof/src/metrics.rs
index 9937e32..7e0f9e6 100644
--- a/crates/distroproof/src/metrics.rs
+++ b/crates/distroproof/src/metrics.rs
@@ -1,28 +1,28 @@
-//! CPU et mémoire d'un processus QEMU, lus dans `/proc/<pid>`.
+//! CPU and memory of a QEMU process, read from `/proc/<pid>`.
 
 use std::fs;
 use std::time::Instant;
 
-/// Temps CPU cumulé (utime + stime) en ticks, champs 14 et 15 de `stat`.
+/// Cumulative CPU time (utime + stime) in ticks, fields 14 and 15 of `stat`.
 pub fn parse_cpu_ticks(stat: &str) -> Option<u64> {
-    // Le nom du processus (champ 2) peut contenir des espaces : on repart
-    // de la dernière parenthèse fermante.
+    // The process name (field 2) can contain spaces: start again from the
+    // last closing parenthesis.
     let rest = &stat[stat.rfind(')')? + 2..];
     let fields: Vec<&str> = rest.split_whitespace().collect();
-    // Après « ) », le champ 3 (state) est à l'index 0 : utime = 14 → index 11.
+    // After ")", field 3 (state) is at index 0: utime = 14 → index 11.
     let utime: u64 = fields.get(11)?.parse().ok()?;
     let stime: u64 = fields.get(12)?.parse().ok()?;
     Some(utime + stime)
 }
 
-/// `VmRSS` de `/proc/<pid>/status`, en octets.
+/// `VmRSS` from `/proc/<pid>/status`, in bytes.
 pub fn parse_rss(status: &str) -> Option<u64> {
     let line = status.lines().find(|l| l.starts_with("VmRSS:"))?;
     let kib: u64 = line.split_whitespace().nth(1)?.parse().ok()?;
     Some(kib * 1024)
 }
 
-/// Échantillonneur : le pourcentage CPU est calculé entre deux appels.
+/// Sampler: the CPU percentage is computed between two calls.
 pub struct Sampler {
     pid: u32,
     ticks_per_sec: u64,
@@ -38,7 +38,7 @@ impl Sampler {
         }
     }
 
-    /// (CPU en % d'un cœur, RSS en octets).
+    /// (CPU as a % of one core, RSS in bytes).
     pub fn sample(&mut self) -> Option<(f64, u64)> {
         let stat = fs::read_to_string(format!("/proc/{}/stat", self.pid)).ok()?;
         let status = fs::read_to_string(format!("/proc/{}/status", self.pid)).ok()?;
diff --git a/crates/distroproof/src/model.rs b/crates/distroproof/src/model.rs
index e542638..917f9e2 100644
--- a/crates/distroproof/src/model.rs
+++ b/crates/distroproof/src/model.rs
@@ -1,4 +1,4 @@
-//! Description d'une exécution et de son résultat.
+//! Description of a run and of its result.
 
 use std::collections::BTreeMap;
 use std::path::PathBuf;
@@ -7,63 +7,63 @@ use std::time::Duration;
 use envprobe_core::Report;
 use serde::{Deserialize, Serialize};
 
-/// Tout ce qu'il faut pour lancer une cible.
+/// Everything needed to run a target.
 #[derive(Debug, Clone)]
 pub struct VmSpec {
-    /// Nom unique dans la matrice.
+    /// Unique name in the matrix.
     pub name: String,
-    /// Image du catalogue (`debian-12`, `rocky-8`…).
+    /// Catalog image (`debian-12`, `rocky-8`…).
     pub image: String,
     pub memory_mib: u64,
     pub cpus: u32,
     pub timeout: Duration,
     pub sysctl: BTreeMap<String, String>,
-    /// Arguments ajoutés à la ligne de commande du noyau (boot direct).
+    /// Arguments appended to the kernel command line (direct boot).
     pub kernel_cmdline: Option<String>,
-    /// Utilisateur qui lance envprobe et la commande : `root` ou un compte créé.
+    /// User that runs envprobe and the command: `root` or a created account.
     pub user: String,
-    /// Capabilities accordées à l'utilisateur non root (`bpf`, `perfmon`…).
+    /// Capabilities granted to the non-root user (`bpf`, `perfmon`…).
     pub caps: Vec<String>,
-    /// PMU exposée à l'invité (`-cpu host`) ou masquée (`pmu=off`).
+    /// PMU exposed to the guest (`-cpu host`) or hidden (`pmu=off`).
     pub pmu: bool,
-    /// Script lancé en root avant la sonde et la commande.
+    /// Script run as root before the probe and the command.
     pub setup: Option<String>,
-    /// Commande shell lancée dans le répertoire de travail de l'invité.
+    /// Shell command run in the guest's working directory.
     pub command: Option<String>,
     pub env: BTreeMap<String, String>,
-    /// Répertoire partagé avec l'invité (copié dans `/distroproof/work`).
+    /// Directory shared with the guest (copied to `/distroproof/work`).
     pub workdir: Option<PathBuf>,
     pub exclude: Vec<String>,
     pub include: Vec<String>,
-    /// Lancer envprobe avant la commande et joindre son rapport.
+    /// Run envprobe before the command and attach its report.
     pub probe: bool,
-    /// Garder la VM allumée après la commande, avec un shell root sur la
-    /// console série, jusqu'à ce qu'on la tue.
+    /// Keep the VM up after the command, with a root shell on the serial
+    /// console, until it is killed.
     pub hold: bool,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
 pub enum Outcome {
-    /// La commande a renvoyé 0.
+    /// The command returned 0.
     Success,
-    /// La commande a renvoyé un code non nul.
+    /// The command returned a non-zero code.
     Failure,
     TimedOut,
-    /// Interrompue depuis la TUI ou par Ctrl+C.
+    /// Interrupted from the TUI or by Ctrl+C.
     Killed,
-    /// Erreur de l'orchestrateur : image, boot, agent injoignable…
+    /// Orchestrator error: image, boot, unreachable agent…
     Error,
 }
 
 impl Outcome {
     pub fn label(self) -> &'static str {
         match self {
-            Outcome::Success => "succès",
-            Outcome::Failure => "échec",
+            Outcome::Success => "success",
+            Outcome::Failure => "failed",
             Outcome::TimedOut => "timeout",
-            Outcome::Killed => "interrompu",
-            Outcome::Error => "erreur",
+            Outcome::Killed => "killed",
+            Outcome::Error => "error",
         }
     }
 
@@ -72,7 +72,7 @@ impl Outcome {
     }
 }
 
-/// Résultat d'une étape de l'agent (setup, commande).
+/// Result of an agent stage (setup, command).
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct StageResult {
     pub exit_code: Option<i32>,
@@ -80,7 +80,7 @@ pub struct StageResult {
     pub stderr: String,
 }
 
-/// Variantes appliquées à la cible, recopiées dans le résultat.
+/// Variants applied to the target, copied into the result.
 #[derive(Debug, Clone, Default, Serialize, Deserialize)]
 pub struct Variant {
     #[serde(skip_serializing_if = "BTreeMap::is_empty", default)]
@@ -97,7 +97,7 @@ pub struct Variant {
 pub struct TargetResult {
     pub name: String,
     pub image: String,
-    /// Fichier de l'image utilisée (version exacte).
+    /// File of the image used (exact version).
     #[serde(default)]
     pub image_file: Option<String>,
     pub outcome: Outcome,
@@ -113,12 +113,12 @@ pub struct TargetResult {
     pub command: Option<StageResult>,
     #[serde(default)]
     pub envprobe: Option<Report>,
-    /// Erreurs de l'agent (sysctl refusé, capability inconnue…).
+    /// Agent errors (sysctl refused, unknown capability…).
     #[serde(default)]
     pub warnings: Vec<String>,
     #[serde(default)]
     pub error: Option<String>,
-    /// Dernières lignes de la console série, utiles quand le boot échoue.
+    /// Last lines of the serial console, useful when the boot fails.
     #[serde(default)]
     pub console_tail: String,
 }
@@ -149,7 +149,7 @@ impl TargetResult {
         }
     }
 
-    /// Release du noyau vue par envprobe dans l'invité.
+    /// Kernel release seen by envprobe in the guest.
     pub fn kernel_release(&self) -> Option<&str> {
         self.envprobe
             .as_ref()?
diff --git a/crates/distroproof/src/progress.rs b/crates/distroproof/src/progress.rs
index 9f862f7..ee08356 100644
--- a/crates/distroproof/src/progress.rs
+++ b/crates/distroproof/src/progress.rs
@@ -1,4 +1,4 @@
-//! Consommateurs non interactifs du bus d'événements : texte et JSON lignes.
+//! Non-interactive consumers of the event bus: text and JSON lines.
 
 use std::collections::HashMap;
 use std::io::{self, Write};
@@ -9,16 +9,16 @@ use crate::model::Outcome;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, clap::ValueEnum)]
 pub enum Progress {
-    /// Lignes lisibles sur stderr.
+    /// Human-readable lines on stderr.
     Text,
-    /// Un événement JSON par ligne sur stderr.
+    /// One JSON event per line on stderr.
     Json,
-    /// Rien.
+    /// Nothing.
     None,
 }
 
 pub fn fmt_bytes(n: u64) -> String {
-    const UNITS: [&str; 5] = ["o", "Kio", "Mio", "Gio", "Tio"];
+    const UNITS: [&str; 5] = ["B", "KiB", "MiB", "GiB", "TiB"];
     let mut v = n as f64;
     let mut unit = 0;
     while v >= 1024.0 && unit < UNITS.len() - 1 {
@@ -26,7 +26,7 @@ pub fn fmt_bytes(n: u64) -> String {
         unit += 1;
     }
     if unit == 0 {
-        format!("{n} o")
+        format!("{n} B")
     } else {
         format!("{v:.1} {}", UNITS[unit])
     }
@@ -40,7 +40,7 @@ pub fn fmt_ms(ms: u64) -> String {
     }
 }
 
-/// Lit le flux jusqu'à sa fermeture et l'affiche sur stderr.
+/// Reads the stream until it closes and prints it on stderr.
 pub async fn consume(mut rx: EventRx, mode: Progress, verbose: bool) {
     let mut last_download: HashMap<String, (Instant, u64)> = HashMap::new();
     while let Some(event) = rx.recv().await {
@@ -50,7 +50,7 @@ pub async fn consume(mut rx: EventRx, mode: Progress, verbose: bool) {
             Progress::Text => text_line(&event, verbose, &mut last_download),
         };
         if res.is_err() {
-            // stderr fermé : on continue de vider le flux sans rien écrire.
+            // stderr closed: keep draining the stream without writing anything.
             continue;
         }
     }
@@ -74,7 +74,7 @@ fn text_line(
         VmEvent::Queued | VmEvent::Console(_) | VmEvent::Metrics(_) | VmEvent::Stopped => {
             return Ok(())
         }
-        VmEvent::Holding => "VM gardée : shell root sur la console série".into(),
+        VmEvent::Holding => "VM kept up: root shell on the serial console".into(),
         VmEvent::Info { message } => message.clone(),
         VmEvent::Downloading { done, total } => {
             let now = Instant::now();
@@ -88,33 +88,33 @@ fn text_line(
             *entry = (now, *done);
             match total {
                 Some(total) if *total > 0 => format!(
-                    "téléchargement {:>3} % ({} / {})",
+                    "downloading {:>3}% ({} / {})",
                     done * 100 / total,
                     fmt_bytes(*done),
                     fmt_bytes(*total)
                 ),
-                _ => format!("téléchargement {}", fmt_bytes(*done)),
+                _ => format!("downloading {}", fmt_bytes(*done)),
             }
         }
-        VmEvent::Verifying => "vérification du checksum".into(),
+        VmEvent::Verifying => "verifying checksum".into(),
         VmEvent::ImageReady { file, cached } => {
             format!("image {file}{}", if *cached { " (cache)" } else { "" })
         }
-        VmEvent::Preparing => "boot de préparation : extraction du noyau".into(),
+        VmEvent::Preparing => "preparation boot: extracting the kernel".into(),
         VmEvent::Booting {
             pid, direct_kernel, ..
         } => format!(
-            "démarrage de la VM (pid {pid}, {})",
+            "starting the VM (pid {pid}, {})",
             if *direct_kernel {
-                "boot direct sur le noyau de la distro"
+                "direct boot on the distro kernel"
             } else {
-                "boot sur le disque"
+                "booting from disk"
             }
         ),
-        VmEvent::Booted { boot_ms } => format!("agent prêt, boot en {}", fmt_ms(*boot_ms)),
-        VmEvent::Stage { stage } => format!("étape {}", stage.label()),
+        VmEvent::Booted { boot_ms } => format!("agent ready, booted in {}", fmt_ms(*boot_ms)),
+        VmEvent::Stage { stage } => format!("stage {}", stage.label()),
         VmEvent::StageExited { stage, code } => {
-            format!("{} terminé (code {code})", stage.label())
+            format!("{} finished (code {code})", stage.label())
         }
         VmEvent::Output { stream, line } => {
             if !verbose {
@@ -123,8 +123,8 @@ fn text_line(
             let sep = if *stream == Stream::Stderr { "!" } else { "|" };
             format!("{sep} {line}")
         }
-        VmEvent::Paused => "en pause".into(),
-        VmEvent::Resumed => "reprise".into(),
+        VmEvent::Paused => "paused".into(),
+        VmEvent::Resumed => "resumed".into(),
         VmEvent::Finished(r) => {
             let boot = r
                 .boot_ms
@@ -132,23 +132,23 @@ fn text_line(
                 .unwrap_or_default();
             let kernel = r
                 .kernel_release()
-                .map(|k| format!(", noyau {k}"))
+                .map(|k| format!(", kernel {k}"))
                 .unwrap_or_default();
             let detail = match r.outcome {
                 Outcome::Failure => r
                     .exit_code()
                     .map(|c| format!(" (code {c})"))
-                    .or_else(|| r.error.as_ref().map(|e| format!(" : {e}")))
+                    .or_else(|| r.error.as_ref().map(|e| format!(": {e}")))
                     .unwrap_or_default(),
                 Outcome::Error | Outcome::TimedOut | Outcome::Killed => r
                     .error
                     .as_ref()
-                    .map(|e| format!(" : {e}"))
+                    .map(|e| format!(": {e}"))
                     .unwrap_or_default(),
                 Outcome::Success => String::new(),
             };
             format!(
-                "{}{detail} en {}{boot}{kernel}",
+                "{}{detail} in {}{boot}{kernel}",
                 r.outcome.label(),
                 fmt_ms(r.duration_ms)
             )
diff --git a/crates/distroproof/src/qemu.rs b/crates/distroproof/src/qemu.rs
index cc04246..e8cc104 100644
--- a/crates/distroproof/src/qemu.rs
+++ b/crates/distroproof/src/qemu.rs
@@ -1,4 +1,4 @@
-//! QEMU piloté en sous-processus, et son socket QMP.
+//! QEMU driven as a subprocess, and its QMP socket.
 
 use std::env;
 use std::ffi::OsString;
@@ -11,7 +11,7 @@ use tokio::net::unix::{OwnedReadHalf, OwnedWriteHalf};
 use tokio::net::UnixStream;
 use tokio::process::Command;
 
-/// Binaire QEMU : `$DISTROPROOF_QEMU` ou `qemu-system-x86_64` dans le PATH.
+/// QEMU binary: `$DISTROPROOF_QEMU` or `qemu-system-x86_64` from PATH.
 pub fn qemu_binary() -> OsString {
     env::var_os("DISTROPROOF_QEMU").unwrap_or_else(|| "qemu-system-x86_64".into())
 }
@@ -20,7 +20,7 @@ pub fn qemu_img_binary() -> OsString {
     env::var_os("DISTROPROOF_QEMU_IMG").unwrap_or_else(|| "qemu-img".into())
 }
 
-/// KVM utilisable par l'utilisateur courant ?
+/// Is KVM usable by the current user?
 pub fn kvm_available() -> bool {
     std::fs::OpenOptions::new()
         .read(true)
@@ -29,14 +29,14 @@ pub fn kvm_available() -> bool {
         .is_ok()
 }
 
-/// Firmware UEFI (OVMF) : code en lecture seule et modèle de variables.
+/// UEFI firmware (OVMF): read-only code and variables template.
 pub struct Ovmf {
     pub code: PathBuf,
     pub vars: PathBuf,
 }
 
-/// Cherche OVMF : `$DISTROPROOF_OVMF_CODE` et `$DISTROPROOF_OVMF_VARS`, puis
-/// les emplacements des paquets Arch, Debian/Ubuntu, Fedora et de QEMU.
+/// Looks for OVMF: `$DISTROPROOF_OVMF_CODE` and `$DISTROPROOF_OVMF_VARS`, then
+/// the locations used by the Arch, Debian/Ubuntu, Fedora and QEMU packages.
 pub fn find_ovmf() -> Option<Ovmf> {
     if let (Some(code), Some(vars)) = (
         env::var_os("DISTROPROOF_OVMF_CODE"),
@@ -78,7 +78,7 @@ pub fn find_ovmf() -> Option<Ovmf> {
     })
 }
 
-/// Overlay qcow2 jetable au-dessus de l'image de base, qui reste intacte.
+/// Throwaway qcow2 overlay on top of the base image, which stays untouched.
 pub async fn create_overlay(base: &Path, overlay: &Path) -> Result<(), String> {
     let out = Command::new(qemu_img_binary())
         .args(["create", "-q", "-f", "qcow2", "-F", "qcow2", "-b"])
@@ -86,17 +86,17 @@ pub async fn create_overlay(base: &Path, overlay: &Path) -> Result<(), String> {
         .arg(overlay)
         .output()
         .await
-        .map_err(|e| format!("qemu-img introuvable : {e}"))?;
+        .map_err(|e| format!("qemu-img not found: {e}"))?;
     if !out.status.success() {
         return Err(format!(
-            "qemu-img create : {}",
+            "qemu-img create: {}",
             String::from_utf8_lossy(&out.stderr).trim()
         ));
     }
     Ok(())
 }
 
-/// Démarrage direct sur un noyau extrait de l'image.
+/// Direct boot on a kernel extracted from the image.
 pub struct KernelBoot<'a> {
     pub kernel: &'a Path,
     pub initrd: Option<&'a Path>,
@@ -116,13 +116,13 @@ pub struct Machine<'a> {
     pub console: &'a Path,
     pub agent: &'a Path,
     pub kernel: Option<KernelBoot<'a>>,
-    /// Boot UEFI : code OVMF et copie des variables propre à cette VM.
+    /// UEFI boot: OVMF code and this VM's own copy of the variables.
     pub uefi: Option<(&'a Path, &'a Path)>,
 }
 
 impl Machine<'_> {
-    /// Ligne de commande QEMU. La VM démarre en pause (`-S`) : l'hôte se
-    /// connecte à tous les sockets avant de la lancer, rien n'est perdu.
+    /// QEMU command line. The VM starts paused (`-S`): the host connects to
+    /// every socket before starting it, so nothing is lost.
     pub fn command(&self) -> Command {
         let mut cmd = Command::new(qemu_binary());
         let kvm = kvm_available();
@@ -174,7 +174,7 @@ impl Machine<'_> {
                 drive.push(",readonly=on");
             }
             cmd.arg("-drive").arg(drive);
-            // Avec -kernel, QEMU réserve lui-même le premier index de boot.
+            // With -kernel, QEMU reserves the first boot index itself.
             let boot = if i == 0 && self.kernel.is_none() {
                 ",bootindex=0"
             } else {
@@ -198,7 +198,7 @@ impl Machine<'_> {
     }
 }
 
-/// Les options QEMU séparées par des virgules : une virgule se double.
+/// Comma-separated QEMU options: a literal comma is doubled.
 fn escape_opt(path: &Path) -> OsString {
     path.to_string_lossy().replace(',', ",,").into()
 }
@@ -217,21 +217,21 @@ fn socket_chardev(id: &str, path: &Path) -> OsString {
     s
 }
 
-/// Connexion à un socket unix créé par QEMU, en attendant qu'il apparaisse.
+/// Connects to a unix socket created by QEMU, waiting for it to appear.
 pub async fn connect(path: &Path, wait: Duration) -> Result<UnixStream, String> {
     let deadline = tokio::time::Instant::now() + wait;
     loop {
         match UnixStream::connect(path).await {
             Ok(s) => return Ok(s),
             Err(e) if tokio::time::Instant::now() >= deadline => {
-                return Err(format!("{} : {e}", path.display()))
+                return Err(format!("{}: {e}", path.display()))
             }
             Err(_) => tokio::time::sleep(Duration::from_millis(50)).await,
         }
     }
 }
 
-/// Client QMP minimal : une commande à la fois, événements ignorés.
+/// Minimal QMP client: one command at a time, events ignored.
 pub struct Qmp {
     reader: BufReader<OwnedReadHalf>,
     writer: OwnedWriteHalf,
@@ -245,7 +245,7 @@ impl Qmp {
             reader: BufReader::new(r),
             writer: w,
         };
-        // Message d'accueil puis négociation des capacités.
+        // Greeting, then capabilities negotiation.
         qmp.read_message().await?;
         qmp.execute("qmp_capabilities", None).await?;
         Ok(qmp)
@@ -259,11 +259,11 @@ impl Qmp {
                 .reader
                 .read_line(&mut line)
                 .await
-                .map_err(|e| format!("QMP : {e}"))?;
+                .map_err(|e| format!("QMP: {e}"))?;
             if n == 0 {
-                return Err("QMP : connexion fermée".into());
+                return Err("QMP: connection closed".into());
             }
-            let msg: Json = serde_json::from_str(&line).map_err(|e| format!("QMP : {e}"))?;
+            let msg: Json = serde_json::from_str(&line).map_err(|e| format!("QMP: {e}"))?;
             if msg.get("event").is_none() {
                 return Ok(msg);
             }
@@ -280,20 +280,20 @@ impl Qmp {
         self.writer
             .write_all(text.as_bytes())
             .await
-            .map_err(|e| format!("QMP : {e}"))?;
+            .map_err(|e| format!("QMP: {e}"))?;
         let reply = tokio::time::timeout(Duration::from_secs(10), self.read_message())
             .await
-            .map_err(|_| format!("QMP : pas de réponse à {command}"))??;
+            .map_err(|_| format!("QMP: no reply to {command}"))??;
         if let Some(err) = reply.get("error") {
             return Err(format!(
-                "QMP {command} : {}",
-                err.get("desc").and_then(Json::as_str).unwrap_or("erreur")
+                "QMP {command}: {}",
+                err.get("desc").and_then(Json::as_str).unwrap_or("error")
             ));
         }
         Ok(reply.get("return").cloned().unwrap_or(Json::Null))
     }
 
-    /// Octets lus et écrits sur l'ensemble des disques.
+    /// Bytes read and written across all disks.
     pub async fn block_stats(&mut self) -> Option<(u64, u64)> {
         let ret = self.execute("query-blockstats", None).await.ok()?;
         let mut rd = 0;
@@ -312,7 +312,7 @@ impl Qmp {
     }
 }
 
-/// Répertoire d'une exécution, supprimé quoi qu'il arrive.
+/// Directory of one run, removed no matter what.
 pub struct RunDir {
     pub dir: PathBuf,
     pub sockets: PathBuf,
@@ -333,7 +333,7 @@ impl RunDir {
         let dir = crate::dirs::runs().join(&id);
         let sockets = crate::dirs::sockets().join(&id);
         for d in [&dir, &sockets] {
-            std::fs::create_dir_all(d).map_err(|e| format!("{} : {e}", d.display()))?;
+            std::fs::create_dir_all(d).map_err(|e| format!("{}: {e}", d.display()))?;
         }
         std::fs::write(dir.join("pid"), std::process::id().to_string())
             .map_err(|e| e.to_string())?;
@@ -371,7 +371,7 @@ fn unique() -> u64 {
     (nanos << 8) ^ NEXT.fetch_add(1, Ordering::Relaxed)
 }
 
-/// Supprime les répertoires laissés par un distroproof tué (SIGKILL).
+/// Removes the directories left behind by a killed distroproof (SIGKILL).
 pub fn clean_stale_runs() {
     for base in [crate::dirs::runs(), crate::dirs::sockets()] {
         let Ok(entries) = std::fs::read_dir(&base) else {
@@ -380,7 +380,7 @@ pub fn clean_stale_runs() {
         for entry in entries.flatten() {
             let name = entry.file_name();
             let name = name.to_string_lossy();
-            // <nom>-<pid>-<unique>
+            // <name>-<pid>-<unique>
             let pid = name.rsplit('-').nth(1).and_then(|p| p.parse::<u32>().ok());
             if let Some(pid) = pid {
                 if !crate::sys::pid_alive(pid) {
diff --git a/crates/distroproof/src/report.rs b/crates/distroproof/src/report.rs
index 21130cc..56f87cd 100644
--- a/crates/distroproof/src/report.rs
+++ b/crates/distroproof/src/report.rs
@@ -1,5 +1,5 @@
-//! Rapport de matrice : tableau des résultats, corrélation des échecs avec les
-//! différences d'environnement, et rendus terminal, JSON, JUnit et Markdown.
+//! Matrix report: results table, correlation of failures with environment
+//! differences, and terminal, JSON, JUnit and Markdown renderings.
 
 use std::fmt::Write as _;
 
@@ -10,7 +10,8 @@ use serde::{Deserialize, Serialize};
 use crate::model::{Outcome, TargetResult};
 use crate::progress::fmt_ms;
 
-/// Entrées qui changent d'une VM à l'autre sans rien dire de l'environnement.
+/// Entries that change from one VM to the next without saying anything about
+/// the environment.
 const NOISE: &[(&str, &str)] = &[
     ("kernel", "cmdline"),
     ("kernel", "version"),
@@ -27,7 +28,7 @@ fn is_noise(section: &str, key: &str) -> bool {
     NOISE.iter().any(|(s, k)| *s == section && *k == key)
 }
 
-/// Poids d'une différence : à quel point elle explique, a priori, un échec.
+/// Weight of a difference: how likely it is, a priori, to explain a failure.
 fn weight(section: &str, key: &str) -> u32 {
     match (section, key) {
         ("btf", "vmlinux") => 10,
@@ -63,9 +64,9 @@ fn weight(section: &str, key: &str) -> u32 {
     }
 }
 
-/// Mots-clés de stderr, les entrées du rapport qu'ils désignent (`section` ou
-/// `section.clé`, préfixe accepté) et le bonus accordé : un mot précis
-/// (« btf ») pèse plus qu'un mot générique (« bpf », contenu dans « libbpf »).
+/// stderr keywords, the report entries they point to (`section` or
+/// `section.key`, prefixes accepted) and the bonus they give: a precise word
+/// ("btf") weighs more than a generic one ("bpf", found in "libbpf").
 const KEYWORDS: &[(&[&str], &[&str], u32)] = &[
     (
         &["btf", "vmlinux"],
@@ -143,8 +144,8 @@ const KEYWORDS: &[(&[&str], &[&str], u32)] = &[
     ),
 ];
 
-/// Bonus le plus fort parmi les mots-clés présents dans la sortie qui
-/// désignent cette entrée.
+/// Highest bonus among the keywords present in the output that point to this
+/// entry.
 fn keyword_hits(text: &str, section: &str, key: &str) -> Option<(&'static str, u32)> {
     let full = format!("{section}.{key}");
     KEYWORDS
@@ -163,19 +164,19 @@ fn keyword_hits(text: &str, section: &str, key: &str) -> Option<(&'static str, u
         .max_by_key(|(_, boost)| *boost)
 }
 
-/// Suspects affichés au plus, et par section : une section entière qui
-/// disparaît (tous les helpers BPF) ne masque pas les autres pistes.
+/// Maximum number of suspects shown, overall and per section: a whole section
+/// disappearing (every BPF helper) does not hide the other leads.
 const MAX_SUSPECTS: usize = 8;
 const MAX_PER_SECTION: usize = 2;
 
-/// Différence d'environnement suspectée d'expliquer un échec.
+/// Environment difference suspected of explaining a failure.
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Suspect {
     pub section: String,
     pub key: String,
-    /// Valeur sur la cible en échec.
+    /// Value on the failed target.
     pub failed: String,
-    /// Valeur sur la cible de référence, si elle existe.
+    /// Value on the reference target, if it exists.
     pub reference: Option<String>,
     pub score: u32,
     pub reasons: Vec<String>,
@@ -196,17 +197,17 @@ impl Suspect {
         } else {
             format!(" [{}]", self.reasons.join(", "))
         };
-        format!("{} : {change}{reasons}", self.id())
+        format!("{}: {change}{reasons}", self.id())
     }
 }
 
-/// Analyse d'une cible en échec.
+/// Analysis of a failed target.
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Analysis {
     pub target: String,
-    /// Cible réussie la plus proche, servant de référence au diff.
+    /// Closest successful target, used as the diff reference.
     pub reference: Option<String>,
-    /// Nombre de différences significatives avec la référence.
+    /// Number of significant differences with the reference.
     pub differences: usize,
     pub suspects: Vec<Suspect>,
     #[serde(default)]
@@ -223,7 +224,7 @@ pub struct MatrixReport {
     pub analysis: Vec<Analysis>,
 }
 
-/// Différences significatives (hors bruit) entre deux rapports.
+/// Significant differences (noise excluded) between two reports.
 fn significant(a: &Report, b: &Report) -> Vec<(String, Change)> {
     let mut out = Vec::new();
     for d in diff::diff(a, b) {
@@ -247,7 +248,7 @@ fn show(v: &Value) -> String {
     }
 }
 
-/// Relie l'échec de `failed` aux différences avec la cible réussie la plus proche.
+/// Ties the failure of `failed` to its differences with the closest successful target.
 pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
     let mut analysis = Analysis {
         target: failed.name.clone(),
@@ -257,7 +258,7 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
         note: None,
     };
     let Some(report) = &failed.envprobe else {
-        analysis.note = Some("pas de rapport envprobe pour cette cible".into());
+        analysis.note = Some("no envprobe report for this target".into());
         return analysis;
     };
     let text = format!(
@@ -268,7 +269,7 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
     )
     .to_lowercase();
 
-    // Référence : la réussite la plus proche, à image égale de préférence.
+    // Reference: the closest success, preferably with the same image.
     let reference = all
         .iter()
         .filter(|r| r.outcome.is_success() && r.name != failed.name)
@@ -283,9 +284,10 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
                 let (failed_value, ref_value) = match &change {
                     Change::Changed { a, b, .. } => (b.clone(), Some(a.clone())),
                     Change::Added { value, .. } => (value.clone(), None),
-                    Change::Removed { value, .. } => {
-                        (Value::unavailable("absent du rapport"), Some(value.clone()))
-                    }
+                    Change::Removed { value, .. } => (
+                        Value::unavailable("missing from the report"),
+                        Some(value.clone()),
+                    ),
                 };
                 let key = change.key().to_string();
                 let mut score = weight(&section, &key);
@@ -294,11 +296,11 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
                     && matches!(ref_value, Some(Value::Ok(_)));
                 if lost {
                     score += 3;
-                    reasons.push("indisponible ici, présent sur la référence".to_string());
+                    reasons.push("unavailable here, present on the reference".to_string());
                 }
                 if let Some((word, boost)) = keyword_hits(&text, &section, &key) {
                     score += boost;
-                    reasons.push(format!("« {word} » dans la sortie"));
+                    reasons.push(format!("\"{word}\" in the output"));
                 }
                 analysis.suspects.push(Suspect {
                     section,
@@ -311,9 +313,9 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
             }
         }
         None => {
-            analysis.note = Some("aucune cible réussie pour comparer".into());
-            // Sans référence : les entrées absentes ou refusées que la
-            // sortie du programme désigne.
+            analysis.note = Some("no successful target to compare with".into());
+            // Without a reference: the missing or denied entries that the
+            // program's output points to.
             for section in &report.sections {
                 for entry in &section.entries {
                     if matches!(entry.value, Value::Ok(_)) || is_noise(&section.name, &entry.key) {
@@ -326,7 +328,7 @@ pub fn analyze(failed: &TargetResult, all: &[TargetResult]) -> Analysis {
                             failed: show(&entry.value),
                             reference: None,
                             score: weight(&section.name, &entry.key) + boost,
-                            reasons: vec![format!("« {word} » dans la sortie")],
+                            reasons: vec![format!("\"{word}\" in the output")],
                         });
                     }
                 }
@@ -380,10 +382,10 @@ impl MatrixReport {
     }
 
     pub fn to_json(&self) -> String {
-        serde_json::to_string_pretty(self).expect("rapport sérialisable")
+        serde_json::to_string_pretty(self).expect("serializable report")
     }
 
-    /// Tableau pour le terminal, avec couleurs ANSI si `color`.
+    /// Table for the terminal, with ANSI colors if `color`.
     pub fn to_text(&self, color: bool) -> String {
         let paint = |code: &str, s: &str| {
             if color {
@@ -406,7 +408,7 @@ impl MatrixReport {
                 ]
             })
             .collect();
-        let header = ["cible", "image", "noyau", "résultat", "boot", "durée"];
+        let header = ["target", "image", "kernel", "result", "boot", "duration"];
         let mut widths = header.map(|h| h.chars().count());
         for row in &rows {
             for (w, cell) in widths.iter_mut().zip(row) {
@@ -435,7 +437,7 @@ impl MatrixReport {
             line(row, &mut out, Some(t.outcome));
         }
         let (ok, total) = self.counts();
-        let _ = writeln!(out, "\n{ok}/{total} cibles réussies");
+        let _ = writeln!(out, "\n{ok}/{total} targets passed");
 
         for t in self.targets.iter().filter(|t| !t.outcome.is_success()) {
             let _ = writeln!(
@@ -444,14 +446,14 @@ impl MatrixReport {
                 paint("1", &format!("[{}] {}", t.name, outcome_cell(t)))
             );
             if let Some(e) = &t.error {
-                let _ = writeln!(out, "  erreur : {e}");
+                let _ = writeln!(out, "  error: {e}");
             }
             if let Some(a) = self.analysis_for(&t.name) {
                 write_analysis_text(&mut out, a);
             }
             let excerpt = stderr_excerpt(t, 8);
             if !excerpt.is_empty() {
-                let _ = writeln!(out, "  stderr :");
+                let _ = writeln!(out, "  stderr:");
                 for l in excerpt.lines() {
                     let _ = writeln!(out, "    {l}");
                 }
@@ -464,11 +466,8 @@ impl MatrixReport {
         let (ok, total) = self.counts();
         let mut md = String::new();
         let status = if ok == total { "✅" } else { "❌" };
-        let _ = writeln!(
-            md,
-            "## {status} distroproof : {ok}/{total} cibles réussies\n"
-        );
-        let _ = writeln!(md, "| Cible | Image | Noyau | Résultat | Boot | Durée |");
+        let _ = writeln!(md, "## {status} distroproof: {ok}/{total} targets passed\n");
+        let _ = writeln!(md, "| Target | Image | Kernel | Result | Boot | Duration |");
         let _ = writeln!(md, "| --- | --- | --- | --- | --- | --- |");
         for t in &self.targets {
             let icon = match t.outcome {
@@ -493,23 +492,23 @@ impl MatrixReport {
             let analysis = self.analysis_for(&t.name);
             let cause = analysis
                 .and_then(|a| a.suspects.first())
-                .map(|s| format!(" — cause probable : `{}`", s.id()))
+                .map(|s| format!(" — probable cause: `{}`", s.id()))
                 .unwrap_or_default();
             let _ = writeln!(
                 md,
-                "\n<details><summary><b>{}</b> : {}{cause}</summary>\n",
+                "\n<details><summary><b>{}</b>: {}{cause}</summary>\n",
                 t.name,
                 outcome_cell(t)
             );
             if let Some(e) = &t.error {
-                let _ = writeln!(md, "Erreur : {}\n", md_escape(e));
+                let _ = writeln!(md, "Error: {}\n", md_escape(e));
             }
             if let Some(a) = analysis {
                 match &a.reference {
                     Some(r) => {
                         let _ = writeln!(
                             md,
-                            "Comparée à `{r}` ({} différences significatives) :\n",
+                            "Compared with `{r}` ({} significant differences):\n",
                             a.differences
                         );
                     }
@@ -572,17 +571,17 @@ impl MatrixReport {
             let mut body = String::new();
             if let Some(a) = self.analysis_for(&t.name) {
                 if let Some(r) = &a.reference {
-                    let _ = writeln!(body, "comparée à {r} ({} différences)", a.differences);
+                    let _ = writeln!(body, "compared with {r} ({} differences)", a.differences);
                 }
                 for s in &a.suspects {
-                    let _ = writeln!(body, "suspect : {}", s.describe());
+                    let _ = writeln!(body, "suspect: {}", s.describe());
                 }
             }
             if let Some(e) = &t.error {
-                let _ = writeln!(body, "erreur : {e}");
+                let _ = writeln!(body, "error: {e}");
             }
             let message = match self.analysis_for(&t.name).and_then(|a| a.suspects.first()) {
-                Some(s) => format!("{} ; cause probable : {}", outcome_cell(t), s.id()),
+                Some(s) => format!("{}; probable cause: {}", outcome_cell(t), s.id()),
                 None => outcome_cell(t),
             };
             match t.outcome {
@@ -634,7 +633,7 @@ fn write_analysis_text(out: &mut String, a: &Analysis) {
         Some(r) => {
             let _ = writeln!(
                 out,
-                "  comparée à {r} : {} différences significatives",
+                "  compared with {r}: {} significant differences",
                 a.differences
             );
         }
@@ -645,19 +644,19 @@ fn write_analysis_text(out: &mut String, a: &Analysis) {
         }
     }
     for (i, s) in a.suspects.iter().take(5).enumerate() {
-        let label = if i == 0 { "cause probable" } else { "aussi" };
-        let _ = writeln!(out, "  {label} : {}", s.describe());
+        let label = if i == 0 { "probable cause" } else { "also" };
+        let _ = writeln!(out, "  {label}: {}", s.describe());
     }
 }
 
 pub fn outcome_cell(t: &TargetResult) -> String {
     match (t.outcome, t.exit_code()) {
-        (Outcome::Failure, Some(c)) if c != 0 => format!("échec (code {c})"),
+        (Outcome::Failure, Some(c)) if c != 0 => format!("failed (code {c})"),
         (o, _) => o.label().to_string(),
     }
 }
 
-/// Fin de stderr de la commande, ou à défaut l'erreur et la console.
+/// Tail of the command's stderr, or failing that the error and the console.
 pub fn stderr_excerpt(t: &TargetResult, lines: usize) -> String {
     let source = match &t.command {
         Some(c) if !c.stderr.trim().is_empty() => c.stderr.as_str(),
@@ -696,7 +695,7 @@ fn xml(s: &str) -> String {
     out
 }
 
-/// Date UTC au format RFC 3339, sans dépendance.
+/// UTC date in RFC 3339 format, without a dependency.
 pub fn now_rfc3339() -> String {
     let secs = std::time::SystemTime::now()
         .duration_since(std::time::UNIX_EPOCH)
@@ -707,7 +706,7 @@ pub fn now_rfc3339() -> String {
 fn rfc3339(secs: i64) -> String {
     let days = secs.div_euclid(86_400);
     let rem = secs.rem_euclid(86_400);
-    // Algorithme « civil from days » de Howard Hinnant.
+    // Howard Hinnant's "civil from days" algorithm.
     let z = days + 719_468;
     let era = z.div_euclid(146_097);
     let doe = z.rem_euclid(146_097);
@@ -795,14 +794,14 @@ mod tests {
             "ubuntu-22.04",
             "ubuntu-22.04",
             Outcome::Success,
-            report(Value::ok("présent, 5 Mio"), "5.15.0", "4"),
+            report(Value::ok("present, 5 MiB"), "5.15.0", "4"),
             "",
         );
         let other = result(
             "debian-12",
             "debian-12",
             Outcome::Success,
-            report(Value::ok("présent, 6 Mio"), "6.1.0", "3"),
+            report(Value::ok("present, 6 MiB"), "6.1.0", "3"),
             "",
         );
         let ko = result(
@@ -810,29 +809,29 @@ mod tests {
             "ubuntu-18.04",
             Outcome::Failure,
             report(
-                Value::unavailable("/sys/kernel/btf/vmlinux absent"),
+                Value::unavailable("/sys/kernel/btf/vmlinux missing"),
                 "4.15.0",
                 "4",
             ),
-            "erreur : BTF du noyau introuvable\n",
+            "error: kernel BTF not found\n",
         );
         let all = vec![ok, other, ko];
         let m = MatrixReport::build(all, None);
         let a = m.analysis_for("ubuntu-18.04").unwrap();
-        // ubuntu-22.04 est plus proche (même paranoid) que debian-12.
+        // ubuntu-22.04 is closer (same paranoid) than debian-12.
         assert_eq!(a.reference.as_deref(), Some("ubuntu-22.04"));
-        // kernel.cmdline est du bruit : seuls release et vmlinux comptent.
+        // kernel.cmdline is noise: only release and vmlinux count.
         assert_eq!(a.differences, 2);
         assert_eq!(a.suspects[0].id(), "btf.vmlinux");
         assert!(a.suspects[0].reasons.iter().any(|r| r.contains("btf")));
         let text = m.to_text(false);
-        assert!(text.contains("cause probable : btf.vmlinux"), "{text}");
+        assert!(text.contains("probable cause: btf.vmlinux"), "{text}");
         let md = m.to_markdown();
-        assert!(md.contains("cause probable : `btf.vmlinux`"), "{md}");
-        assert!(md.contains("2/3 cibles réussies"));
+        assert!(md.contains("probable cause: `btf.vmlinux`"), "{md}");
+        assert!(md.contains("2/3 targets passed"));
         let junit = m.to_junit();
         assert!(junit.contains("failures=\"1\""));
-        assert!(junit.contains("cause probable : btf.vmlinux"));
+        assert!(junit.contains("probable cause: btf.vmlinux"));
         assert!(!m.all_succeeded());
         let back: MatrixReport = serde_json::from_str(&m.to_json()).unwrap();
         assert_eq!(back.targets.len(), 3);
@@ -844,7 +843,7 @@ mod tests {
             "alone",
             "ubuntu-18.04",
             Outcome::Failure,
-            report(Value::unavailable("absent"), "4.15.0", "4"),
+            report(Value::unavailable("missing"), "4.15.0", "4"),
             "libbpf: failed to find valid kernel BTF\n",
         );
         let a = analyze(&ko, std::slice::from_ref(&ko));
diff --git a/crates/distroproof/src/sys.rs b/crates/distroproof/src/sys.rs
index df751a9..538f5f5 100644
--- a/crates/distroproof/src/sys.rs
+++ b/crates/distroproof/src/sys.rs
@@ -1,14 +1,14 @@
-//! Appels système bruts. Seul module autorisé à contenir du code `unsafe`.
+//! Raw system calls. The only module allowed to contain `unsafe` code.
 
-/// UID réel du processus.
+/// Real UID of the process.
 pub fn uid() -> u32 {
-    // SAFETY: getuid n'a ni argument ni cas d'erreur.
+    // SAFETY: getuid takes no argument and cannot fail.
     unsafe { libc::getuid() }
 }
 
-/// Ticks d'horloge par seconde, unité des temps CPU de `/proc/<pid>/stat`.
+/// Clock ticks per second, the unit of CPU times in `/proc/<pid>/stat`.
 pub fn clock_ticks() -> u64 {
-    // SAFETY: sysconf ne lit que la constante demandée.
+    // SAFETY: sysconf only reads the requested constant.
     let ticks = unsafe { libc::sysconf(libc::_SC_CLK_TCK) };
     if ticks > 0 {
         ticks as u64
@@ -17,21 +17,21 @@ pub fn clock_ticks() -> u64 {
     }
 }
 
-/// Le processus existe-t-il encore ? (signal 0 : vérification sans envoi)
+/// Does the process still exist? (signal 0: check without sending anything)
 pub fn pid_alive(pid: u32) -> bool {
     let Ok(pid) = libc::pid_t::try_from(pid) else {
         return false;
     };
-    // SAFETY: kill avec le signal 0 n'a aucun effet sur la cible.
+    // SAFETY: kill with signal 0 has no effect on the target.
     let ret = unsafe { libc::kill(pid, 0) };
     ret == 0 || std::io::Error::last_os_error().raw_os_error() == Some(libc::EPERM)
 }
 
-/// Verrou exclusif (flock) tenu tant que le fichier reste ouvert. Bloquant.
+/// Exclusive lock (flock) held as long as the file stays open. Blocking.
 pub fn lock_exclusive(file: &std::fs::File) -> std::io::Result<()> {
     use std::os::fd::AsRawFd;
     loop {
-        // SAFETY: le descripteur est valide pendant toute la durée de l'appel.
+        // SAFETY: the descriptor is valid for the whole duration of the call.
         let ret = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) };
         if ret == 0 {
             return Ok(());
@@ -43,11 +43,11 @@ pub fn lock_exclusive(file: &std::fs::File) -> std::io::Result<()> {
     }
 }
 
-/// Le processus enfant reçoit SIGKILL si distroproof meurt, même tué par
-/// SIGKILL : aucune VM orpheline.
+/// The child process gets SIGKILL if distroproof dies, even when distroproof
+/// itself is killed by SIGKILL: no orphan VMs.
 pub fn kill_with_parent(cmd: &mut tokio::process::Command) {
-    // SAFETY: la fermeture ne fait qu'un appel prctl, autorisé entre fork et
-    // exec (async-signal-safe), sans allocation.
+    // SAFETY: the closure only makes a prctl call, which is allowed between
+    // fork and exec (async-signal-safe), without allocating.
     unsafe {
         cmd.pre_exec(|| {
             if libc::prctl(libc::PR_SET_PDEATHSIG, libc::SIGKILL) == 0 {
diff --git a/crates/distroproof/src/tui/input.rs b/crates/distroproof/src/tui/input.rs
index 920a9ad..c07ac1f 100644
--- a/crates/distroproof/src/tui/input.rs
+++ b/crates/distroproof/src/tui/input.rs
@@ -1,4 +1,4 @@
-//! Clavier et souris : navigation modale façon vim, palette de commandes.
+//! Keyboard and mouse: vim-style modal navigation, command palette.
 
 use ratatui::crossterm::event::{
     Event as TermEvent, KeyCode, KeyEvent, KeyEventKind, KeyModifiers, MouseButton, MouseEvent,
@@ -11,31 +11,31 @@ use super::render::{report_rows, ReportRow};
 use super::state::{App, Filter, Mode, Phase, View, Workspace};
 use crate::event::Control;
 
-/// Commandes de la palette : (commande, description).
+/// Palette commands: (command, description).
 pub fn palette_commands(app: &App) -> Vec<(String, String)> {
     let mut cmds: Vec<(String, String)> = [
-        ("pause", "met la cible en pause (QMP stop)"),
-        ("resume", "reprend la cible (QMP cont)"),
-        ("restart", "relance la cible"),
-        ("kill", "tue la cible"),
-        ("restart failed", "relance toutes les cibles en échec"),
-        ("kill all", "tue toutes les VM"),
-        ("console", "panneau courant : console série"),
-        ("logs", "panneau courant : logs"),
-        ("report", "panneau courant : rapport envprobe"),
-        ("dashboard", "panneau courant : dashboard"),
-        ("split", "découpe le panneau (dessous)"),
-        ("vsplit", "découpe le panneau (côte à côte)"),
-        ("close", "ferme le panneau"),
-        ("pin", "épingle le panneau sur la cible"),
-        ("nodiff", "quitte le mode diff"),
-        ("filter all", "toutes les cibles"),
-        ("filter running", "cibles en cours"),
-        ("filter failed", "cibles en échec"),
-        ("filter done", "cibles terminées"),
-        ("ws new", "nouveau workspace"),
-        ("help", "aide"),
-        ("quit", "quitter"),
+        ("pause", "pause the target (QMP stop)"),
+        ("resume", "resume the target (QMP cont)"),
+        ("restart", "restart the target"),
+        ("kill", "kill the target"),
+        ("restart failed", "restart every failed target"),
+        ("kill all", "kill every VM"),
+        ("console", "current pane: serial console"),
+        ("logs", "current pane: logs"),
+        ("report", "current pane: envprobe report"),
+        ("dashboard", "current pane: dashboard"),
+        ("split", "split the pane (below)"),
+        ("vsplit", "split the pane (side by side)"),
+        ("close", "close the pane"),
+        ("pin", "pin the pane to the target"),
+        ("nodiff", "leave diff mode"),
+        ("filter all", "all targets"),
+        ("filter running", "running targets"),
+        ("filter failed", "failed targets"),
+        ("filter done", "finished targets"),
+        ("ws new", "new workspace"),
+        ("help", "help"),
+        ("quit", "quit"),
     ]
     .iter()
     .map(|(c, h)| (c.to_string(), h.to_string()))
@@ -43,20 +43,20 @@ pub fn palette_commands(app: &App) -> Vec<(String, String)> {
     for t in &app.targets {
         cmds.push((
             format!("diff {}", t.name),
-            "diff du rapport contre cette cible".into(),
+            "diff the report against this target".into(),
         ));
-        cmds.push((format!("select {}", t.name), "sélectionne la cible".into()));
+        cmds.push((format!("select {}", t.name), "select the target".into()));
     }
     for (i, ws) in app.workspaces.iter().enumerate() {
         cmds.push((
             format!("ws {}", i + 1),
-            format!("workspace « {} »", ws.name),
+            format!("workspace \"{}\"", ws.name),
         ));
     }
     cmds
 }
 
-/// Correspondance floue : les caractères de `query` apparaissent dans l'ordre.
+/// Fuzzy match: the characters of `query` appear in order.
 fn fuzzy(query: &str, text: &str) -> Option<usize> {
     let mut score = 0;
     let mut last = 0;
@@ -82,7 +82,7 @@ fn target_by_name(app: &App, name: &str) -> Option<usize> {
     app.targets.iter().position(|t| t.name == name)
 }
 
-/// Exécute une commande textuelle (palette ou `:` libre).
+/// Runs a text command (palette or free-form `:`).
 pub fn execute(app: &mut App, cmd: &str) {
     let words: Vec<&str> = cmd.split_whitespace().collect();
     let sel = app.selected;
@@ -108,7 +108,7 @@ pub fn execute(app: &mut App, cmd: &str) {
         }
         ["console"] => set_view(app, View::Console),
         ["logs"] => set_view(app, View::Logs),
-        ["report" | "rapport"] => set_view(app, View::Report),
+        ["report"] => set_view(app, View::Report),
         ["dashboard"] => set_view(app, View::Dashboard),
         ["split"] => split(app, false),
         ["vsplit"] => split(app, true),
@@ -122,18 +122,18 @@ pub fn execute(app: &mut App, cmd: &str) {
                     set_view(app, View::Report);
                 }
             }
-            None => app.notify(format!("cible inconnue : {name}")),
+            None => app.notify(format!("unknown target: {name}")),
         },
         ["select", name] => match target_by_name(app, name) {
             Some(i) => app.selected = i,
-            None => app.notify(format!("cible inconnue : {name}")),
+            None => app.notify(format!("unknown target: {name}")),
         },
         ["filter", f] => match Filter::parse(f) {
             Some(f) => {
                 app.filter = f;
                 app.fix_selection();
             }
-            None => app.notify(format!("filtre inconnu : {f}")),
+            None => app.notify(format!("unknown filter: {f}")),
         },
         ["ws", "new"] => {
             let pane = app.add_pane(View::Dashboard);
@@ -147,12 +147,12 @@ pub fn execute(app: &mut App, cmd: &str) {
         }
         ["ws", n] => match n.parse::<usize>() {
             Ok(n) if n >= 1 && n <= app.workspaces.len() => app.ws = n - 1,
-            _ => app.notify(format!("workspace inconnu : {n}")),
+            _ => app.notify(format!("unknown workspace: {n}")),
         },
         ["help"] => app.mode = Mode::Help,
         ["q" | "quit"] => request_quit(app),
         ["q!" | "quit!"] => app.quit = true,
-        _ => app.notify(format!("commande inconnue : {cmd}")),
+        _ => app.notify(format!("unknown command: {cmd}")),
     }
 }
 
@@ -183,7 +183,7 @@ fn close(app: &mut App) {
     if ws.root.close(focus) {
         ws.focus = ws.root.leaves()[0];
     } else {
-        app.notify("dernier panneau du workspace");
+        app.notify("last pane of the workspace");
     }
 }
 
@@ -202,7 +202,7 @@ fn request_quit(app: &mut App) {
     } else {
         app.quit_armed = true;
         app.notify(format!(
-            "{} VM en cours : q encore pour tout arrêter et quitter",
+            "{} VM(s) running: q again to stop everything and quit",
             app.running_count()
         ));
     }
@@ -228,7 +228,7 @@ fn focus_dir(app: &mut App, dir: Dir) {
     }
 }
 
-/// Octets envoyés à la console série pour une touche.
+/// Bytes sent to the serial console for a key.
 pub fn key_bytes(key: &KeyEvent) -> Vec<u8> {
     let ctrl = key.modifiers.contains(KeyModifiers::CONTROL);
     match key.code {
@@ -268,7 +268,7 @@ fn handle_key(app: &mut App, key: KeyEvent) {
     }
     match app.mode.clone() {
         Mode::Insert => {
-            // Ctrl+] arrive en 0x1D, que crossterm décode en Ctrl+5.
+            // Ctrl+] arrives as 0x1D, which crossterm decodes as Ctrl+5.
             if ctrl && matches!(key.code, KeyCode::Char(']') | KeyCode::Char('5')) {
                 app.mode = Mode::Normal;
                 return;
@@ -318,7 +318,7 @@ fn handle_key(app: &mut App, key: KeyEvent) {
             KeyCode::Enter => {
                 let matches = palette_matches(app, &input);
                 app.mode = Mode::Normal;
-                // Une commande avec arguments tapée en entier passe telle quelle.
+                // A command with arguments typed in full goes through as is.
                 let exact = palette_commands(app)
                     .iter()
                     .any(|(c, _)| *c == input.trim());
@@ -448,8 +448,8 @@ fn normal_key(app: &mut App, key: KeyEvent) {
         KeyCode::Char('x') => app.send(app.selected, Control::Kill),
         KeyCode::Char('p') => toggle_pin(app),
         KeyCode::Char('c') => {
-            // Ouvre la console de la cible dans le panneau courant (ou dans
-            // un panneau console déjà visible).
+            // Opens the target's console in the current pane (or in a console
+            // pane that is already visible).
             let existing = app
                 .workspace()
                 .root
@@ -467,7 +467,7 @@ fn normal_key(app: &mut App, key: KeyEvent) {
             if app.targets[app.pane_target(pane)].alive {
                 app.mode = Mode::Insert;
             } else {
-                app.notify("VM arrêtée : relancez-la (r), avec --hold pour garder la console");
+                app.notify("VM stopped: restart it (r), with --hold to keep the console");
             }
         }
         KeyCode::Char('/') => {
@@ -488,7 +488,7 @@ fn normal_key(app: &mut App, key: KeyEvent) {
             _ => {}
         },
         KeyCode::Char('d') if view == View::Report => {
-            // Diff contre la cible suivante qui a un rapport.
+            // Diff against the next target that has a report.
             let me = app.pane_target(pane);
             let n = app.targets.len();
             let start = app.diff_with.unwrap_or(me);
@@ -500,7 +500,7 @@ fn normal_key(app: &mut App, key: KeyEvent) {
                         .is_some_and(|r| r.envprobe.is_some())
             });
             if app.diff_with.is_none() {
-                app.notify("aucune autre cible n'a de rapport envprobe");
+                app.notify("no other target has an envprobe report");
             }
         }
         KeyCode::Enter if view == View::Report => toggle_section(app, pane),
@@ -532,7 +532,7 @@ fn normal_key(app: &mut App, key: KeyEvent) {
     }
 }
 
-/// Défilement : positif vers le haut (logs : depuis le bas).
+/// Scrolling: positive is up (logs: from the bottom).
 fn scroll(app: &mut App, pane: usize, delta: isize) {
     let p = &mut app.panes[pane];
     match p.view {
@@ -579,7 +579,7 @@ fn collapse_at_cursor(app: &mut App, pane: usize, collapse: bool) {
     if let Some(name) = section_at_cursor(app, pane) {
         if collapse {
             app.panes[pane].collapsed.insert(name.clone());
-            // Le curseur revient sur l'en-tête replié.
+            // The cursor goes back to the collapsed header.
             let rows = report_rows(app, pane);
             if let Some(i) = rows
                 .iter()
@@ -593,7 +593,7 @@ fn collapse_at_cursor(app: &mut App, pane: usize, collapse: bool) {
     }
 }
 
-/// Fait défiler le panneau logs jusqu'à la correspondance suivante.
+/// Scrolls the logs pane to the next match.
 fn jump_match(app: &mut App, forward: bool) {
     let Some(needle) = app.search.clone().filter(|s| !s.is_empty()) else {
         return;
@@ -623,7 +623,7 @@ fn jump_match(app: &mut App, forward: bool) {
         .iter()
         .find(|(p, _)| *p == pane)
         .map_or(10, |(_, r)| r.height.saturating_sub(2) as usize);
-    // Ligne actuellement en bas du panneau.
+    // Line currently at the bottom of the pane.
     let bottom = total.saturating_sub(app.panes[pane].scroll + 1);
     let found = if forward {
         (bottom + 1..total)
@@ -637,11 +637,11 @@ fn jump_match(app: &mut App, forward: bool) {
     };
     match found {
         Some(i) => {
-            // Correspondance au milieu du panneau.
+            // Match in the middle of the pane.
             let bottom_line = (i + height / 2).min(total.saturating_sub(1));
             app.panes[pane].scroll = total.saturating_sub(bottom_line + 1);
         }
-        None => app.notify(format!("« {needle} » introuvable")),
+        None => app.notify(format!("\"{needle}\" not found")),
     }
 }
 
diff --git a/crates/distroproof/src/tui/layout.rs b/crates/distroproof/src/tui/layout.rs
index 9dea099..bdaba63 100644
--- a/crates/distroproof/src/tui/layout.rs
+++ b/crates/distroproof/src/tui/layout.rs
@@ -1,4 +1,4 @@
-//! Panneaux en tiling : arbre binaire de découpes horizontales et verticales.
+//! Tiled panes: a binary tree of horizontal and vertical splits.
 
 use ratatui::layout::Rect;
 
@@ -6,9 +6,9 @@ use ratatui::layout::Rect;
 pub enum Node {
     Leaf(usize),
     Split {
-        /// Vrai : côte à côte (découpe verticale) ; faux : l'un sous l'autre.
+        /// True: side by side (vertical split); false: one above the other.
         side_by_side: bool,
-        /// Part du premier enfant, en pourcentage.
+        /// Share of the first child, as a percentage.
         ratio: u16,
         a: Box<Node>,
         b: Box<Node>,
@@ -33,7 +33,7 @@ impl Node {
         }
     }
 
-    /// Rectangle de chaque panneau.
+    /// Rectangle of each pane.
     pub fn layout(&self, area: Rect, out: &mut Vec<(usize, Rect)>) {
         match self {
             Node::Leaf(id) => out.push((*id, area)),
@@ -61,7 +61,7 @@ impl Node {
         }
     }
 
-    /// Remplace le panneau `target` par une découpe `target | new`.
+    /// Replaces pane `target` with a `target | new` split.
     pub fn split_leaf(&mut self, target: usize, new: usize, side_by_side: bool) -> bool {
         match self {
             Node::Leaf(id) if *id == target => {
@@ -75,7 +75,7 @@ impl Node {
         }
     }
 
-    /// Retire un panneau : son voisin prend sa place. Le dernier reste.
+    /// Removes a pane: its sibling takes its place. The last one stays.
     pub fn close(&mut self, target: usize) -> bool {
         let Node::Split { a, b, .. } = self else {
             return false;
@@ -91,8 +91,8 @@ impl Node {
         a.close(target) || b.close(target)
     }
 
-    /// Agrandit (delta > 0) ou réduit le panneau dans la découpe parente
-    /// la plus proche orientée dans le bon sens.
+    /// Grows (delta > 0) or shrinks the pane within the closest parent split
+    /// that has the right orientation.
     pub fn resize(&mut self, target: usize, delta: i16, side_by_side_wanted: bool) -> bool {
         match self {
             Node::Leaf(_) => false,
@@ -144,7 +144,7 @@ fn cut(area: Rect, side_by_side: bool, ratio: u16) -> (Rect, Rect) {
     }
 }
 
-/// Panneau voisin dans une direction, d'après la géométrie.
+/// Neighboring pane in a direction, based on geometry.
 pub fn neighbor(rects: &[(usize, Rect)], from: usize, dir: Dir) -> Option<usize> {
     let (_, cur) = rects.iter().find(|(id, _)| *id == from)?;
     let center = |r: &Rect| {
diff --git a/crates/distroproof/src/tui/mod.rs b/crates/distroproof/src/tui/mod.rs
index 69b36ac..1a8095d 100644
--- a/crates/distroproof/src/tui/mod.rs
+++ b/crates/distroproof/src/tui/mod.rs
@@ -1,5 +1,5 @@
-//! TUI de monitoring de la matrice, branchée uniquement sur le bus
-//! d'événements : elle lit les `Event` et envoie des `Control`.
+//! Matrix monitoring TUI, plugged only into the event bus: it reads
+//! `Event`s and sends `Control`s.
 
 mod input;
 mod layout;
@@ -20,11 +20,11 @@ use crate::model::VmSpec;
 
 pub use state::App;
 
-/// Intervalle minimal entre deux rendus : au plus 30 images par seconde,
-/// quel que soit le débit des consoles série.
+/// Minimum interval between two renders: at most 30 frames per second,
+/// whatever the throughput of the serial consoles.
 const FRAME: Duration = Duration::from_millis(33);
 
-/// Lance la TUI jusqu'à ce que l'utilisateur quitte.
+/// Runs the TUI until the user quits.
 pub async fn run(
     specs: Vec<(VmSpec, usize)>,
     groups: Vec<String>,
@@ -40,8 +40,8 @@ pub async fn run(
     let mut terminal = ratatui::try_init()?;
     execute!(io::stdout(), EnableMouseCapture)?;
 
-    // Lecture du terminal dans un thread dédié : la boucle tokio ne bloque
-    // jamais, même pendant les boots.
+    // The terminal is read in a dedicated thread: the tokio loop never
+    // blocks, even during boots.
     let (input_tx, mut input_rx) = mpsc::unbounded_channel();
     std::thread::spawn(move || {
         while let Ok(ev) = event::read() {
@@ -68,13 +68,13 @@ pub async fn run(
             ev = bus.recv(), if bus_open => match ev {
                 Some(ev) => {
                     app.apply(ev);
-                    // Vide le reste du flux avant de redessiner.
+                    // Drain the rest of the stream before redrawing.
                     while let Ok(ev) = bus.try_recv() {
                         app.apply(ev);
                     }
                     dirty = true;
                 }
-                // Plus d'émetteur : l'affichage reste jusqu'à `q`.
+                // No senders left: the display stays until `q`.
                 None => bus_open = false,
             },
             ev = input_rx.recv() => {
@@ -186,7 +186,7 @@ mod tests {
                 "debian-12",
                 VmEvent::Output {
                     stream: Stream::Stdout,
-                    line: format!("ligne {i} du programme"),
+                    line: format!("program line {i}"),
                 },
             ));
         }
@@ -248,13 +248,13 @@ mod tests {
         let small = render(&mut app, 80, 24);
         assert!(small.contains("distroproof"));
         assert!(small.contains("debian-12"));
-        assert!(small.contains("commande"), "{small}");
-        assert!(small.contains("ligne 49 du programme"), "{small}");
+        assert!(small.contains("command"), "{small}");
+        assert!(small.contains("program line 49"), "{small}");
         let big = render(&mut app, 200, 60);
-        for name in ["rocky-9", "fedora", "alpine", "téléchargement 25 %"] {
-            assert!(big.contains(name), "{name} absent :\n{big}");
+        for name in ["rocky-9", "fedora", "alpine", "downloading 25%"] {
+            assert!(big.contains(name), "{name} missing:\n{big}");
         }
-        // Très petit terminal : pas de panique.
+        // Tiny terminal: no panic.
         render(&mut app, 20, 5);
     }
 
@@ -262,7 +262,7 @@ mod tests {
     fn keys_drive_views_and_controls() {
         let (mut app, mut rxs) = app();
         render(&mut app, 120, 40);
-        // Sélection et pause de la cible.
+        // Select and pause the target.
         assert_eq!(app.selected, 0);
         key(&mut app, KeyCode::Char(' '), KeyModifiers::NONE);
         assert!(matches!(rxs[0].try_recv(), Ok(Control::Pause)));
@@ -273,7 +273,7 @@ mod tests {
         key(&mut app, KeyCode::Char('x'), KeyModifiers::NONE);
         assert!(matches!(rxs[1].try_recv(), Ok(Control::Kill)));
 
-        // Palette : diff du rapport d'alpine contre arch.
+        // Palette: diff alpine's report against arch.
         app.selected = 6;
         chars(&mut app, ":diff arch");
         key(&mut app, KeyCode::Enter, KeyModifiers::NONE);
@@ -281,9 +281,9 @@ mod tests {
         assert_eq!(app.diff_with, Some(5));
         assert_eq!(app.panes[app.focused_pane()].view, View::Report);
         let screen = render(&mut app, 120, 40);
-        assert!(screen.contains("diff contre arch"), "{screen}");
+        assert!(screen.contains("diff against arch"), "{screen}");
 
-        // Tiling : découpe, redimensionnement, fermeture.
+        // Tiling: split, resize, close.
         let before = app.workspace().root.leaves().len();
         key(&mut app, KeyCode::Char('w'), KeyModifiers::CONTROL);
         chars(&mut app, "v");
@@ -294,7 +294,7 @@ mod tests {
         chars(&mut app, "q");
         assert_eq!(app.workspace().root.leaves().len(), before);
 
-        // Console interactive : la saisie part vers la VM.
+        // Interactive console: input goes to the VM.
         app.selected = 0;
         key(&mut app, KeyCode::Char('c'), KeyModifiers::NONE);
         assert_eq!(app.panes[app.focused_pane()].view, View::Console);
@@ -312,21 +312,21 @@ mod tests {
         let screen = render(&mut app, 120, 40);
         assert!(screen.contains("login:"), "{screen}");
 
-        // Recherche dans les logs.
+        // Search the logs.
         key(&mut app, KeyCode::Char('L'), KeyModifiers::NONE);
-        chars(&mut app, "/ligne 3");
+        chars(&mut app, "/line 3");
         key(&mut app, KeyCode::Enter, KeyModifiers::NONE);
-        assert_eq!(app.search.as_deref(), Some("ligne 3"));
+        assert_eq!(app.search.as_deref(), Some("line 3"));
         let screen = render(&mut app, 120, 40);
-        assert!(screen.contains("« ligne 3 » : 11"), "{screen}");
+        assert!(screen.contains("\"line 3\": 11"), "{screen}");
 
-        // Filtre échecs : seule alpine reste.
+        // Failed filter: only alpine is left.
         key(&mut app, KeyCode::Char('1'), KeyModifiers::NONE);
         chars(&mut app, ":filter failed");
         key(&mut app, KeyCode::Enter, KeyModifiers::NONE);
         assert_eq!(app.visible(), vec![6]);
 
-        // Quitter : confirmation tant que des VM tournent.
+        // Quit: confirmation while VMs are running.
         key(&mut app, KeyCode::Char('q'), KeyModifiers::NONE);
         assert!(!app.quit);
         key(&mut app, KeyCode::Char('q'), KeyModifiers::NONE);
diff --git a/crates/distroproof/src/tui/render.rs b/crates/distroproof/src/tui/render.rs
index 3e9eb16..f2a6d50 100644
--- a/crates/distroproof/src/tui/render.rs
+++ b/crates/distroproof/src/tui/render.rs
@@ -1,5 +1,5 @@
-//! Rendu : barres, panneaux en tiling, cartes du dashboard, logs, rapport,
-//! console, palette de commandes et aide.
+//! Rendering: bars, tiled panes, dashboard cards, logs, report, console,
+//! command palette and help.
 
 use std::time::Duration;
 
@@ -104,7 +104,7 @@ fn top_bar(f: &mut Frame, app: &App, area: Rect) {
         Span::styled(format!("● {running}"), Style::new().fg(t.running)),
         Span::styled(
             format!(
-                "  / {}  │ filtre : {}",
+                "  / {}  │ filter: {}",
                 app.targets.len(),
                 app.filter.label()
             ),
@@ -126,19 +126,19 @@ fn bottom_bar(f: &mut Frame, app: &App, area: Rect) {
             (
                 " NORMAL ",
                 msg.unwrap_or_else(|| {
-                    "hjkl sélection · espace pause · r relance · x kill · c console · / chercher · : commandes · ? aide · q quitter".into()
+                    "hjkl select · space pause · r restart · x kill · c console · / search · : commands · ? help · q quit".into()
                 }),
             )
         }
         Mode::Window => (
-            " FENÊTRE ",
-            "s/v découper · q fermer · hjkl/w focus · < > + - taille · Échap annuler".into(),
+            " WINDOW ",
+            "s/v split · q close · hjkl/w focus · < > + - resize · Esc cancel".into(),
         ),
         Mode::Insert => (
             " CONSOLE ",
-            "saisie envoyée à la console série · Ctrl+] pour sortir".into(),
+            "input sent to the serial console · Ctrl+] to leave".into(),
         ),
-        Mode::Search(s) => (" CHERCHER ", format!("/{s}")),
+        Mode::Search(s) => (" SEARCH ", format!("/{s}")),
     };
     let line = Line::from(vec![
         Span::styled(
@@ -162,31 +162,31 @@ fn bottom_bar(f: &mut Frame, app: &App, area: Rect) {
 pub fn status(app: &App, t: &Target) -> (String, Color) {
     let th = &app.theme;
     if t.paused {
-        return ("⏸ en pause".into(), th.warning);
+        return ("⏸ paused".into(), th.warning);
     }
     match &t.phase {
-        Phase::Queued => ("en attente".into(), th.muted),
+        Phase::Queued => ("queued".into(), th.muted),
         Phase::Downloading { done, total } => (
             match total {
-                Some(total) if *total > 0 => format!("téléchargement {} %", done * 100 / total),
-                _ => format!("téléchargement {}", fmt_bytes(*done)),
+                Some(total) if *total > 0 => format!("downloading {}%", done * 100 / total),
+                _ => format!("downloading {}", fmt_bytes(*done)),
             },
             th.warning,
         ),
-        Phase::Verifying => ("vérification".into(), th.warning),
-        Phase::Preparing => ("extraction du noyau".into(), th.running),
+        Phase::Verifying => ("verifying".into(), th.warning),
+        Phase::Preparing => ("extracting kernel".into(), th.running),
         Phase::Booting => ("boot…".into(), th.running),
         Phase::Running(stage) => (
             match stage {
                 Some(s) => format!("● {}", s.label()),
-                None => "● agent prêt".into(),
+                None => "● agent ready".into(),
             },
             th.running,
         ),
         Phase::Done(o) => {
             let mut label = match (o, t.result.as_ref().and_then(|r| r.exit_code())) {
-                (Outcome::Failure, Some(c)) => format!("✘ échec ({c})"),
-                (Outcome::Success, _) => "✔ succès".into(),
+                (Outcome::Failure, Some(c)) => format!("✘ failed ({c})"),
+                (Outcome::Success, _) => "✔ success".into(),
                 (o, _) => format!("✘ {}", o.label()),
             };
             if t.held && t.alive {
@@ -207,7 +207,7 @@ fn fmt_clock(d: Duration) -> String {
     format!("{:02}:{:02}", s / 60, s % 60)
 }
 
-/// Jauge horizontale avec huitièmes de bloc.
+/// Horizontal gauge with eighth blocks.
 fn gauge(ratio: f64, width: usize, color: Color, bg: Color) -> Vec<Span<'static>> {
     let ratio = ratio.clamp(0.0, 1.0);
     let eighths = (ratio * width as f64 * 8.0).round() as usize;
@@ -226,8 +226,8 @@ fn gauge(ratio: f64, width: usize, color: Color, bg: Color) -> Vec<Span<'static>
     ]
 }
 
-/// Graphe en caractères Braille (2 échantillons × 4 niveaux par cellule),
-/// aligné à droite sur les échantillons les plus récents.
+/// Graph in Braille characters (2 samples × 4 levels per cell), right-aligned
+/// on the most recent samples.
 pub fn braille(samples: &[f64], max: f64, width: usize, height: usize) -> Vec<String> {
     let cols = width * 2;
     let start = samples.len().saturating_sub(cols);
@@ -247,7 +247,7 @@ pub fn braille(samples: &[f64], max: f64, width: usize, height: usize) -> Vec<St
             let base = (height - 1 - row) * 4;
             let dots = level.saturating_sub(base).min(4);
             for d in 0..dots {
-                // Points de bas en haut : lignes 3, 2, 1, 0 de la cellule.
+                // Dots from bottom to top: rows 3, 2, 1, 0 of the cell.
                 let bit = match (x % 2, 3 - d) {
                     (0, 0) => 0x01,
                     (0, 1) => 0x02,
@@ -282,7 +282,7 @@ fn dashboard(f: &mut Frame, app: &mut App, area: Rect, focused: bool) {
                 .add_modifier(Modifier::BOLD),
         ),
         Span::styled(
-            format!("{} cible(s) ", visible.len()),
+            format!("{} target(s) ", visible.len()),
             Style::new().fg(app.theme.muted),
         ),
     ]);
@@ -291,7 +291,7 @@ fn dashboard(f: &mut Frame, app: &mut App, area: Rect, focused: bool) {
     f.render_widget(block, area);
     if visible.is_empty() {
         f.render_widget(
-            Paragraph::new("aucune cible pour ce filtre (f pour changer)")
+            Paragraph::new("no targets for this filter (f to change it)")
                 .style(Style::new().fg(app.theme.muted)),
             inner,
         );
@@ -361,7 +361,7 @@ fn card(f: &mut Frame, app: &App, idx: usize, rect: Rect) {
         Span::styled(t.image.clone(), Style::new().fg(th.accent)),
         Span::styled(" · ", muted),
         Span::styled(
-            t.kernel().unwrap_or("noyau ?").to_string(),
+            t.kernel().unwrap_or("kernel ?").to_string(),
             Style::new().fg(th.fg),
         ),
     ]));
@@ -379,7 +379,7 @@ fn card(f: &mut Frame, app: &App, idx: usize, rect: Rect) {
         Span::styled(if t.direct_kernel { "  direct" } else { "" }, muted),
     ]));
     let gauge_w = w.saturating_sub(14).max(4);
-    // 100 % par vCPU : une VM à 2 CPU saturée affiche 200 %.
+    // 100% per vCPU: a saturated 2-CPU VM shows 200%.
     let cpu_max = 100.0 * f64::from(t.cpus.max(1));
     let alive = t.alive;
     let cpu = if alive { t.metrics.cpu_percent } else { 0.0 };
@@ -454,8 +454,8 @@ fn highlight<'a>(text: &'a str, needle: Option<&str>, base: Style, hl: Style) ->
     };
     let lower = text.to_lowercase();
     let n = needle.to_lowercase();
-    // Correspondances sur la version minuscule, découpage sur l'original si
-    // les longueurs coïncident (ASCII), sinon ligne entière surlignée.
+    // Match on the lowercase version and slice the original if the lengths
+    // agree (ASCII); otherwise highlight the whole line.
     if lower.len() != text.len() {
         return if lower.contains(&n) {
             Line::from(Span::styled(text, hl))
@@ -484,7 +484,7 @@ fn logs(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool) {
     let p = &mut app.panes[pane];
     p.scroll = p.scroll.min(max_scroll);
     let scroll = p.scroll;
-    let follow = if scroll == 0 { "suivi" } else { "défilement" };
+    let follow = if scroll == 0 { "following" } else { "scrolled" };
     let search = app.search.clone();
     let matches = search
         .as_ref()
@@ -496,13 +496,13 @@ fn logs(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool) {
                 .filter(|l| l.text.to_lowercase().contains(&s))
                 .count()
         })
-        .map(|n| format!(" · « {} » : {n}", search.as_deref().unwrap_or("")))
+        .map(|n| format!(" · \"{}\": {n}", search.as_deref().unwrap_or("")))
         .unwrap_or_default();
     let title = target_title(
         app,
         pane,
         "logs",
-        format!("{total} lignes · {follow}{matches} "),
+        format!("{total} lines · {follow}{matches} "),
     );
     let block = pane_block(app, title, focused);
     let th = app.theme;
@@ -526,7 +526,7 @@ fn logs(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool) {
     f.render_widget(Paragraph::new(lines).block(block), area);
 }
 
-/// Ligne logique du panneau rapport.
+/// Logical line of the report pane.
 pub enum ReportRow {
     Section {
         name: String,
@@ -576,11 +576,11 @@ pub fn report_rows(app: &App, pane: usize) -> Vec<ReportRow> {
                 }
                 match d {
                     SectionDiff::OnlyInA(_) => rows.push(ReportRow::Entry(Line::styled(
-                        "    - section absente ici",
+                        "    - section missing here",
                         Style::new().fg(th.failure),
                     ))),
                     SectionDiff::OnlyInB(_) => rows.push(ReportRow::Entry(Line::styled(
-                        "    + section absente de la référence",
+                        "    + section missing from the reference",
                         Style::new().fg(th.success),
                     ))),
                     SectionDiff::Changed { changes, .. } => {
@@ -639,9 +639,9 @@ fn report(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool)
     let diff_label = app
         .diff_with
         .filter(|&o| o != idx)
-        .map(|o| format!("diff contre {} (D pour quitter) ", app.targets[o].name))
-        .unwrap_or_else(|| "Entrée replier · d diff ".into());
-    let title = target_title(app, pane, "rapport", diff_label);
+        .map(|o| format!("diff against {} (D to leave) ", app.targets[o].name))
+        .unwrap_or_else(|| "Enter fold · d diff ".into());
+    let title = target_title(app, pane, "report", diff_label);
     let block = pane_block(app, title, focused);
     let height = area.height.saturating_sub(2) as usize;
     let th = app.theme;
@@ -655,8 +655,8 @@ fn report(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool)
     let (cursor, scroll) = (p.cursor, p.scroll);
     if rows.is_empty() {
         let msg = match &app.targets[idx].result {
-            Some(_) => "pas de rapport envprobe pour cette cible",
-            None => "rapport envprobe pas encore disponible",
+            Some(_) => "no envprobe report for this target",
+            None => "envprobe report not available yet",
         };
         f.render_widget(
             Paragraph::new(msg)
@@ -700,11 +700,11 @@ fn console(f: &mut Frame, app: &mut App, pane: usize, area: Rect, focused: bool)
     let idx = app.pane_target(pane);
     let insert = focused && app.mode == Mode::Insert;
     let extra = if insert {
-        "saisie active · Ctrl+] pour sortir ".to_string()
+        "typing · Ctrl+] to leave ".to_string()
     } else if app.targets[idx].alive {
-        "i pour saisir ".to_string()
+        "i to type ".to_string()
     } else {
-        "VM arrêtée ".to_string()
+        "VM stopped ".to_string()
     };
     let title = target_title(app, pane, "console", extra);
     let mut block = pane_block(app, title, focused);
@@ -739,7 +739,7 @@ fn palette(f: &mut Frame, app: &App, input: &str, selected: usize) {
     let block = Block::bordered()
         .border_type(BorderType::Rounded)
         .border_style(Style::new().fg(th.accent))
-        .title(" commandes ");
+        .title(" commands ");
     let inner = block.inner(rect);
     f.render_widget(block, rect);
     let mut lines = vec![Line::from(vec![
@@ -768,33 +768,27 @@ fn palette(f: &mut Frame, app: &App, input: &str, selected: usize) {
 }
 
 const HELP: &[(&str, &str)] = &[
-    (
-        "h j k l / flèches",
-        "changer de cible (dashboard) ou défiler",
-    ),
-    ("Tab, Ctrl+W w", "panneau suivant"),
-    ("Ctrl+W h/j/k/l", "focus dans une direction"),
-    (
-        "Ctrl+W s / v",
-        "découper le panneau (dessous / côte à côte)",
-    ),
-    ("Ctrl+W q", "fermer le panneau"),
-    ("Ctrl+W < > + -", "redimensionner"),
-    ("1…9", "changer de workspace"),
-    ("D L R C", "vue dashboard, logs, rapport, console"),
-    ("espace", "pause / reprise (QMP stop / cont)"),
-    ("r / x", "relancer / tuer la cible"),
-    ("c, puis i", "ouvrir la console série / saisir dedans"),
-    ("Ctrl+]", "quitter la saisie console"),
-    ("/  n  N", "chercher dans les logs, suivant, précédent"),
-    ("g / G", "début / fin (suivi)"),
-    ("Entrée", "replier une section du rapport"),
-    ("d / D", "diff contre une autre cible / quitter le diff"),
-    ("p", "épingler le panneau sur la cible"),
-    ("f", "filtrer : toutes, en cours, échecs, terminées"),
-    (": ou Ctrl+P", "palette de commandes"),
-    ("souris", "clic : sélection et focus, molette : défilement"),
-    ("q", "quitter (deux fois si des VM tournent)"),
+    ("h j k l / arrows", "change target (dashboard) or scroll"),
+    ("Tab, Ctrl+W w", "next pane"),
+    ("Ctrl+W h/j/k/l", "focus in a direction"),
+    ("Ctrl+W s / v", "split the pane (below / side by side)"),
+    ("Ctrl+W q", "close the pane"),
+    ("Ctrl+W < > + -", "resize"),
+    ("1…9", "switch workspace"),
+    ("D L R C", "view: dashboard, logs, report, console"),
+    ("space", "pause / resume (QMP stop / cont)"),
+    ("r / x", "restart / kill the target"),
+    ("c, then i", "open the serial console / type in it"),
+    ("Ctrl+]", "leave console input"),
+    ("/  n  N", "search the logs, next, previous"),
+    ("g / G", "top / bottom (follow)"),
+    ("Enter", "fold a report section"),
+    ("d / D", "diff against another target / leave the diff"),
+    ("p", "pin the pane to the target"),
+    ("f", "filter: all, running, failed, finished"),
+    (": or Ctrl+P", "command palette"),
+    ("mouse", "click: select and focus, wheel: scroll"),
+    ("q", "quit (twice if VMs are running)"),
 ];
 
 fn help(f: &mut Frame, app: &App) {
@@ -804,7 +798,7 @@ fn help(f: &mut Frame, app: &App) {
     let block = Block::bordered()
         .border_type(BorderType::Rounded)
         .border_style(Style::new().fg(th.accent))
-        .title(" aide · Échap pour fermer ");
+        .title(" help · Esc to close ");
     let lines: Vec<Line> = HELP
         .iter()
         .map(|(k, v)| {
@@ -824,13 +818,13 @@ mod tests {
     #[test]
     fn braille_graph() {
         let rows = braille(&[0.0, 100.0], 100.0, 1, 1);
-        // Colonne gauche vide, colonne droite pleine.
+        // Left column empty, right column full.
         assert_eq!(rows, vec!["⢸".to_string()]);
         let rows = braille(&[100.0, 100.0, 50.0, 50.0], 100.0, 2, 2);
         assert_eq!(rows.len(), 2);
         assert_eq!(rows[0], "⣿⠀");
         assert_eq!(rows[1], "⣿⣿");
-        // Moins d'échantillons que de place : alignés à droite.
+        // Fewer samples than room: right-aligned.
         assert_eq!(braille(&[100.0], 100.0, 2, 1), vec!["⠀⢸".to_string()]);
     }
 
diff --git a/crates/distroproof/src/tui/state.rs b/crates/distroproof/src/tui/state.rs
index ce1ccde..3cdf180 100644
--- a/crates/distroproof/src/tui/state.rs
+++ b/crates/distroproof/src/tui/state.rs
@@ -1,4 +1,4 @@
-//! État de la TUI, alimenté uniquement par le bus d'événements.
+//! TUI state, fed only by the event bus.
 
 use std::collections::{HashMap, HashSet, VecDeque};
 use std::time::{Duration, Instant};
@@ -12,7 +12,7 @@ use crate::event::{Control, Event, Metrics, Stage, Stream, VmEvent};
 use crate::model::{Outcome, TargetResult, VmSpec};
 use crate::vm::strip_ansi;
 
-/// Échantillons gardés pour les graphes (une seconde chacun).
+/// Samples kept for the graphs (one second each).
 pub const HISTORY: usize = 120;
 const MAX_LOGS: usize = 20_000;
 
@@ -50,7 +50,7 @@ pub struct Target {
     pub cpus: u32,
     pub phase: Phase,
     pub paused: bool,
-    /// Processus QEMU vivant.
+    /// QEMU process alive.
     pub alive: bool,
     pub held: bool,
     pub started: Option<Instant>,
@@ -162,7 +162,7 @@ impl Target {
             }
             VmEvent::Preparing => {
                 self.phase = Phase::Preparing;
-                self.log(LogKind::Info, "boot de préparation : extraction du noyau");
+                self.log(LogKind::Info, "preparation boot: extracting the kernel");
             }
             VmEvent::Booting {
                 pid, direct_kernel, ..
@@ -182,7 +182,7 @@ impl Target {
                         if direct_kernel {
                             "boot direct"
                         } else {
-                            "boot sur le disque"
+                            "booting from disk"
                         }
                     ),
                 );
@@ -192,7 +192,7 @@ impl Target {
                     self.boot_ms = Some(boot_ms);
                     self.phase = Phase::Running(None);
                 }
-                self.log(LogKind::Info, format!("agent prêt en {} ms", boot_ms));
+                self.log(LogKind::Info, format!("agent ready in {} ms", boot_ms));
             }
             VmEvent::Stage { stage } => {
                 if self.phase != Phase::Preparing {
@@ -201,7 +201,7 @@ impl Target {
                 self.log(LogKind::Stage, format!("▶ {}", stage.label()));
             }
             VmEvent::StageExited { stage, code } => {
-                self.log(LogKind::Stage, format!("■ {} : code {code}", stage.label()));
+                self.log(LogKind::Stage, format!("■ {}: code {code}", stage.label()));
             }
             VmEvent::Output { stream, line } => {
                 let kind = match stream {
@@ -226,7 +226,7 @@ impl Target {
             }
             VmEvent::Resumed => {
                 self.paused = false;
-                self.log(LogKind::Info, "reprise");
+                self.log(LogKind::Info, "resumed");
             }
             VmEvent::Finished(result) => {
                 self.phase = Phase::Done(result.outcome);
@@ -235,7 +235,7 @@ impl Target {
                     self.boot_ms = result.boot_ms;
                 }
                 let msg = match (&result.error, result.exit_code()) {
-                    (Some(e), _) => format!("{} : {e}", result.outcome.label()),
+                    (Some(e), _) => format!("{}: {e}", result.outcome.label()),
                     (None, Some(c)) => format!("{} (code {c})", result.outcome.label()),
                     (None, None) => result.outcome.label().to_string(),
                 };
@@ -246,7 +246,7 @@ impl Target {
                 self.held = true;
                 self.log(
                     LogKind::Info,
-                    "VM gardée : shell root sur la console (c pour l'ouvrir)",
+                    "VM kept up: root shell on the console (c to open it)",
                 );
             }
             VmEvent::Stopped => {
@@ -268,9 +268,9 @@ pub enum View {
 
 pub struct Pane {
     pub view: View,
-    /// Lignes défilées depuis le bas (logs) ou depuis le haut (rapport).
+    /// Lines scrolled from the bottom (logs) or from the top (report).
     pub scroll: usize,
-    /// Cible affichée quand le panneau est épinglé, sinon la sélection.
+    /// Target shown when the pane is pinned; otherwise the selection.
     pub pinned: Option<usize>,
     pub cursor: usize,
     pub collapsed: HashSet<String>,
@@ -290,7 +290,7 @@ impl Pane {
 
 pub struct Workspace {
     pub name: String,
-    /// Groupe de cibles (fichier de matrice) montré par le dashboard.
+    /// Group of targets (matrix file) shown by the dashboard.
     pub group: Option<usize>,
     pub root: Node,
     pub focus: usize,
@@ -307,10 +307,10 @@ pub enum Filter {
 impl Filter {
     pub fn label(self) -> &'static str {
         match self {
-            Filter::All => "toutes",
-            Filter::Running => "en cours",
-            Filter::Failed => "échecs",
-            Filter::Done => "terminées",
+            Filter::All => "all",
+            Filter::Running => "running",
+            Filter::Failed => "failed",
+            Filter::Done => "finished",
         }
     }
 
@@ -325,10 +325,10 @@ impl Filter {
 
     pub fn parse(s: &str) -> Option<Filter> {
         Some(match s {
-            "all" | "toutes" | "tout" => Filter::All,
-            "running" | "encours" | "run" => Filter::Running,
-            "failed" | "fail" | "échecs" | "echecs" => Filter::Failed,
-            "done" | "finished" | "terminées" => Filter::Done,
+            "all" => Filter::All,
+            "running" | "run" => Filter::Running,
+            "failed" | "fail" => Filter::Failed,
+            "done" | "finished" => Filter::Done,
             _ => return None,
         })
     }
@@ -349,9 +349,9 @@ impl Filter {
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Mode {
     Normal,
-    /// Préfixe Ctrl+W : commande de fenêtre en attente.
+    /// Ctrl+W prefix: window command pending.
     Window,
-    /// Saisie envoyée à la console série de la cible.
+    /// Input sent to the target's serial console.
     Insert,
     Search(String),
     Palette {
@@ -376,7 +376,7 @@ pub struct App {
     pub controls: HashMap<String, UnboundedSender<Control>>,
     pub quit_armed: bool,
     pub quit: bool,
-    /// Géométrie du dernier rendu, pour la souris et la navigation.
+    /// Geometry of the last render, for the mouse and navigation.
     pub pane_rects: Vec<(usize, Rect)>,
     pub card_rects: Vec<(Rect, usize)>,
     pub dashboard_cols: usize,
@@ -409,23 +409,19 @@ impl App {
             card_rects: Vec::new(),
             dashboard_cols: 1,
         };
-        // Un workspace par matrice : dashboard au-dessus des logs.
+        // One workspace per matrix: dashboard above the logs.
         let multi = groups.len() > 1;
         for (i, name) in groups.iter().enumerate() {
             let dash = app.add_pane(View::Dashboard);
             let logs = app.add_pane(View::Logs);
             app.workspaces.push(Workspace {
-                name: if multi {
-                    name.clone()
-                } else {
-                    "matrice".into()
-                },
+                name: if multi { name.clone() } else { "matrix".into() },
                 group: multi.then_some(i),
                 root: Node::split(Node::Leaf(dash), Node::Leaf(logs), false, 58),
                 focus: dash,
             });
         }
-        // Workspace d'inspection : rapport et console côte à côte.
+        // Inspection workspace: report and console side by side.
         let report = app.add_pane(View::Report);
         let console = app.add_pane(View::Console);
         app.workspaces.push(Workspace {
@@ -460,7 +456,7 @@ impl App {
         self.workspace().focus
     }
 
-    /// Cible affichée par un panneau.
+    /// Target shown by a pane.
     pub fn pane_target(&self, pane: usize) -> usize {
         self.panes[pane]
             .pinned
@@ -468,7 +464,7 @@ impl App {
             .min(self.targets.len().saturating_sub(1))
     }
 
-    /// Cibles visibles dans le dashboard du workspace courant.
+    /// Targets visible in the current workspace's dashboard.
     pub fn visible(&self) -> Vec<usize> {
         let group = self.workspace().group;
         self.targets
@@ -488,18 +484,18 @@ impl App {
         let name = self.targets[target].name.clone();
         let label = match &ctrl {
             Control::Pause => Some("pause"),
-            Control::Resume => Some("reprise"),
-            Control::Kill => Some("arrêt"),
-            Control::Restart => Some("relance"),
+            Control::Resume => Some("resume"),
+            Control::Kill => Some("kill"),
+            Control::Restart => Some("restart"),
             Control::ConsoleInput(_) => None,
         };
         match self.controls.get(&name) {
             Some(tx) if tx.send(ctrl).is_ok() => {
                 if let Some(label) = label {
-                    self.notify(format!("{label} : {name}"));
+                    self.notify(format!("{label}: {name}"));
                 }
             }
-            _ => self.notify(format!("{name} : plus de contrôle possible")),
+            _ => self.notify(format!("{name}: can no longer be controlled")),
         }
     }
 
@@ -523,7 +519,7 @@ impl App {
         self.selected = visible[next];
     }
 
-    /// Garde la sélection parmi les cibles visibles quand le filtre change.
+    /// Keeps the selection among the visible targets when the filter changes.
     pub fn fix_selection(&mut self) {
         let visible = self.visible();
         if !visible.contains(&self.selected) {
@@ -534,9 +530,9 @@ impl App {
     }
 }
 
-/// Ajoute `bytes` au tampon et renvoie les lignes complètes, nettoyées. Le
-/// décodage attend la fin de ligne : un caractère UTF-8 ou une séquence
-/// d'échappement coupés entre deux lectures du port série restent intacts.
+/// Appends `bytes` to the buffer and returns the complete, cleaned-up lines.
+/// Decoding waits for the end of the line: a UTF-8 character or an escape
+/// sequence split across two serial port reads stays intact.
 fn complete_lines(partial: &mut Vec<u8>, bytes: &[u8]) -> Vec<String> {
     partial.extend_from_slice(bytes);
     let mut lines = Vec::new();
@@ -558,12 +554,12 @@ mod tests {
     #[test]
     fn console_lines_survive_split_reads() {
         let mut partial = Vec::new();
-        let text = "\x1b[0;32m OK \x1b[0m ttyS0…ice\r\ncommande terminée\n\nsuite";
+        let text = "\x1b[0;32m OK \x1b[0m ttyS0…ice\r\ncommand finished — déjà vu\n\nrest";
         let mut lines = Vec::new();
         for b in text.as_bytes() {
             lines.extend(complete_lines(&mut partial, std::slice::from_ref(b)));
         }
-        assert_eq!(lines, [" OK  ttyS0…ice", "commande terminée"]);
-        assert_eq!(partial, b"suite");
+        assert_eq!(lines, [" OK  ttyS0…ice", "command finished — déjà vu"]);
+        assert_eq!(partial, b"rest");
     }
 }
diff --git a/crates/distroproof/src/tui/theme.rs b/crates/distroproof/src/tui/theme.rs
index 627444e..b277719 100644
--- a/crates/distroproof/src/tui/theme.rs
+++ b/crates/distroproof/src/tui/theme.rs
@@ -1,4 +1,4 @@
-//! Thème de la TUI : `$XDG_CONFIG_HOME/distroproof/theme.toml`.
+//! TUI theme: `$XDG_CONFIG_HOME/distroproof/theme.toml`.
 //!
 //! ```toml
 //! [colors]
@@ -6,8 +6,8 @@
 //! success = "#9ece6a"
 //! ```
 //!
-//! Les couleurs sont en true color si le terminal l'annonce (`COLORTERM`),
-//! sinon ramenées à la palette 256 couleurs la plus proche.
+//! Colors are true color if the terminal advertises it (`COLORTERM`),
+//! otherwise mapped to the closest color of the 256-color palette.
 
 use std::collections::HashMap;
 
@@ -63,7 +63,7 @@ fn parse_hex(s: &str) -> Option<(u8, u8, u8)> {
     Some(((v >> 16) as u8, (v >> 8) as u8, v as u8))
 }
 
-/// Index xterm-256 le plus proche d'une couleur RGB (cube 6×6×6 ou gris).
+/// Closest xterm-256 index for an RGB color (6×6×6 cube or grays).
 pub fn to_256(r: u8, g: u8, b: u8) -> u8 {
     let level = |c: u8| -> u8 {
         match c {
@@ -101,14 +101,14 @@ fn truecolor() -> bool {
 }
 
 impl Theme {
-    /// Thème par défaut, surchargé par le fichier de l'utilisateur s'il existe.
-    /// Renvoie aussi un avertissement si le fichier est invalide.
+    /// Default theme, overridden by the user's file if it exists. Also returns
+    /// a warning if the file is invalid.
     pub fn load() -> (Theme, Option<String>) {
         let path = crate::dirs::config().join("theme.toml");
         let mut warning = None;
         let file: ThemeFile = match std::fs::read_to_string(&path) {
             Ok(text) => toml::from_str(&text).unwrap_or_else(|e| {
-                warning = Some(format!("{} : {}", path.display(), e.message()));
+                warning = Some(format!("{}: {}", path.display(), e.message()));
                 ThemeFile::default()
             }),
             Err(_) => ThemeFile::default(),
@@ -122,9 +122,9 @@ impl Theme {
                         colors.insert(key, rgb);
                     }
                 }
-                (false, _) => warning = Some(format!("theme.toml : couleur inconnue « {k} »")),
+                (false, _) => warning = Some(format!("theme.toml: unknown color \"{k}\"")),
                 (true, None) => {
-                    warning = Some(format!("theme.toml : « {v} » n'est pas au format #rrggbb"))
+                    warning = Some(format!("theme.toml: \"{v}\" is not in #rrggbb format"))
                 }
             }
         }
diff --git a/crates/distroproof/src/vm.rs b/crates/distroproof/src/vm.rs
index 7953c84..4fc4d27 100644
--- a/crates/distroproof/src/vm.rs
+++ b/crates/distroproof/src/vm.rs
@@ -1,4 +1,4 @@
-//! Exécution d'une cible : image, disques, boot QEMU, agent, résultat.
+//! Running one target: image, disks, QEMU boot, agent, result.
 
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -15,23 +15,23 @@ use crate::metrics::Sampler;
 use crate::model::{Outcome, StageResult, TargetResult, VmSpec};
 use crate::qemu::{self, KernelBoot, Machine, Qmp, RunDir};
 
-/// Délai laissé à QEMU pour s'arrêter seul après la fin de l'agent.
+/// Time given to QEMU to stop on its own after the agent finishes.
 const SHUTDOWN_GRACE: Duration = Duration::from_secs(15);
-/// Taille de la fin de console gardée dans le résultat.
+/// Size of the console tail kept in the result.
 const CONSOLE_TAIL: usize = 16 * 1024;
 
 #[derive(Clone)]
 pub struct Runner {
     pub store: Store,
-    /// Binaire envprobe statique copié dans chaque invité.
+    /// Static envprobe binary copied into each guest.
     pub envprobe: PathBuf,
-    /// Boot direct sur le noyau extrait de l'image quand il est disponible.
+    /// Direct boot on the kernel extracted from the image, when available.
     pub direct_boot: bool,
-    /// Garder les répertoires d'exécution pour déboguer.
+    /// Keep the run directories for debugging.
     pub keep: bool,
 }
 
-/// Fin d'exécution demandée de l'extérieur.
+/// End of run requested from outside.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum Stop {
     Kill,
@@ -39,8 +39,8 @@ pub enum Stop {
 }
 
 impl Runner {
-    /// Lance une cible et renvoie son résultat ; ne panique jamais sur une
-    /// erreur d'environnement (image absente, QEMU qui ne démarre pas…).
+    /// Runs a target and returns its result; never panics on an environment
+    /// error (missing image, QEMU failing to start…).
     pub async fn run(
         &self,
         spec: &VmSpec,
@@ -78,8 +78,8 @@ impl Runner {
 
         let mut kernel = image.direct_kernel();
         if spec.kernel_cmdline.is_some() && kernel.is_none() {
-            // Le noyau doit être extrait une fois pour pouvoir modifier sa
-            // ligne de commande : boot de préparation sans étape utilisateur.
+            // The kernel must be extracted once before its command line can be
+            // changed: preparation boot with no user stage.
             let _guard = self
                 .store
                 .exclusive(&format!("{}#kernel", image.name))
@@ -98,9 +98,9 @@ impl Runner {
                 kernel = image.direct_kernel();
                 if kernel.is_none() {
                     return Err(format!(
-                        "noyau non extrait de {} : kernel_cmdline impossible ({})",
+                        "kernel not extracted from {}: kernel_cmdline impossible ({})",
                         image.file,
-                        prep.warnings.join(" ; ")
+                        prep.warnings.join("; ")
                     ));
                 }
             }
@@ -163,13 +163,13 @@ impl Runner {
         }
         fs::File::create(&output)
             .and_then(|f| f.set_len(guest::OUTPUT_DISK_BYTES))
-            .map_err(|e| format!("{} : {e}", output.display()))?;
+            .map_err(|e| format!("{}: {e}", output.display()))?;
 
         let cmdline;
         let kernel_boot = match &kernel {
             Some(k) => {
-                // L'attente de synchro NTP (Arch) bloque cloud-final ~40 s pour
-                // rien : l'horloge de la VM vient déjà de l'hôte.
+                // Waiting for NTP sync (Arch) blocks cloud-final for ~40 s for
+                // nothing: the VM clock already comes from the host.
                 cmdline = format!(
                     "{} console=ttyS0,115200 panic=-1 \
                      systemd.mask=systemd-time-wait-sync.service {}",
@@ -185,18 +185,18 @@ impl Runner {
             None => None,
         };
         result.direct_kernel = kernel_boot.is_some();
-        // Le boot direct se passe de firmware ; le boot disque des images
-        // UEFI demande OVMF et une copie de ses variables.
+        // Direct boot needs no firmware; booting UEFI images from disk needs
+        // OVMF and a copy of its variables.
         let vars = rd.path("efivars.fd");
         let ovmf = if image.uefi && kernel_boot.is_none() {
             let ovmf = qemu::find_ovmf().ok_or_else(|| {
                 format!(
-                    "{} démarre en UEFI : installez OVMF (edk2-ovmf) ou définissez \
-                     DISTROPROOF_OVMF_CODE et DISTROPROOF_OVMF_VARS",
+                    "{} boots with UEFI: install OVMF (edk2-ovmf) or set \
+                     DISTROPROOF_OVMF_CODE and DISTROPROOF_OVMF_VARS",
                     image.name
                 )
             })?;
-            fs::copy(&ovmf.vars, &vars).map_err(|e| format!("{} : {e}", ovmf.vars.display()))?;
+            fs::copy(&ovmf.vars, &vars).map_err(|e| format!("{}: {e}", ovmf.vars.display()))?;
             Some(ovmf)
         } else {
             None
@@ -224,10 +224,10 @@ impl Runner {
             .stderr(Stdio::piped())
             .kill_on_drop(true)
             .spawn()
-            .map_err(|e| format!("lancement de QEMU impossible : {e}"))?;
+            .map_err(|e| format!("cannot start QEMU: {e}"))?;
         let pid = child.id().unwrap_or(0);
         let stderr_task = {
-            let mut stderr = child.stderr.take().expect("stderr capturé");
+            let mut stderr = child.stderr.take().expect("stderr captured");
             tokio::spawn(async move {
                 let mut s = String::new();
                 let _ = (&mut stderr).take(64 * 1024).read_to_string(&mut s).await;
@@ -235,7 +235,7 @@ impl Runner {
             })
         };
 
-        // Connexion aux sockets pendant que la VM est en pause (-S).
+        // Connect to the sockets while the VM is paused (-S).
         let sockets = async {
             let qmp = Qmp::connect(&qmp_path).await?;
             let console = qemu::connect(&console_path, Duration::from_secs(5)).await?;
@@ -247,7 +247,7 @@ impl Runner {
             status = child.wait() => {
                 let err = stderr_task.await.unwrap_or_default();
                 return Err(format!(
-                    "QEMU s'est arrêté au démarrage ({}) : {}",
+                    "QEMU stopped during startup ({}): {}",
                     status.map(|s| s.to_string()).unwrap_or_default(),
                     err.trim()
                 ));
@@ -305,8 +305,8 @@ impl Runner {
                             match handle_agent_line(&line, ev, result, boot_start, &mut current_stage) {
                                 AgentMsg::Done => {
                                     done = true;
-                                    // Le disque de sortie est complet (sync) : on le lit
-                                    // sans attendre l'arrêt de la VM.
+                                    // The output disk is complete (sync): read it
+                                    // without waiting for the VM to stop.
                                     let res = read_output(&output).await;
                                     if let Ok(out) = &res {
                                         if extract_kernel {
@@ -372,7 +372,7 @@ impl Runner {
                         if let Some(at) = paused_at {
                             if qmp.execute("cont", None).await.is_ok() {
                                 paused_at = None;
-                                // Le temps passé en pause ne compte pas dans le timeout.
+                                // Time spent paused does not count toward the timeout.
                                 let next = deadline.deadline() + at.elapsed();
                                 deadline.as_mut().reset(next);
                                 ev.emit(VmEvent::Resumed);
@@ -390,7 +390,7 @@ impl Runner {
                     Some(Control::ConsoleInput(bytes)) => {
                         let _ = con_w.write_all(&bytes).await;
                     }
-                    // Plus aucun consommateur : Ctrl+C ou fin de la TUI.
+                    // No consumers left: Ctrl+C or the TUI exited.
                     None => {
                         stop = Some(Stop::Kill);
                         let _ = child.start_kill();
@@ -412,8 +412,8 @@ impl Runner {
         result.console_tail = tail_text(&console_tail, 60);
 
         if let Some(res) = collected {
-            // L'agent a fini : le résultat est acquis, même si la VM a été
-            // tuée ensuite (VM gardée avec --hold).
+            // The agent finished: the result stands, even if the VM was killed
+            // afterwards (VM kept up with --hold).
             res?;
             return Ok(BootEnd {
                 stop: stop.filter(|s| *s == Stop::Restart),
@@ -427,30 +427,30 @@ impl Runner {
         if timed_out {
             result.outcome = Outcome::TimedOut;
             let phase = match (result.boot_ms, current_stage) {
-                (None, _) => "pendant le boot".to_string(),
-                (Some(_), Some(stage)) => format!("pendant l'étape {}", stage.label()),
-                (Some(_), None) => "après le boot".to_string(),
+                (None, _) => "during boot".to_string(),
+                (Some(_), Some(stage)) => format!("during the {} stage", stage.label()),
+                (Some(_), None) => "after boot".to_string(),
             };
             result.error = Some(format!(
-                "timeout de {} {phase}",
+                "timed out after {} {phase}",
                 crate::config::format_duration(spec.timeout)
             ));
             return Ok(BootEnd::default());
         }
         if let Some(msg) = fatal {
-            return Err(format!("agent : {msg}"));
+            return Err(format!("agent: {msg}"));
         }
         let status = exit_status.map(|s| s.to_string()).unwrap_or_default();
         let detail = qemu_stderr.trim();
         Err(if result.boot_ms.is_none() {
-            format!("la VM s'est arrêtée sans que l'agent réponde ({status}) {detail}")
+            format!("the VM stopped before the agent answered ({status}) {detail}")
         } else {
-            format!("la VM s'est arrêtée avant la fin de l'agent ({status}) {detail}")
+            format!("the VM stopped before the agent finished ({status}) {detail}")
         })
     }
 }
 
-/// Fin d'un boot : arrêt demandé, et résultat déjà publié (VM gardée).
+/// End of a boot: requested stop, and result already published (VM kept up).
 #[derive(Debug, Default)]
 struct BootEnd {
     stop: Option<Stop>,
@@ -471,9 +471,9 @@ async fn read_output(path: &Path) -> Result<GuestOutput, String> {
     let out = tokio::task::spawn_blocking(move || GuestOutput::read(&path))
         .await
         .map_err(|e| e.to_string())?
-        .map_err(|e| format!("disque de sortie illisible : {e}"))?;
+        .map_err(|e| format!("output disk unreadable: {e}"))?;
     if out.is_empty() {
-        return Err("disque de sortie vide".into());
+        return Err("output disk empty".into());
     }
     Ok(out)
 }
@@ -491,8 +491,8 @@ fn handle_agent_line(
     boot_start: Instant,
     current: &mut Option<Stage>,
 ) -> AgentMsg {
-    // Le firmware (OVMF) écrit aussi sur COM2 avant l'agent : un message de
-    // contrôle peut arriver précédé d'octets parasites.
+    // The firmware (OVMF) also writes to COM2 before the agent: a control
+    // message can arrive preceded by stray bytes.
     let line = match line.find("@ ") {
         Some(i) if i > 0 && !line.starts_with("> ") && !line.starts_with("! ") => &line[i..],
         _ => line,
@@ -543,7 +543,7 @@ fn handle_agent_line(
             }
             "WARN" => {
                 result.warnings.push(rest.to_string());
-                ev.info(format!("invité : {rest}"));
+                ev.info(format!("guest: {rest}"));
             }
             "DONE" => return AgentMsg::Done,
             "FATAL" => return AgentMsg::Fatal(rest.to_string()),
@@ -569,7 +569,7 @@ fn collect(out: &GuestOutput, spec: &VmSpec, prepare_only: bool, result: &mut Ta
         match serde_json::from_slice(json) {
             Ok(report) => result.envprobe = Some(report),
             Err(e) => result.warnings.push(format!(
-                "rapport envprobe illisible : {e} ({})",
+                "envprobe report unreadable: {e} ({})",
                 out.text("envprobe.err").unwrap_or_default().trim()
             )),
         }
@@ -581,7 +581,7 @@ fn collect(out: &GuestOutput, spec: &VmSpec, prepare_only: bool, result: &mut Ta
     result.outcome = match (&result.command, setup_failed) {
         (_, true) => {
             result.error = Some(format!(
-                "setup en échec (code {})",
+                "setup failed (code {})",
                 result
                     .setup
                     .as_ref()
@@ -596,7 +596,7 @@ fn collect(out: &GuestOutput, spec: &VmSpec, prepare_only: bool, result: &mut Ta
     };
 }
 
-/// Range noyau et initramfs extraits par l'agent, de façon atomique.
+/// Stores the kernel and initramfs extracted by the agent, atomically.
 fn save_kernel(out: &GuestOutput, dir: &Path, ev: &Emitter) {
     let (Some(kernel), Some(cmdline)) = (out.get("kernel/vmlinuz"), out.get("kernel/cmdline"))
     else {
@@ -620,17 +620,17 @@ fn save_kernel(out: &GuestOutput, dir: &Path, ev: &Emitter) {
     })();
     match res {
         Ok(()) => ev.info(format!(
-            "noyau extrait ({}), boot direct aux prochaines exécutions",
+            "kernel extracted ({}), direct boot on the next runs",
             images::clean_cmdline(&String::from_utf8_lossy(cmdline))
         )),
         Err(e) => {
             let _ = fs::remove_dir_all(&tmp);
-            ev.info(format!("noyau extrait non sauvegardé : {e}"));
+            ev.info(format!("extracted kernel not saved: {e}"));
         }
     }
 }
 
-/// Dernières lignes de la console, sans séquences d'échappement.
+/// Last lines of the console, without escape sequences.
 pub fn tail_text(bytes: &[u8], lines: usize) -> String {
     let text = strip_ansi(&String::from_utf8_lossy(bytes));
     let all: Vec<&str> = text
diff --git a/crates/envprobe-core/Cargo.toml b/crates/envprobe-core/Cargo.toml
index 6ab7dda..ed8d622 100644
--- a/crates/envprobe-core/Cargo.toml
+++ b/crates/envprobe-core/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "envprobe-core"
-description = "Sondes d'environnement Linux (userspace + kernel)"
+description = "Linux environment probes (userspace + kernel)"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
diff --git a/crates/envprobe-core/src/diff.rs b/crates/envprobe-core/src/diff.rs
index c12566b..861bb37 100644
--- a/crates/envprobe-core/src/diff.rs
+++ b/crates/envprobe-core/src/diff.rs
@@ -1,15 +1,15 @@
-//! Différences entre deux rapports.
+//! Differences between two reports.
 
 use crate::{Report, Section, Value};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Change {
-    /// Clé présente seulement dans le second rapport.
+    /// Key present only in the second report.
     Added {
         key: String,
         value: Value,
     },
-    /// Clé présente seulement dans le premier rapport.
+    /// Key present only in the first report.
     Removed {
         key: String,
         value: Value,
@@ -47,8 +47,8 @@ impl SectionDiff {
     }
 }
 
-/// Sections qui diffèrent, dans l'ordre du premier rapport puis du second.
-/// Le marqueur `privileged` n'est pas comparé : seule la valeur compte.
+/// Sections that differ, in the order of the first report then the second.
+/// The `privileged` flag is not compared: only the value matters.
 pub fn diff(a: &Report, b: &Report) -> Vec<SectionDiff> {
     let mut out = Vec::new();
     for sa in &a.sections {
diff --git a/crates/envprobe-core/src/lib.rs b/crates/envprobe-core/src/lib.rs
index 8a65c4b..17fb4f7 100644
--- a/crates/envprobe-core/src/lib.rs
+++ b/crates/envprobe-core/src/lib.rs
@@ -1,8 +1,8 @@
-//! Sondes d'environnement Linux.
+//! Linux environment probes.
 //!
-//! Chaque catégorie est un module de [`probes`] exposant `probe() -> Section`.
-//! Une sonde ne plante jamais : une information absente ou refusée devient une
-//! [`Value::Unavailable`] ou une [`Value::Denied`] avec sa raison.
+//! Each category is a [`probes`] module exposing `probe() -> Section`.
+//! A probe never crashes: missing or denied information becomes a
+//! [`Value::Unavailable`] or a [`Value::Denied`] with its reason.
 
 pub mod diff;
 pub mod parse;
@@ -16,19 +16,19 @@ use std::panic;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-/// Version du format du rapport JSON. À incrémenter à chaque changement
-/// incompatible (clé renommée, statut ajouté…).
+/// Version of the JSON report format. Bump it on every incompatible change
+/// (renamed key, added status…).
 pub const SCHEMA_VERSION: u32 = 1;
 
-/// Résultat d'une sonde élémentaire.
+/// Result of an elementary probe.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 #[serde(tag = "status", content = "value", rename_all = "snake_case")]
 pub enum Value {
-    /// Valeur obtenue.
+    /// Value obtained.
     Ok(String),
-    /// Information absente ou impossible à obtenir (fichier absent, syscall inexistant…) ; contient la raison.
+    /// Information missing or impossible to obtain (missing file, nonexistent syscall…); holds the reason.
     Unavailable(String),
-    /// Accès refusé (EPERM, EACCES, seccomp…) ; contient l'errno et le contexte.
+    /// Access denied (EPERM, EACCES, seccomp…); holds the errno and the context.
     Denied(String),
 }
 
@@ -57,23 +57,23 @@ impl fmt::Display for Value {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             Value::Ok(v) => f.write_str(v),
-            Value::Unavailable(reason) => write!(f, "indisponible ({reason})"),
-            Value::Denied(reason) => write!(f, "refusé ({reason})"),
+            Value::Unavailable(reason) => write!(f, "unavailable ({reason})"),
+            Value::Denied(reason) => write!(f, "denied ({reason})"),
         }
     }
 }
 
-/// Une information du rapport.
+/// One piece of information in the report.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub struct Entry {
     pub key: String,
     #[serde(flatten)]
     pub value: Value,
-    /// Le résultat change selon les privilèges du processus (root, capabilities).
+    /// The result depends on the process's privileges (root, capabilities).
     pub privileged: bool,
 }
 
-/// Une catégorie du rapport, par exemple « kernel » ou « bpf ».
+/// A report category, for example "kernel" or "bpf".
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub struct Section {
     pub name: String,
@@ -109,7 +109,7 @@ impl Section {
     }
 }
 
-/// Rapport complet, tel qu'écrit par `envprobe --json`.
+/// Full report, as written by `envprobe --json`.
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, JsonSchema)]
 pub struct Report {
     pub schema_version: u32,
@@ -123,13 +123,13 @@ impl Report {
     }
 }
 
-/// Noms des sections, dans l'ordre du rapport.
+/// Section names, in report order.
 pub fn section_names() -> impl Iterator<Item = &'static str> {
     probes::ALL.iter().map(|(name, _)| *name)
 }
 
-/// Exécute les sondes demandées (toutes si `only` est vide). Une sonde qui
-/// panique est remplacée par une section contenant l'erreur, les autres continuent.
+/// Runs the requested probes (all of them if `only` is empty). A probe that
+/// panics is replaced by a section holding the error; the others go on.
 pub fn probe(only: &[&str]) -> Report {
     let sections = probes::ALL
         .iter()
@@ -140,12 +140,9 @@ pub fn probe(only: &[&str]) -> Report {
                     .downcast_ref::<&str>()
                     .map(|s| s.to_string())
                     .or_else(|| payload.downcast_ref::<String>().cloned())
-                    .unwrap_or_else(|| "panique".to_string());
+                    .unwrap_or_else(|| "panic".to_string());
                 let mut section = Section::new(*name);
-                section.push(
-                    "error",
-                    Value::unavailable(format!("sonde en échec : {msg}")),
-                );
+                section.push("error", Value::unavailable(format!("probe failed: {msg}")));
                 section
             })
         })
@@ -157,12 +154,12 @@ pub fn probe(only: &[&str]) -> Report {
     }
 }
 
-/// Exécute toutes les sondes.
+/// Runs every probe.
 pub fn probe_all() -> Vec<Section> {
     probe(&[]).sections
 }
 
-/// Schéma JSON du rapport.
+/// JSON schema of the report.
 pub fn json_schema() -> serde_json::Value {
-    serde_json::to_value(schemars::schema_for!(Report)).expect("schéma sérialisable")
+    serde_json::to_value(schemars::schema_for!(Report)).expect("serializable schema")
 }
diff --git a/crates/envprobe-core/src/parse/elf.rs b/crates/envprobe-core/src/parse/elf.rs
index 9e9726e..ad3b71c 100644
--- a/crates/envprobe-core/src/parse/elf.rs
+++ b/crates/envprobe-core/src/parse/elf.rs
@@ -1,4 +1,4 @@
-//! Lecture minimale d'un en-tête ELF : interpréteur (`PT_INTERP`).
+//! Minimal ELF header reader: the interpreter (`PT_INTERP`).
 
 const PT_INTERP: u32 = 3;
 
@@ -40,7 +40,7 @@ impl Reader<'_> {
     }
 }
 
-/// Chemin de l'interpréteur dynamique, `None` pour un binaire statique ou un fichier non ELF.
+/// Path of the dynamic interpreter, `None` for a static binary or a non-ELF file.
 pub fn interpreter(data: &[u8]) -> Option<String> {
     if data.get(..4)? != b"\x7fELF" {
         return None;
@@ -84,7 +84,7 @@ pub fn interpreter(data: &[u8]) -> Option<String> {
 mod tests {
     use super::*;
 
-    /// ELF64 little-endian avec un seul en-tête de programme PT_INTERP.
+    /// Little-endian ELF64 with a single PT_INTERP program header.
     fn elf64(interp: Option<&str>) -> Vec<u8> {
         let mut d = vec![0u8; 64 + 56];
         d[..4].copy_from_slice(b"\x7fELF");
diff --git a/crates/envprobe-core/src/parse/kconfig.rs b/crates/envprobe-core/src/parse/kconfig.rs
index 3f4046e..5c39063 100644
--- a/crates/envprobe-core/src/parse/kconfig.rs
+++ b/crates/envprobe-core/src/parse/kconfig.rs
@@ -1,11 +1,11 @@
-//! Configuration du noyau (`/proc/config.gz`, `/boot/config-*`).
+//! Kernel configuration (`/proc/config.gz`, `/boot/config-*`).
 
 use std::collections::BTreeMap;
 use std::io::{self, Read};
 
 use flate2::read::GzDecoder;
 
-/// Associe chaque option à sa valeur ; `# CONFIG_X is not set` donne `n`.
+/// Maps each option to its value; `# CONFIG_X is not set` gives `n`.
 pub fn parse(text: &str) -> BTreeMap<String, String> {
     let mut map = BTreeMap::new();
     for line in text.lines() {
diff --git a/crates/envprobe-core/src/parse/ldconfig.rs b/crates/envprobe-core/src/parse/ldconfig.rs
index 19cd52a..a3b8aec 100644
--- a/crates/envprobe-core/src/parse/ldconfig.rs
+++ b/crates/envprobe-core/src/parse/ldconfig.rs
@@ -1,6 +1,6 @@
-//! Sortie de `ldconfig -p`.
+//! Output of `ldconfig -p`.
 
-/// Paires (soname, chemin) dans l'ordre de la sortie.
+/// (soname, path) pairs in output order.
 pub fn parse(text: &str) -> Vec<(String, String)> {
     text.lines()
         .filter_map(|line| {
diff --git a/crates/envprobe-core/src/parse/libc_version.rs b/crates/envprobe-core/src/parse/libc_version.rs
index f2f3306..edc5c11 100644
--- a/crates/envprobe-core/src/parse/libc_version.rs
+++ b/crates/envprobe-core/src/parse/libc_version.rs
@@ -1,6 +1,6 @@
-//! Version de la libc sans l'exécuter.
+//! libc version, without running it.
 
-/// Cherche « release version X.Y » dans le binaire `libc.so.6` de glibc.
+/// Looks for "release version X.Y" in glibc's `libc.so.6` binary.
 pub fn glibc_version(data: &[u8]) -> Option<String> {
     let marker = b"release version ";
     let pos = data.windows(marker.len()).position(|w| w == marker)? + marker.len();
@@ -13,7 +13,7 @@ pub fn glibc_version(data: &[u8]) -> Option<String> {
     (!version.is_empty()).then(|| version.to_string())
 }
 
-/// Version du paquet `musl` dans la base apk (`/lib/apk/db/installed`).
+/// Version of the `musl` package in the apk database (`/lib/apk/db/installed`).
 pub fn musl_version_from_apk(db: &str) -> Option<String> {
     db.split("\n\n").find_map(|block| {
         let mut lines = block.lines();
diff --git a/crates/envprobe-core/src/parse/mod.rs b/crates/envprobe-core/src/parse/mod.rs
index a32559d..5c39f4a 100644
--- a/crates/envprobe-core/src/parse/mod.rs
+++ b/crates/envprobe-core/src/parse/mod.rs
@@ -1,4 +1,4 @@
-//! Parseurs purs, sans accès au système, testés sur des fixtures.
+//! Pure parsers, with no system access, tested on fixtures.
 
 pub mod elf;
 pub mod kconfig;
@@ -8,7 +8,7 @@ pub mod mounts;
 pub mod os_release;
 pub mod status;
 
-/// Extrait la valeur active d'une liste du type `none [integrity] confidentiality`.
+/// Extracts the active value from a list like `none [integrity] confidentiality`.
 pub fn bracketed(s: &str) -> Option<&str> {
     let start = s.find('[')? + 1;
     let end = start + s[start..].find(']')?;
diff --git a/crates/envprobe-core/src/parse/mounts.rs b/crates/envprobe-core/src/parse/mounts.rs
index e522166..a92f619 100644
--- a/crates/envprobe-core/src/parse/mounts.rs
+++ b/crates/envprobe-core/src/parse/mounts.rs
@@ -22,7 +22,7 @@ pub fn parse(text: &str) -> Vec<Mount> {
         .collect()
 }
 
-/// Le noyau encode espaces, tabulations et `\` en octal (`\040`).
+/// The kernel encodes spaces, tabs and `\` in octal (`\040`).
 fn unescape(s: &str) -> String {
     let bytes = s.as_bytes();
     let mut out = Vec::with_capacity(bytes.len());
diff --git a/crates/envprobe-core/src/parse/os_release.rs b/crates/envprobe-core/src/parse/os_release.rs
index 196174d..15b4b0f 100644
--- a/crates/envprobe-core/src/parse/os_release.rs
+++ b/crates/envprobe-core/src/parse/os_release.rs
@@ -1,4 +1,4 @@
-//! `/etc/os-release` (format décrit dans os-release(5)).
+//! `/etc/os-release` (format described in os-release(5)).
 
 use std::collections::BTreeMap;
 
diff --git a/crates/envprobe-core/src/parse/status.rs b/crates/envprobe-core/src/parse/status.rs
index aefa5a0..7829b5b 100644
--- a/crates/envprobe-core/src/parse/status.rs
+++ b/crates/envprobe-core/src/parse/status.rs
@@ -20,7 +20,7 @@ impl Status {
         self.fields.get(key).map(String::as_str)
     }
 
-    /// Identifiants réel, effectif, sauvegardé et fs (ligne `Uid:`).
+    /// Real, effective, saved and fs IDs (`Uid:` line).
     pub fn uids(&self) -> Option<[u32; 4]> {
         ids(self.get("Uid")?)
     }
@@ -33,7 +33,7 @@ impl Status {
         u64::from_str_radix(self.get("CapEff")?, 16).ok()
     }
 
-    /// 0 : désactivé, 1 : strict, 2 : filtre.
+    /// 0: disabled, 1: strict, 2: filter.
     pub fn seccomp(&self) -> Option<u32> {
         self.get("Seccomp")?.parse().ok()
     }
@@ -52,7 +52,7 @@ fn ids(value: &str) -> Option<[u32; 4]> {
     Some(out)
 }
 
-/// `/proc/<pid>/uid_map` du user namespace initial : `0 0 4294967295`.
+/// `/proc/<pid>/uid_map` of the initial user namespace: `0 0 4294967295`.
 pub fn is_initial_uid_map(map: &str) -> bool {
     let lines: Vec<Vec<&str>> = map
         .lines()
diff --git a/crates/envprobe-core/src/probes/bpf.rs b/crates/envprobe-core/src/probes/bpf.rs
index 2901bd8..b596a3a 100644
--- a/crates/envprobe-core/src/probes/bpf.rs
+++ b/crates/envprobe-core/src/probes/bpf.rs
@@ -1,6 +1,6 @@
-//! Types de programmes, types de maps et helpers BPF, sondés par des appels
-//! `bpf()` minimaux (équivalent de `bpftool feature probe`, sans libbpf).
-//! Chaque objet créé est fermé immédiatement : rien ne reste chargé.
+//! BPF program types, map types and helpers, probed with minimal `bpf()`
+//! calls (the equivalent of `bpftool feature probe`, without libbpf).
+//! Every object created is closed immediately: nothing stays loaded.
 
 use crate::probes::kernel;
 use crate::sys::{self, BpfInsn, MapCreate, ProgLoad};
@@ -11,7 +11,7 @@ const BPF_F_NO_PREALLOC: u32 = 1;
 const BPF_F_SLEEPABLE: u32 = 1 << 4;
 const PROG_KPROBE: u32 = 2;
 
-/// (nom, type, expected_attach_type, prog_flags)
+/// (name, type, expected_attach_type, prog_flags)
 const PROG_TYPES: &[(&str, u32, u32, u32)] = &[
     ("socket_filter", 1, 0, 0),
     ("kprobe", PROG_KPROBE, 0, 0),
@@ -47,10 +47,10 @@ const PROG_TYPES: &[(&str, u32, u32, u32)] = &[
     ("netfilter", 32, 45, 0),
 ];
 
-/// Types qui exigent une cible BTF (fonction à attacher) pour être chargés.
+/// Types that need a BTF target (a function to attach to) to be loaded.
 const PROG_TYPES_BTF: &[&str] = &["tracing", "struct_ops", "ext", "lsm"];
 
-/// (nom, type, key_size, value_size, max_entries, flags) ; max_entries 0 = taille de page.
+/// (name, type, key_size, value_size, max_entries, flags); max_entries 0 = page size.
 const MAP_TYPES: &[(&str, u32, u32, u32, u32, u32)] = &[
     ("hash", 1, 4, 8, 1, 0),
     ("array", 2, 4, 8, 1, 0),
@@ -76,7 +76,7 @@ const MAP_TYPES: &[(&str, u32, u32, u32, u32, u32)] = &[
     ("user_ringbuf", 31, 0, 0, 0, 0),
 ];
 
-/// Helpers utiles au tracing, testés dans un programme kprobe.
+/// Helpers useful for tracing, tested in a kprobe program.
 const HELPERS: &[(&str, i32)] = &[
     ("ktime_get_ns", 5),
     ("trace_printk", 6),
@@ -103,19 +103,19 @@ pub fn probe() -> Section {
         .unwrap_or(0);
     let trivial = [BpfInsn::mov_r0(0), BpfInsn::exit()];
 
-    // Premier appel : le syscall existe-t-il seulement ?
+    // First call: does the syscall even exist?
     let syscall = load(1, 0, 0, kern_version, &trivial, None);
     if syscall == Err(libc::ENOSYS) {
         s.push(
             "syscall",
-            Value::unavailable("ENOSYS : bpf() absent (CONFIG_BPF_SYSCALL)"),
+            Value::unavailable("ENOSYS: bpf() missing (CONFIG_BPF_SYSCALL)"),
         );
         return s;
     }
     s.push_privileged(
         "syscall",
         match syscall {
-            Ok(()) => Value::ok("disponible"),
+            Ok(()) => Value::ok("available"),
             Err(e) => util::errno_value(e),
         },
     );
@@ -136,7 +136,7 @@ pub fn probe() -> Section {
     for name in PROG_TYPES_BTF {
         s.push(
             format!("prog.{name}"),
-            Value::unavailable("non sondé : nécessite une cible BTF"),
+            Value::unavailable("not probed: needs a BTF target"),
         );
     }
 
@@ -186,15 +186,15 @@ fn log_text(log: &[u8]) -> String {
     String::from_utf8_lossy(&log[..end]).into_owned()
 }
 
-/// Convention de bpftool : EINVAL / EOPNOTSUPP / E2BIG signifient « type inconnu ».
+/// bpftool convention: EINVAL / EOPNOTSUPP / E2BIG mean "unknown type".
 fn unsupported(errno: i32) -> bool {
     matches!(errno, libc::EINVAL | libc::EOPNOTSUPP | libc::E2BIG | 524)
 }
 
 fn interpret_simple(res: Result<(), i32>) -> Value {
     match res {
-        Ok(()) => Value::ok("supporté"),
-        Err(e) if unsupported(e) => Value::ok(format!("non supporté ({})", errno_name(e))),
+        Ok(()) => Value::ok("supported"),
+        Err(e) if unsupported(e) => Value::ok(format!("unsupported ({})", errno_name(e))),
         Err(e) => util::errno_value(e),
     }
 }
@@ -205,7 +205,7 @@ fn interpret_prog(res: Result<(), i32>, log: &[u8]) -> Value {
             let text = log_text(log);
             match text.lines().rev().find(|l| !l.trim().is_empty()) {
                 Some(line) => {
-                    Value::unavailable(format!("rejeté par le vérificateur : {}", line.trim()))
+                    Value::unavailable(format!("rejected by the verifier: {}", line.trim()))
                 }
                 None => Value::denied("EACCES"),
             }
@@ -222,19 +222,19 @@ fn interpret_helper(res: Result<(), i32>, log: &[u8]) -> Value {
         "program of this type cannot use helper ",
     ];
     match res {
-        Ok(()) => Value::ok("supporté"),
-        Err(_) if missing.iter().any(|m| text.contains(m)) => Value::ok("non supporté"),
-        // Le vérificateur a dépassé l'appel du helper avant de rejeter le programme.
-        Err(_) if !text.trim().is_empty() => Value::ok("supporté"),
+        Ok(()) => Value::ok("supported"),
+        Err(_) if missing.iter().any(|m| text.contains(m)) => Value::ok("unsupported"),
+        // The verifier got past the helper call before rejecting the program.
+        Err(_) if !text.trim().is_empty() => Value::ok("supported"),
         Err(e) => util::errno_value(e),
     }
 }
 
 fn jit() -> Value {
     match util::read_trimmed("/proc/sys/net/core/bpf_jit_enable") {
-        Ok(v) if v == "0" => Value::ok("désactivé"),
-        Ok(v) if v == "1" => Value::ok("activé"),
-        Ok(v) if v == "2" => Value::ok("activé (debug)"),
+        Ok(v) if v == "0" => Value::ok("disabled"),
+        Ok(v) if v == "1" => Value::ok("enabled"),
+        Ok(v) if v == "2" => Value::ok("enabled (debug)"),
         Ok(v) => Value::ok(v),
         Err(v) => v,
     }
@@ -252,20 +252,20 @@ mod tests {
 
     #[test]
     fn helper_interpretation() {
-        assert_eq!(interpret_helper(Ok(()), &[0]), Value::ok("supporté"));
+        assert_eq!(interpret_helper(Ok(()), &[0]), Value::ok("supported"));
         assert_eq!(
             interpret_helper(
                 Err(libc::EINVAL),
                 &log("0: (85) call unknown#999\ninvalid func unknown#999\n")
             ),
-            Value::ok("non supporté")
+            Value::ok("unsupported")
         );
         assert_eq!(
             interpret_helper(
                 Err(libc::EACCES),
                 &log("0: (85) call bpf_probe_read_kernel#113\nR1 !read_ok\n")
             ),
-            Value::ok("supporté")
+            Value::ok("supported")
         );
         assert_eq!(
             interpret_helper(Err(libc::EPERM), &[0]),
@@ -277,7 +277,7 @@ mod tests {
     fn prog_interpretation() {
         assert_eq!(
             interpret_prog(Err(libc::EINVAL), &[0]),
-            Value::ok("non supporté (EINVAL)")
+            Value::ok("unsupported (EINVAL)")
         );
         assert_eq!(
             interpret_prog(Err(libc::EPERM), &[0]),
diff --git a/crates/envprobe-core/src/probes/btf.rs b/crates/envprobe-core/src/probes/btf.rs
index 941b9d9..ea1b674 100644
--- a/crates/envprobe-core/src/probes/btf.rs
+++ b/crates/envprobe-core/src/probes/btf.rs
@@ -1,4 +1,4 @@
-//! BTF du noyau et des modules.
+//! Kernel and module BTF.
 
 use std::fs;
 use std::path::Path;
@@ -11,7 +11,7 @@ pub fn probe() -> Section {
     s.push(
         "vmlinux",
         match fs::metadata(vmlinux) {
-            Ok(m) => Value::ok(format!("présent, {} octets", m.len())),
+            Ok(m) => Value::ok(format!("present, {} bytes", m.len())),
             Err(e) => util::io_value(&e, vmlinux),
         },
     );
diff --git a/crates/envprobe-core/src/probes/cgroups.rs b/crates/envprobe-core/src/probes/cgroups.rs
index a3b394f..f248f80 100644
--- a/crates/envprobe-core/src/probes/cgroups.rs
+++ b/crates/envprobe-core/src/probes/cgroups.rs
@@ -1,4 +1,4 @@
-//! Version des cgroups.
+//! cgroups version.
 
 use crate::probes::tracing::read_mounts;
 use crate::{util, Section, Value};
@@ -13,15 +13,15 @@ pub fn probe() -> Section {
             let v2_any = mounts.iter().any(|m| m.fstype == "cgroup2");
             let v1 = mounts.iter().any(|m| m.fstype == "cgroup");
             let mode = if v1 && v2_any {
-                Value::ok("hybride")
+                Value::ok("hybrid")
             } else if v2_root {
                 Value::ok("v2")
             } else if v2_any {
-                Value::ok("v2 (hors /sys/fs/cgroup)")
+                Value::ok("v2 (outside /sys/fs/cgroup)")
             } else if v1 {
                 Value::ok("v1")
             } else {
-                Value::unavailable("aucun cgroup monté")
+                Value::unavailable("no cgroup mounted")
             };
             s.push("mode", mode);
         }
diff --git a/crates/envprobe-core/src/probes/clib.rs b/crates/envprobe-core/src/probes/clib.rs
index 95eca54..7b26bef 100644
--- a/crates/envprobe-core/src/probes/clib.rs
+++ b/crates/envprobe-core/src/probes/clib.rs
@@ -1,7 +1,8 @@
-//! libc du système : glibc ou musl, et sa version.
+//! System libc: glibc or musl, and its version.
 //!
-//! La sonde est elle-même liée statiquement à musl, `gnu_get_libc_version()`
-//! n'est donc jamais disponible : on lit l'interpréteur ELF de `/bin/sh`.
+//! The probe itself is statically linked against musl, so
+//! `gnu_get_libc_version()` is never available: we read the ELF interpreter
+//! of `/bin/sh` instead.
 
 use std::fs;
 use std::path::Path;
@@ -23,12 +24,12 @@ pub fn probe() -> Section {
         }
     };
     let Some(interp) = interp else {
-        s.push("interpreter", Value::ok("aucun (/bin/sh statique)"));
+        s.push("interpreter", Value::ok("none (static /bin/sh)"));
         s.push(
             "kind",
-            Value::unavailable("/bin/sh statique, libc non déterminable"),
+            Value::unavailable("static /bin/sh, libc cannot be determined"),
         );
-        s.push("version", Value::unavailable("/bin/sh statique"));
+        s.push("version", Value::unavailable("static /bin/sh"));
         return s;
     };
     s.push("interpreter", Value::ok(interp.as_str()));
@@ -39,8 +40,10 @@ pub fn probe() -> Section {
             match fs::read_to_string("/lib/apk/db/installed") {
                 Ok(db) => libc_version::musl_version_from_apk(&db)
                     .map(Value::ok)
-                    .unwrap_or_else(|| Value::unavailable("paquet musl absent de la base apk")),
-                Err(_) => Value::unavailable("pas de base apk pour lire la version de musl"),
+                    .unwrap_or_else(|| {
+                        Value::unavailable("musl package missing from the apk database")
+                    }),
+                Err(_) => Value::unavailable("no apk database to read the musl version from"),
             },
         );
     } else if interp.contains("ld-linux") || interp.contains("ld64.so") {
@@ -49,9 +52,9 @@ pub fn probe() -> Section {
     } else {
         s.push(
             "kind",
-            Value::unavailable(format!("interpréteur inconnu : {interp}")),
+            Value::unavailable(format!("unknown interpreter: {interp}")),
         );
-        s.push("version", Value::unavailable("libc inconnue"));
+        s.push("version", Value::unavailable("unknown libc"));
     }
     s
 }
@@ -79,5 +82,5 @@ fn glibc_version(interp: &str) -> Value {
             }
         }
     }
-    Value::unavailable("libc.so.6 introuvable ou sans chaîne de version")
+    Value::unavailable("libc.so.6 not found or without a version string")
 }
diff --git a/crates/envprobe-core/src/probes/fhs.rs b/crates/envprobe-core/src/probes/fhs.rs
index 9de9595..ef10ec3 100644
--- a/crates/envprobe-core/src/probes/fhs.rs
+++ b/crates/envprobe-core/src/probes/fhs.rs
@@ -1,4 +1,4 @@
-//! Arborescence : merged-usr, /lib64, multiarch Debian.
+//! Filesystem layout: merged-usr, /lib64, Debian multiarch.
 
 use std::fs;
 use std::path::Path;
@@ -17,7 +17,7 @@ pub fn probe() -> Section {
                 }
                 Value::ok(format!("→ {target}"))
             }
-            Err(_) if Path::new(dir).is_dir() => Value::ok("répertoire"),
+            Err(_) if Path::new(dir).is_dir() => Value::ok("directory"),
             Err(e) => util::io_value(&e, Path::new(dir)),
         };
         s.push(dir, value);
@@ -25,16 +25,16 @@ pub fn probe() -> Section {
     s.push(
         "merged_usr",
         Value::ok(match merged {
-            3 => "oui",
-            0 => "non",
-            _ => "partiel",
+            3 => "yes",
+            0 => "no",
+            _ => "partial",
         }),
     );
     s.push(
         "/lib64",
         match fs::read_link("/lib64") {
             Ok(target) => Value::ok(format!("→ {}", target.display())),
-            Err(_) if Path::new("/lib64").is_dir() => Value::ok("répertoire"),
+            Err(_) if Path::new("/lib64").is_dir() => Value::ok("directory"),
             Err(_) => Value::ok("absent"),
         },
     );
@@ -42,9 +42,9 @@ pub fn probe() -> Section {
     s.push(
         "multiarch",
         Value::ok(if Path::new(&multiarch).is_dir() {
-            format!("oui ({multiarch})")
+            format!("yes ({multiarch})")
         } else {
-            "non".to_string()
+            "no".to_string()
         }),
     );
     let lib_dirs: Vec<String> = [
diff --git a/crates/envprobe-core/src/probes/identity.rs b/crates/envprobe-core/src/probes/identity.rs
index 348065d..d448174 100644
--- a/crates/envprobe-core/src/probes/identity.rs
+++ b/crates/envprobe-core/src/probes/identity.rs
@@ -1,4 +1,4 @@
-//! Distro, architecture, virtualisation, conteneur.
+//! Distro, architecture, virtualization, container.
 
 use std::collections::BTreeMap;
 use std::fs;
@@ -24,7 +24,7 @@ pub fn probe() -> Section {
                 let value = map
                     .get(field)
                     .map(|v| Value::ok(v.as_str()))
-                    .unwrap_or_else(|| Value::unavailable(format!("{field} non défini")));
+                    .unwrap_or_else(|| Value::unavailable(format!("{field} not set")));
                 s.push(key, value);
             }
         }
@@ -39,7 +39,7 @@ pub fn probe() -> Section {
         "arch",
         match sys::uname() {
             Ok(u) => Value::ok(u.machine),
-            Err(e) => Value::unavailable(format!("uname : {e}")),
+            Err(e) => Value::unavailable(format!("uname: {e}")),
         },
     );
     s.push("virtualization", detect_virt());
@@ -48,7 +48,7 @@ pub fn probe() -> Section {
 }
 
 fn read_os_release() -> Result<(&'static str, BTreeMap<String, String>), Value> {
-    let mut last = Value::unavailable("os-release absent");
+    let mut last = Value::unavailable("os-release missing");
     for path in OS_RELEASE {
         match fs::read_to_string(path) {
             Ok(text) => return Ok((path, os_release::parse(&text))),
@@ -100,10 +100,10 @@ fn detect_virt() -> Value {
             .filter(|l| l.starts_with("flags"))
             .any(|l| l.split_whitespace().any(|f| f == "hypervisor"));
         if flagged {
-            return Value::ok("hyperviseur inconnu (flag cpuinfo hypervisor)");
+            return Value::ok("unknown hypervisor (cpuinfo hypervisor flag)");
         }
     }
-    Value::ok("non détectée")
+    Value::ok("none detected")
 }
 
 fn detect_container() -> Value {
@@ -131,7 +131,7 @@ fn detect_container() -> Value {
         }
     }
     if let Ok(kind) = std::env::var("container") {
-        return Value::ok(format!("{kind} (variable container)"));
+        return Value::ok(format!("{kind} (container variable)"));
     }
-    Value::ok("aucun détecté")
+    Value::ok("none detected")
 }
diff --git a/crates/envprobe-core/src/probes/init.rs b/crates/envprobe-core/src/probes/init.rs
index de9cb21..18af95f 100644
--- a/crates/envprobe-core/src/probes/init.rs
+++ b/crates/envprobe-core/src/probes/init.rs
@@ -30,10 +30,10 @@ fn classify(comm: &str) -> Value {
         "runit" | "runit-init" => "runit",
         "s6-svscan" => "s6",
         "dinit" => "dinit",
-        "tini" | "docker-init" => "tini (conteneur)",
-        "dumb-init" => "dumb-init (conteneur)",
-        "init" => "init (sysvinit, busybox ou openrc)",
-        _ => return Value::ok(format!("autre ({comm})")),
+        "tini" | "docker-init" => "tini (container)",
+        "dumb-init" => "dumb-init (container)",
+        "init" => "init (sysvinit, busybox or openrc)",
+        _ => return Value::ok(format!("other ({comm})")),
     };
     Value::ok(kind)
 }
diff --git a/crates/envprobe-core/src/probes/kernel.rs b/crates/envprobe-core/src/probes/kernel.rs
index 29b1557..d6c8379 100644
--- a/crates/envprobe-core/src/probes/kernel.rs
+++ b/crates/envprobe-core/src/probes/kernel.rs
@@ -1,4 +1,4 @@
-//! Version, ligne de commande et configuration du noyau.
+//! Kernel version, command line and configuration.
 
 use std::collections::BTreeMap;
 use std::fs;
@@ -30,7 +30,7 @@ pub fn probe() -> Section {
             s.push("version", Value::ok(u.version.as_str()));
         }
         Err(e) => {
-            let v = Value::unavailable(format!("uname : {e}"));
+            let v = Value::unavailable(format!("uname: {e}"));
             s.push("release", v.clone());
             s.push("version", v);
         }
@@ -44,7 +44,7 @@ pub fn probe() -> Section {
                 let value = config
                     .get(*key)
                     .map(|v| Value::ok(v.as_str()))
-                    .unwrap_or_else(|| Value::ok("absente de la config"));
+                    .unwrap_or_else(|| Value::ok("not in the config"));
                 s.push(*key, value);
             }
         }
@@ -58,7 +58,7 @@ pub fn probe() -> Section {
     s
 }
 
-/// Configuration du noyau courant : `/proc/config.gz`, puis les emplacements des distros.
+/// Configuration of the running kernel: `/proc/config.gz`, then the distro locations.
 pub(crate) fn load_config(
     release: Option<&str>,
 ) -> Result<(String, BTreeMap<String, String>), Value> {
@@ -68,7 +68,7 @@ pub(crate) fn load_config(
             Ok(map) => return Ok(("/proc/config.gz".to_string(), map)),
             Err(e) => {
                 last = Some(Value::unavailable(format!(
-                    "/proc/config.gz illisible : {e}"
+                    "/proc/config.gz unreadable: {e}"
                 )))
             }
         },
@@ -93,12 +93,12 @@ pub(crate) fn load_config(
     }
     Err(last.unwrap_or_else(|| {
         Value::unavailable(
-            "ni /proc/config.gz, ni /boot/config-<release>, ni /lib/modules/<release>/config",
+            "neither /proc/config.gz nor /boot/config-<release> nor /lib/modules/<release>/config",
         )
     }))
 }
 
-/// `LINUX_VERSION_CODE` déduit de la release, exigé par les kprobes des noyaux < 5.0.
+/// `LINUX_VERSION_CODE` derived from the release, required by kprobes on kernels < 5.0.
 pub(crate) fn version_code(release: &str) -> u32 {
     let mut parts = release
         .split(|c: char| !c.is_ascii_digit())
diff --git a/crates/envprobe-core/src/probes/libs.rs b/crates/envprobe-core/src/probes/libs.rs
index bd34249..721ec9f 100644
--- a/crates/envprobe-core/src/probes/libs.rs
+++ b/crates/envprobe-core/src/probes/libs.rs
@@ -1,4 +1,4 @@
-//! Présence et version des bibliothèques courantes.
+//! Presence and version of common libraries.
 
 use std::fs;
 use std::path::{Path, PathBuf};
@@ -7,7 +7,7 @@ use std::process::Command;
 use crate::parse::ldconfig;
 use crate::{util, Section, Value};
 
-/// (clé, préfixe du soname)
+/// (key, soname prefix)
 const LIBS: &[(&str, &str)] = &[
     ("libbpf", "libbpf.so"),
     ("libelf", "libelf.so"),
@@ -22,7 +22,7 @@ pub fn probe() -> Section {
     let mut s = Section::new("libs");
     let (source, entries) = match ldconfig_entries() {
         Some(entries) => ("ldconfig -p", entries),
-        None => ("scan des répertoires", scan_dirs()),
+        None => ("directory scan", scan_dirs()),
     };
     s.push("source", Value::ok(source));
     for (key, prefix) in LIBS {
@@ -34,14 +34,14 @@ pub fn probe() -> Section {
                 let real = fs::canonicalize(path).unwrap_or_else(|_| PathBuf::from(path));
                 Value::ok(real.display().to_string())
             }
-            None => Value::ok("absente"),
+            None => Value::ok("absent"),
         };
         s.push(*key, value);
     }
     s
 }
 
-/// Sortie de `ldconfig -p` (lecture seule du cache), si l'outil existe et répond.
+/// Output of `ldconfig -p` (read-only cache lookup), if the tool exists and answers.
 fn ldconfig_entries() -> Option<Vec<(String, String)>> {
     let bin = LDCONFIG.iter().find(|p| Path::new(p).exists())?;
     let out = Command::new(bin).arg("-p").output().ok()?;
diff --git a/crates/envprobe-core/src/probes/mod.rs b/crates/envprobe-core/src/probes/mod.rs
index f99a4c6..95c0c40 100644
--- a/crates/envprobe-core/src/probes/mod.rs
+++ b/crates/envprobe-core/src/probes/mod.rs
@@ -1,4 +1,4 @@
-//! Une sonde par catégorie, dans l'ordre d'affichage du rapport.
+//! One probe per category, in report display order.
 
 pub mod bpf;
 pub mod btf;
diff --git a/crates/envprobe-core/src/probes/modules.rs b/crates/envprobe-core/src/probes/modules.rs
index bce7315..982b72a 100644
--- a/crates/envprobe-core/src/probes/modules.rs
+++ b/crates/envprobe-core/src/probes/modules.rs
@@ -1,4 +1,4 @@
-//! Modules noyau chargés et possibilité d'en charger.
+//! Loaded kernel modules and whether more can be loaded.
 
 use std::fs;
 use std::path::Path;
@@ -18,7 +18,7 @@ pub fn probe() -> Section {
             s.push(
                 "loaded",
                 Value::ok(if names.is_empty() {
-                    "(aucun)".to_string()
+                    "(none)".to_string()
                 } else {
                     names.join(", ")
                 }),
@@ -36,19 +36,19 @@ pub fn probe() -> Section {
 
 fn loadable() -> Value {
     if !Path::new("/proc/modules").exists() {
-        return Value::ok("non (noyau sans support des modules)");
+        return Value::ok("no (kernel without module support)");
     }
     if util::read_trimmed("/proc/sys/kernel/modules_disabled").as_deref() == Ok("1") {
-        return Value::ok("non (kernel.modules_disabled=1)");
+        return Value::ok("no (kernel.modules_disabled=1)");
     }
     if privileges::initial_user_ns() == Some(false) {
-        return Value::ok("non (user namespace non initial)");
+        return Value::ok("no (non-initial user namespace)");
     }
     match privileges::cap_eff() {
         Some(caps) if privileges::has_cap(caps, CAP_SYS_MODULE) => {
-            Value::ok("oui (CAP_SYS_MODULE)")
+            Value::ok("yes (CAP_SYS_MODULE)")
         }
-        Some(_) => Value::ok("non (CAP_SYS_MODULE absente)"),
-        None => Value::unavailable("capabilities illisibles"),
+        Some(_) => Value::ok("no (CAP_SYS_MODULE missing)"),
+        None => Value::unavailable("capabilities unreadable"),
     }
 }
diff --git a/crates/envprobe-core/src/probes/packages.rs b/crates/envprobe-core/src/probes/packages.rs
index 531867b..e8ef04a 100644
--- a/crates/envprobe-core/src/probes/packages.rs
+++ b/crates/envprobe-core/src/probes/packages.rs
@@ -1,4 +1,4 @@
-//! Gestionnaires de paquets présents.
+//! Package managers present.
 
 use std::env;
 use std::path::{Path, PathBuf};
@@ -44,7 +44,7 @@ pub fn probe() -> Section {
     s.push(
         "managers",
         Value::ok(if found.is_empty() {
-            "aucun".to_string()
+            "none".to_string()
         } else {
             found.join(", ")
         }),
diff --git a/crates/envprobe-core/src/probes/perf.rs b/crates/envprobe-core/src/probes/perf.rs
index 3511a59..7b83ae8 100644
--- a/crates/envprobe-core/src/probes/perf.rs
+++ b/crates/envprobe-core/src/probes/perf.rs
@@ -1,4 +1,4 @@
-//! `perf_event_open` logiciel et matériel, PMU disponibles.
+//! Software and hardware `perf_event_open`, available PMUs.
 
 use std::fs;
 use std::path::Path;
@@ -37,12 +37,12 @@ pub fn probe() -> Section {
     ];
     for (key, kind, config, user_only) in events {
         let value = match sys::perf_event_open(kind, config, user_only) {
-            Ok(_fd) => Value::ok("ouvert"),
+            Ok(_fd) => Value::ok("opened"),
             Err(libc::ENOSYS) => {
-                Value::unavailable("ENOSYS : perf_event_open absent (CONFIG_PERF_EVENTS)")
+                Value::unavailable("ENOSYS: perf_event_open missing (CONFIG_PERF_EVENTS)")
             }
             Err(e @ (libc::ENOENT | libc::EOPNOTSUPP | libc::ENODEV)) => {
-                Value::ok(format!("non supporté ({})", errno_name(e)))
+                Value::ok(format!("unsupported ({})", errno_name(e)))
             }
             Err(e) => util::errno_value(e),
         };
diff --git a/crates/envprobe-core/src/probes/privileges.rs b/crates/envprobe-core/src/probes/privileges.rs
index ead5c43..26b388c 100644
--- a/crates/envprobe-core/src/probes/privileges.rs
+++ b/crates/envprobe-core/src/probes/privileges.rs
@@ -35,8 +35,8 @@ pub(crate) fn cap_eff() -> Option<u64> {
     self_status().ok()?.cap_eff()
 }
 
-/// Vrai dans le user namespace initial. Ailleurs, les capabilities ne valent
-/// que dans le namespace : CAP_BPF affiché n'autorise pas `bpf()`.
+/// True in the initial user namespace. Elsewhere, capabilities only apply
+/// inside the namespace: a CAP_BPF shown here does not allow `bpf()`.
 pub(crate) fn initial_user_ns() -> Option<bool> {
     let map = fs::read_to_string("/proc/self/uid_map").ok()?;
     Some(crate::parse::status::is_initial_uid_map(&map))
@@ -60,7 +60,7 @@ pub fn probe() -> Section {
             return s;
         }
     };
-    let missing = |field: &str| Value::unavailable(format!("champ {field} absent"));
+    let missing = |field: &str| Value::unavailable(format!("field {field} missing"));
     match status.uids() {
         Some(ids) => {
             s.push_privileged("uid", Value::ok(ids[0].to_string()));
@@ -77,7 +77,7 @@ pub fn probe() -> Section {
             for (name, bit) in CAPS {
                 s.push_privileged(
                     *name,
-                    Value::ok(if has_cap(mask, *bit) { "oui" } else { "non" }),
+                    Value::ok(if has_cap(mask, *bit) { "yes" } else { "no" }),
                 );
             }
         }
@@ -87,16 +87,16 @@ pub fn probe() -> Section {
         "user_namespace",
         match initial_user_ns() {
             Some(true) => Value::ok("initial"),
-            Some(false) => Value::ok("non initial (capabilities limitées au namespace)"),
-            None => Value::unavailable("/proc/self/uid_map illisible"),
+            Some(false) => Value::ok("non-initial (capabilities limited to the namespace)"),
+            None => Value::unavailable("/proc/self/uid_map unreadable"),
         },
     );
     s.push_privileged(
         "seccomp",
         match status.seccomp() {
-            Some(0) => Value::ok("désactivé"),
+            Some(0) => Value::ok("disabled"),
             Some(1) => Value::ok("strict"),
-            Some(2) => Value::ok("filtre"),
+            Some(2) => Value::ok("filter"),
             Some(n) => Value::ok(n.to_string()),
             None => missing("Seccomp"),
         },
@@ -105,7 +105,7 @@ pub fn probe() -> Section {
         "no_new_privs",
         status
             .no_new_privs()
-            .map(|b| Value::ok(if b { "oui" } else { "non" }))
+            .map(|b| Value::ok(if b { "yes" } else { "no" }))
             .unwrap_or_else(|| missing("NoNewPrivs")),
     );
     s
diff --git a/crates/envprobe-core/src/probes/security.rs b/crates/envprobe-core/src/probes/security.rs
index 060e786..302f6bd 100644
--- a/crates/envprobe-core/src/probes/security.rs
+++ b/crates/envprobe-core/src/probes/security.rs
@@ -34,8 +34,8 @@ fn selinux() -> Value {
 
 fn apparmor() -> Value {
     match util::read_trimmed("/sys/module/apparmor/parameters/enabled") {
-        Ok(v) if v == "Y" => Value::ok("activé"),
-        Ok(_) => Value::ok("désactivé"),
+        Ok(v) if v == "Y" => Value::ok("enabled"),
+        Ok(_) => Value::ok("disabled"),
         Err(Value::Unavailable(_)) => Value::ok("absent"),
         Err(v) => v,
     }
@@ -47,7 +47,7 @@ fn apparmor_profiles() -> Value {
         Ok(text) => {
             let total = text.lines().count();
             let enforce = text.lines().filter(|l| l.ends_with("(enforce)")).count();
-            Value::ok(format!("{total} profils, {enforce} en enforce"))
+            Value::ok(format!("{total} profiles, {enforce} in enforce mode"))
         }
         Err(e) => util::io_value(&e, path),
     }
@@ -62,18 +62,14 @@ fn lockdown() -> Value {
 
 fn secure_boot() -> Value {
     if !Path::new("/sys/firmware/efi").exists() {
-        return Value::ok("non (démarrage non EFI)");
+        return Value::ok("no (non-EFI boot)");
     }
     match fs::read(SECURE_BOOT_VAR) {
-        // 4 octets d'attributs, puis la valeur.
-        Ok(data) if data.len() >= 5 => Value::ok(if data[4] == 1 {
-            "activé"
-        } else {
-            "désactivé"
-        }),
-        Ok(_) => Value::unavailable("variable SecureBoot tronquée"),
+        // 4 bytes of attributes, then the value.
+        Ok(data) if data.len() >= 5 => Value::ok(if data[4] == 1 { "enabled" } else { "disabled" }),
+        Ok(_) => Value::unavailable("SecureBoot variable truncated"),
         Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
-            Value::ok("désactivé (variable absente)")
+            Value::ok("disabled (variable missing)")
         }
         Err(e) => util::io_value(&e, Path::new(SECURE_BOOT_VAR)),
     }
diff --git a/crates/envprobe-core/src/probes/shell.rs b/crates/envprobe-core/src/probes/shell.rs
index f807f2e..62a3131 100644
--- a/crates/envprobe-core/src/probes/shell.rs
+++ b/crates/envprobe-core/src/probes/shell.rs
@@ -1,4 +1,4 @@
-//! Cible de /bin/sh et implémentation des outils de base.
+//! Target of /bin/sh and implementation of the base tools.
 
 use std::fs;
 use std::path::Path;
@@ -46,7 +46,7 @@ fn coreutils() -> Value {
     } else if contains_bytes(&data, b"BusyBox") {
         "busybox"
     } else {
-        "inconnu"
+        "unknown"
     };
     Value::ok(format!("{kind} ({})", real.display()))
 }
diff --git a/crates/envprobe-core/src/probes/sysctl.rs b/crates/envprobe-core/src/probes/sysctl.rs
index 3778a29..bef911c 100644
--- a/crates/envprobe-core/src/probes/sysctl.rs
+++ b/crates/envprobe-core/src/probes/sysctl.rs
@@ -1,4 +1,4 @@
-//! Sysctls qui changent le comportement de perf, BPF et ptrace.
+//! Sysctls that change how perf, BPF and ptrace behave.
 
 use crate::{util, Section};
 
diff --git a/crates/envprobe-core/src/probes/tracing.rs b/crates/envprobe-core/src/probes/tracing.rs
index eef7bc1..d76e8b0 100644
--- a/crates/envprobe-core/src/probes/tracing.rs
+++ b/crates/envprobe-core/src/probes/tracing.rs
@@ -1,4 +1,4 @@
-//! tracefs, debugfs, lisibilité de kallsyms.
+//! tracefs, debugfs, kallsyms readability.
 
 use std::fs;
 use std::io::{BufRead, BufReader};
@@ -25,7 +25,7 @@ pub fn probe() -> Section {
                     .map(|m| m.target.as_str())
                     .collect();
                 let value = if targets.is_empty() {
-                    Value::ok("non monté")
+                    Value::ok("not mounted")
                 } else {
                     Value::ok(targets.join(", "))
                 };
@@ -42,7 +42,7 @@ pub fn probe() -> Section {
         ("debug_tracing_dir", "/sys/kernel/debug/tracing"),
     ] {
         let value = match fs::read_dir(dir) {
-            Ok(_) => Value::ok("lisible"),
+            Ok(_) => Value::ok("readable"),
             Err(e) => util::io_value(&e, Path::new(dir)),
         };
         s.push_privileged(key, value);
@@ -63,10 +63,10 @@ fn kallsyms() -> Value {
     }
     let addr = line.split_whitespace().next().unwrap_or("");
     if addr.is_empty() {
-        Value::ok("vide")
+        Value::ok("empty")
     } else if addr.bytes().all(|b| b == b'0') {
-        Value::ok("lisible, adresses masquées (kptr_restrict)")
+        Value::ok("readable, addresses hidden (kptr_restrict)")
     } else {
-        Value::ok("lisible, adresses visibles")
+        Value::ok("readable, addresses visible")
     }
 }
diff --git a/crates/envprobe-core/src/probes/xdg.rs b/crates/envprobe-core/src/probes/xdg.rs
index 3c0a283..2a111de 100644
--- a/crates/envprobe-core/src/probes/xdg.rs
+++ b/crates/envprobe-core/src/probes/xdg.rs
@@ -1,4 +1,4 @@
-//! Variables XDG définies et valeurs effectives.
+//! XDG variables that are set, and effective values.
 
 use std::env;
 
@@ -24,9 +24,9 @@ pub fn probe() -> Section {
     ];
     for (name, default) in vars {
         let value = match (env::var(name), default) {
-            (Ok(v), _) if !v.is_empty() => Value::ok(format!("{v} (défini)")),
-            (_, Some(d)) => Value::ok(format!("{d} (défaut)")),
-            (_, None) => Value::ok("non défini"),
+            (Ok(v), _) if !v.is_empty() => Value::ok(format!("{v} (set)")),
+            (_, Some(d)) => Value::ok(format!("{d} (default)")),
+            (_, None) => Value::ok("not set"),
         };
         s.push(name, value);
     }
diff --git a/crates/envprobe-core/src/sys.rs b/crates/envprobe-core/src/sys.rs
index a73cbcf..6903a32 100644
--- a/crates/envprobe-core/src/sys.rs
+++ b/crates/envprobe-core/src/sys.rs
@@ -1,5 +1,5 @@
-//! Appels système bruts. Seul module autorisé à contenir de l'`unsafe` :
-//! chaque bloc justifie pourquoi il est sûr. Les fonctions exposées sont sûres.
+//! Raw system calls. The only module allowed to contain `unsafe`: each block
+//! explains why it is sound. The exposed functions are safe.
 
 use std::ffi::CStr;
 use std::io;
@@ -9,13 +9,13 @@ fn last_errno() -> i32 {
     io::Error::last_os_error().raw_os_error().unwrap_or(0)
 }
 
-/// Transforme le retour d'un syscall créant un descripteur.
+/// Turns the return value of a syscall that creates a descriptor into a result.
 fn fd_result(ret: libc::c_long) -> Result<OwnedFd, i32> {
     if ret < 0 {
         Err(last_errno())
     } else {
-        // SAFETY : le noyau vient de créer ce descripteur pour nous, personne
-        // d'autre ne le possède ; OwnedFd le fermera une seule fois.
+        // SAFETY: the kernel just created this descriptor for us, nobody else
+        // owns it; OwnedFd will close it exactly once.
         Ok(unsafe { OwnedFd::from_raw_fd(ret as RawFd) })
     }
 }
@@ -27,16 +27,16 @@ pub struct Uname {
 }
 
 pub fn uname() -> io::Result<Uname> {
-    // SAFETY : utsname ne contient que des tableaux de c_char, l'état tout à
-    // zéro est valide.
+    // SAFETY: utsname only contains c_char arrays, so the all-zero state is
+    // valid.
     let mut u: libc::utsname = unsafe { std::mem::zeroed() };
-    // SAFETY : `u` est un pointeur valide vers une utsname modifiable.
+    // SAFETY: `u` is a valid pointer to a mutable utsname.
     if unsafe { libc::uname(&mut u) } != 0 {
         return Err(io::Error::last_os_error());
     }
     let field = |s: &[libc::c_char]| {
-        // SAFETY : le noyau termine chaque champ par un NUL, et la structure
-        // était initialisée à zéro, donc un NUL existe dans le tableau.
+        // SAFETY: the kernel NUL-terminates every field, and the struct was
+        // zero-initialized, so the array contains a NUL.
         unsafe { CStr::from_ptr(s.as_ptr()) }
             .to_string_lossy()
             .into_owned()
@@ -49,7 +49,7 @@ pub fn uname() -> io::Result<Uname> {
 }
 
 pub fn page_size() -> usize {
-    // SAFETY : sysconf n'a pas de précondition.
+    // SAFETY: sysconf has no precondition.
     let size = unsafe { libc::sysconf(libc::_SC_PAGESIZE) };
     if size > 0 {
         size as usize
@@ -60,8 +60,8 @@ pub fn page_size() -> usize {
 
 const BPF_MAP_CREATE: libc::c_long = 0;
 const BPF_PROG_LOAD: libc::c_long = 5;
-/// Taille de `union bpf_attr` transmise : assez pour les champs utilisés, le
-/// reste est à zéro, ce que tous les noyaux acceptent.
+/// Size of the `union bpf_attr` passed in: enough for the fields we use; the
+/// rest is zero, which every kernel accepts.
 const BPF_ATTR_SIZE: usize = 128;
 
 fn put_u32(buf: &mut [u8], off: usize, v: u32) {
@@ -73,9 +73,9 @@ fn put_u64(buf: &mut [u8], off: usize, v: u64) {
 }
 
 fn bpf(cmd: libc::c_long, attr: &mut [u8; BPF_ATTR_SIZE]) -> Result<OwnedFd, i32> {
-    // SAFETY : `attr` est un tampon valide de BPF_ATTR_SIZE octets. Les
-    // pointeurs qu'il contient (instructions, licence, log) sont posés par les
-    // appelants de ce module et restent valides pendant l'appel.
+    // SAFETY: `attr` is a valid buffer of BPF_ATTR_SIZE bytes. The pointers it
+    // holds (instructions, license, log) are set by this module's callers and
+    // stay valid for the duration of the call.
     let ret = unsafe {
         libc::syscall(
             libc::SYS_bpf,
@@ -87,7 +87,7 @@ fn bpf(cmd: libc::c_long, attr: &mut [u8; BPF_ATTR_SIZE]) -> Result<OwnedFd, i32
     fd_result(ret)
 }
 
-/// Une instruction eBPF encodée (`struct bpf_insn`).
+/// An encoded eBPF instruction (`struct bpf_insn`).
 #[derive(Clone, Copy)]
 pub struct BpfInsn([u8; 8]);
 
@@ -121,11 +121,11 @@ pub struct ProgLoad<'a> {
     pub prog_flags: u32,
     pub kern_version: u32,
     pub insns: &'a [BpfInsn],
-    /// Tampon du log du vérificateur (niveau 1) si fourni.
+    /// Verifier log buffer (level 1), if provided.
     pub log: Option<&'a mut [u8]>,
 }
 
-/// `BPF_PROG_LOAD`. Le programme est fermé dès que le descripteur est lâché.
+/// `BPF_PROG_LOAD`. The program is closed as soon as the descriptor is dropped.
 pub fn bpf_prog_load(req: ProgLoad<'_>) -> Result<OwnedFd, i32> {
     let license = b"GPL\0";
     let insns: Vec<u8> = req.insns.iter().flat_map(|i| i.0).collect();
@@ -153,7 +153,7 @@ pub struct MapCreate {
     pub map_flags: u32,
 }
 
-/// `BPF_MAP_CREATE`. La map est détruite dès que le descripteur est lâché.
+/// `BPF_MAP_CREATE`. The map is destroyed as soon as the descriptor is dropped.
 pub fn bpf_map_create(req: &MapCreate) -> Result<OwnedFd, i32> {
     let mut attr = [0u8; BPF_ATTR_SIZE];
     put_u32(&mut attr, 0, req.map_type);
@@ -168,25 +168,25 @@ pub const PERF_TYPE_HARDWARE: u32 = 0;
 pub const PERF_TYPE_SOFTWARE: u32 = 1;
 pub const PERF_COUNT_HW_CPU_CYCLES: u64 = 0;
 pub const PERF_COUNT_SW_CPU_CLOCK: u64 = 0;
-/// PERF_ATTR_SIZE_VER0, compris par tous les noyaux.
+/// PERF_ATTR_SIZE_VER0, understood by every kernel.
 const PERF_ATTR_SIZE: usize = 64;
 const PERF_FLAG_FD_CLOEXEC: libc::c_ulong = 8;
 
-/// `perf_event_open` sur le processus courant, compteur désactivé : rien
-/// n'est mesuré, on teste seulement l'ouverture.
+/// `perf_event_open` on the current process with the counter disabled:
+/// nothing is measured, only opening is tested.
 pub fn perf_event_open(event_type: u32, config: u64, exclude_kernel: bool) -> Result<OwnedFd, i32> {
     let mut attr = [0u8; PERF_ATTR_SIZE];
     put_u32(&mut attr, 0, event_type);
     put_u32(&mut attr, 4, PERF_ATTR_SIZE as u32);
     put_u64(&mut attr, 8, config);
-    // Champs de bits : disabled (0), exclude_kernel (5), exclude_hv (6).
+    // Bit fields: disabled (0), exclude_kernel (5), exclude_hv (6).
     let mut flags: u64 = 1;
     if exclude_kernel {
         flags |= (1 << 5) | (1 << 6);
     }
     put_u64(&mut attr, 40, flags);
-    // SAFETY : `attr` est une perf_event_attr valide de PERF_ATTR_SIZE octets
-    // (taille indiquée dans le champ size) qui survit à l'appel.
+    // SAFETY: `attr` is a valid perf_event_attr of PERF_ATTR_SIZE bytes (the
+    // size given in its size field) that outlives the call.
     let ret = unsafe {
         libc::syscall(
             libc::SYS_perf_event_open,
diff --git a/crates/envprobe-core/src/util.rs b/crates/envprobe-core/src/util.rs
index 63b2345..4132bd8 100644
--- a/crates/envprobe-core/src/util.rs
+++ b/crates/envprobe-core/src/util.rs
@@ -1,4 +1,4 @@
-//! Petites aides partagées par les sondes.
+//! Small helpers shared by the probes.
 
 use std::fs;
 use std::io;
@@ -6,20 +6,20 @@ use std::path::Path;
 
 use crate::Value;
 
-/// Convertit une erreur d'E/S en valeur de rapport.
+/// Turns an I/O error into a report value.
 pub(crate) fn io_value(err: &io::Error, path: &Path) -> Value {
     match err.kind() {
-        io::ErrorKind::NotFound => Value::unavailable(format!("{} absent", path.display())),
+        io::ErrorKind::NotFound => Value::unavailable(format!("{} missing", path.display())),
         io::ErrorKind::PermissionDenied => Value::denied(format!(
-            "{} : {}",
+            "{}: {}",
             errno_name(err.raw_os_error().unwrap_or(libc::EACCES)),
             path.display()
         )),
-        _ => Value::unavailable(format!("{} : {err}", path.display())),
+        _ => Value::unavailable(format!("{}: {err}", path.display())),
     }
 }
 
-/// Lit un fichier texte et retire les blancs en bordure.
+/// Reads a text file and trims surrounding whitespace.
 pub(crate) fn read_trimmed(path: impl AsRef<Path>) -> Result<String, Value> {
     let path = path.as_ref();
     fs::read_to_string(path)
@@ -27,12 +27,12 @@ pub(crate) fn read_trimmed(path: impl AsRef<Path>) -> Result<String, Value> {
         .map_err(|e| io_value(&e, path))
 }
 
-/// Comme [`read_trimmed`], mais renvoie directement une [`Value`].
+/// Like [`read_trimmed`], but returns a [`Value`] directly.
 pub(crate) fn read_value(path: impl AsRef<Path>) -> Value {
     read_trimmed(path).map_or_else(|v| v, Value::Ok)
 }
 
-/// Résultat d'un syscall en échec : EPERM et EACCES sont des refus, le reste une indisponibilité.
+/// Result of a failed syscall: EPERM and EACCES are denials, anything else is unavailability.
 pub(crate) fn errno_value(errno: i32) -> Value {
     match errno {
         libc::EPERM | libc::EACCES => Value::denied(errno_name(errno)),
@@ -67,7 +67,7 @@ pub(crate) fn contains_bytes(haystack: &[u8], needle: &[u8]) -> bool {
     !needle.is_empty() && haystack.windows(needle.len()).any(|w| w == needle)
 }
 
-/// Triplet multiarch Debian correspondant à l'architecture de la sonde.
+/// Debian multiarch triplet matching the probe's architecture.
 pub(crate) fn multiarch_triplet() -> String {
     format!("{}-linux-gnu", std::env::consts::ARCH)
 }
diff --git a/crates/envprobe-core/tests/fixtures/reports/alpine-3.20-rootfs.json b/crates/envprobe-core/tests/fixtures/reports/alpine-3.20-rootfs.json
index b4f3b92..fb7a87e 100644
--- a/crates/envprobe-core/tests/fixtures/reports/alpine-3.20-rootfs.json
+++ b/crates/envprobe-core/tests/fixtures/reports/alpine-3.20-rootfs.json
@@ -32,7 +32,7 @@
         {
           "key": "id_like",
           "status": "unavailable",
-          "value": "ID_LIKE non défini",
+          "value": "ID_LIKE not set",
           "privileged": false
         },
         {
@@ -50,7 +50,7 @@
         {
           "key": "container",
           "status": "ok",
-          "value": "aucun détecté",
+          "value": "none detected",
           "privileged": false
         }
       ]
@@ -73,7 +73,7 @@
         {
           "key": "cmdline",
           "status": "ok",
-          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<masqué> earlycon=pl011,mmio32,0x40001000",
+          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<redacted> earlycon=pl011,mmio32,0x40001000",
           "privileged": false
         },
         {
@@ -139,7 +139,7 @@
         {
           "key": "CONFIG_PERF_EVENTS",
           "status": "ok",
-          "value": "absente de la config",
+          "value": "not in the config",
           "privileged": false
         },
         {
@@ -168,7 +168,7 @@
         {
           "key": "loadable",
           "status": "ok",
-          "value": "non (user namespace non initial)",
+          "value": "no (non-initial user namespace)",
           "privileged": true
         }
       ]
@@ -197,13 +197,13 @@
         {
           "key": "net.core.bpf_jit_enable",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
           "key": "net.core.bpf_jit_harden",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_harden absent",
+          "value": "/proc/sys/net/core/bpf_jit_harden missing",
           "privileged": false
         },
         {
@@ -250,19 +250,19 @@
         {
           "key": "apparmor_profiles",
           "status": "unavailable",
-          "value": "/sys/kernel/security/apparmor/profiles absent",
+          "value": "/sys/kernel/security/apparmor/profiles missing",
           "privileged": true
         },
         {
           "key": "lockdown",
           "status": "unavailable",
-          "value": "/sys/kernel/security/lockdown absent",
+          "value": "/sys/kernel/security/lockdown missing",
           "privileged": false
         },
         {
           "key": "secure_boot",
           "status": "ok",
-          "value": "non (démarrage non EFI)",
+          "value": "no (non-EFI boot)",
           "privileged": false
         }
       ]
@@ -291,49 +291,49 @@
         {
           "key": "CAP_BPF",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_PERFMON",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_ADMIN",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_PTRACE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_MODULE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "user_namespace",
           "status": "ok",
-          "value": "non initial (capabilities limitées au namespace)",
+          "value": "non-initial (capabilities limited to the namespace)",
           "privileged": true
         },
         {
           "key": "seccomp",
           "status": "ok",
-          "value": "désactivé",
+          "value": "disabled",
           "privileged": true
         },
         {
           "key": "no_new_privs",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         }
       ]
@@ -344,7 +344,7 @@
         {
           "key": "vmlinux",
           "status": "ok",
-          "value": "présent, 5279975 octets",
+          "value": "present, 5279975 bytes",
           "privileged": false
         },
         {
@@ -367,7 +367,7 @@
         {
           "key": "jit",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
@@ -457,7 +457,7 @@
         {
           "key": "prog.cgroup_device",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
@@ -541,25 +541,25 @@
         {
           "key": "prog.tracing",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.struct_ops",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.ext",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.lsm",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
@@ -786,7 +786,7 @@
         {
           "key": "sw_cpu_clock.user",
           "status": "ok",
-          "value": "ouvert",
+          "value": "opened",
           "privileged": true
         },
         {
@@ -798,7 +798,7 @@
         {
           "key": "hw_cpu_cycles.user",
           "status": "ok",
-          "value": "non supporté (ENOENT)",
+          "value": "unsupported (ENOENT)",
           "privileged": true
         },
         {
@@ -845,7 +845,7 @@
         {
           "key": "kallsyms",
           "status": "ok",
-          "value": "lisible, adresses masquées (kptr_restrict)",
+          "value": "readable, addresses hidden (kptr_restrict)",
           "privileged": true
         }
       ]
@@ -879,19 +879,19 @@
         {
           "key": "source",
           "status": "ok",
-          "value": "scan des répertoires",
+          "value": "directory scan",
           "privileged": false
         },
         {
           "key": "libbpf",
           "status": "ok",
-          "value": "absente",
+          "value": "absent",
           "privileged": false
         },
         {
           "key": "libelf",
           "status": "ok",
-          "value": "absente",
+          "value": "absent",
           "privileged": false
         },
         {
@@ -920,25 +920,25 @@
         {
           "key": "/bin",
           "status": "ok",
-          "value": "répertoire",
+          "value": "directory",
           "privileged": false
         },
         {
           "key": "/sbin",
           "status": "ok",
-          "value": "répertoire",
+          "value": "directory",
           "privileged": false
         },
         {
           "key": "/lib",
           "status": "ok",
-          "value": "répertoire",
+          "value": "directory",
           "privileged": false
         },
         {
           "key": "merged_usr",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": false
         },
         {
@@ -950,7 +950,7 @@
         {
           "key": "multiarch",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": false
         },
         {
@@ -984,7 +984,7 @@
         {
           "key": "kind",
           "status": "ok",
-          "value": "autre (envprobe)",
+          "value": "other (envprobe)",
           "privileged": false
         },
         {
@@ -1041,55 +1041,55 @@
         {
           "key": "XDG_CONFIG_HOME",
           "status": "ok",
-          "value": "/home/moha/.config (défaut)",
+          "value": "/home/moha/.config (default)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/share (défaut)",
+          "value": "/home/moha/.local/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CACHE_HOME",
           "status": "ok",
-          "value": "/home/moha/.cache (défaut)",
+          "value": "/home/moha/.cache (default)",
           "privileged": false
         },
         {
           "key": "XDG_STATE_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/state (défaut)",
+          "value": "/home/moha/.local/state (default)",
           "privileged": false
         },
         {
           "key": "XDG_RUNTIME_DIR",
           "status": "ok",
-          "value": "/run/user/501 (défini)",
+          "value": "/run/user/501 (set)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_DIRS",
           "status": "ok",
-          "value": "/usr/local/share:/usr/share (défaut)",
+          "value": "/usr/local/share:/usr/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CONFIG_DIRS",
           "status": "ok",
-          "value": "/etc/xdg (défaut)",
+          "value": "/etc/xdg (default)",
           "privileged": false
         },
         {
           "key": "XDG_SESSION_TYPE",
           "status": "ok",
-          "value": "tty (défini)",
+          "value": "tty (set)",
           "privileged": false
         },
         {
           "key": "XDG_CURRENT_DESKTOP",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         }
       ]
diff --git a/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-root.json b/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-root.json
index 613d723..f57fd98 100644
--- a/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-root.json
+++ b/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-root.json
@@ -26,7 +26,7 @@
         {
           "key": "version_id",
           "status": "unavailable",
-          "value": "VERSION_ID non défini",
+          "value": "VERSION_ID not set",
           "privileged": false
         },
         {
@@ -73,7 +73,7 @@
         {
           "key": "cmdline",
           "status": "ok",
-          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<masqué> earlycon=pl011,mmio32,0x40001000",
+          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<redacted> earlycon=pl011,mmio32,0x40001000",
           "privileged": false
         },
         {
@@ -139,7 +139,7 @@
         {
           "key": "CONFIG_PERF_EVENTS",
           "status": "ok",
-          "value": "absente de la config",
+          "value": "not in the config",
           "privileged": false
         },
         {
@@ -168,7 +168,7 @@
         {
           "key": "loadable",
           "status": "ok",
-          "value": "oui (CAP_SYS_MODULE)",
+          "value": "yes (CAP_SYS_MODULE)",
           "privileged": true
         }
       ]
@@ -197,13 +197,13 @@
         {
           "key": "net.core.bpf_jit_enable",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
           "key": "net.core.bpf_jit_harden",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_harden absent",
+          "value": "/proc/sys/net/core/bpf_jit_harden missing",
           "privileged": false
         },
         {
@@ -250,19 +250,19 @@
         {
           "key": "apparmor_profiles",
           "status": "unavailable",
-          "value": "/sys/kernel/security/apparmor/profiles absent",
+          "value": "/sys/kernel/security/apparmor/profiles missing",
           "privileged": true
         },
         {
           "key": "lockdown",
           "status": "unavailable",
-          "value": "/sys/kernel/security/lockdown absent",
+          "value": "/sys/kernel/security/lockdown missing",
           "privileged": false
         },
         {
           "key": "secure_boot",
           "status": "ok",
-          "value": "non (démarrage non EFI)",
+          "value": "no (non-EFI boot)",
           "privileged": false
         }
       ]
@@ -291,31 +291,31 @@
         {
           "key": "CAP_BPF",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_PERFMON",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_ADMIN",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_PTRACE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_MODULE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
@@ -327,13 +327,13 @@
         {
           "key": "seccomp",
           "status": "ok",
-          "value": "désactivé",
+          "value": "disabled",
           "privileged": true
         },
         {
           "key": "no_new_privs",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         }
       ]
@@ -344,7 +344,7 @@
         {
           "key": "vmlinux",
           "status": "ok",
-          "value": "présent, 5279975 octets",
+          "value": "present, 5279975 bytes",
           "privileged": false
         },
         {
@@ -361,421 +361,421 @@
         {
           "key": "syscall",
           "status": "ok",
-          "value": "disponible",
+          "value": "available",
           "privileged": true
         },
         {
           "key": "jit",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
           "key": "prog.socket_filter",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.kprobe",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sched_cls",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sched_act",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.tracepoint",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.xdp",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.perf_event",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_skb",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_sock",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.lwt_in",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.lwt_out",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.lwt_xmit",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sock_ops",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sk_skb",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_device",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sk_msg",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.raw_tracepoint",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_sock_addr",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.lwt_seg6local",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.lirc_mode2",
           "status": "ok",
-          "value": "non supporté (EINVAL)",
+          "value": "unsupported (EINVAL)",
           "privileged": true
         },
         {
           "key": "prog.sk_reuseport",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.flow_dissector",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_sysctl",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.raw_tracepoint_writable",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.cgroup_sockopt",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.sk_lookup",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.syscall",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.netfilter",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "prog.tracing",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.struct_ops",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.ext",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.lsm",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "map.hash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.array",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.prog_array",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.perf_event_array",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.percpu_hash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.percpu_array",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.stack_trace",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.cgroup_array",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.lru_hash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.lru_percpu_hash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.lpm_trie",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.devmap",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.sockmap",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.cpumap",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.xskmap",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.sockhash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.queue",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.stack",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.devmap_hash",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.ringbuf",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.bloom_filter",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "map.user_ringbuf",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.ktime_get_ns",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.trace_printk",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.get_current_pid_tgid",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.get_current_comm",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.perf_event_output",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.get_stackid",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.override_return",
           "status": "ok",
-          "value": "non supporté",
+          "value": "unsupported",
           "privileged": true
         },
         {
           "key": "helper.get_stack",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.send_signal",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.probe_read_user",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.probe_read_kernel",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.ktime_get_boot_ns",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.ringbuf_output",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
           "key": "helper.get_current_task_btf",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         }
       ]
@@ -786,25 +786,25 @@
         {
           "key": "sw_cpu_clock.user",
           "status": "ok",
-          "value": "ouvert",
+          "value": "opened",
           "privileged": true
         },
         {
           "key": "sw_cpu_clock.kernel",
           "status": "ok",
-          "value": "ouvert",
+          "value": "opened",
           "privileged": true
         },
         {
           "key": "hw_cpu_cycles.user",
           "status": "ok",
-          "value": "non supporté (ENOENT)",
+          "value": "unsupported (ENOENT)",
           "privileged": true
         },
         {
           "key": "hw_cpu_cycles.kernel",
           "status": "ok",
-          "value": "non supporté (ENOENT)",
+          "value": "unsupported (ENOENT)",
           "privileged": true
         },
         {
@@ -833,19 +833,19 @@
         {
           "key": "tracing_dir",
           "status": "ok",
-          "value": "lisible",
+          "value": "readable",
           "privileged": true
         },
         {
           "key": "debug_tracing_dir",
           "status": "ok",
-          "value": "lisible",
+          "value": "readable",
           "privileged": true
         },
         {
           "key": "kallsyms",
           "status": "ok",
-          "value": "lisible, adresses visibles",
+          "value": "readable, addresses visible",
           "privileged": true
         }
       ]
@@ -938,7 +938,7 @@
         {
           "key": "merged_usr",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": false
         },
         {
@@ -950,7 +950,7 @@
         {
           "key": "multiarch",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": false
         },
         {
@@ -1041,55 +1041,55 @@
         {
           "key": "XDG_CONFIG_HOME",
           "status": "ok",
-          "value": "/root/.config (défaut)",
+          "value": "/root/.config (default)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_HOME",
           "status": "ok",
-          "value": "/root/.local/share (défaut)",
+          "value": "/root/.local/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CACHE_HOME",
           "status": "ok",
-          "value": "/root/.cache (défaut)",
+          "value": "/root/.cache (default)",
           "privileged": false
         },
         {
           "key": "XDG_STATE_HOME",
           "status": "ok",
-          "value": "/root/.local/state (défaut)",
+          "value": "/root/.local/state (default)",
           "privileged": false
         },
         {
           "key": "XDG_RUNTIME_DIR",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         },
         {
           "key": "XDG_DATA_DIRS",
           "status": "ok",
-          "value": "/usr/local/share:/usr/share (défaut)",
+          "value": "/usr/local/share:/usr/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CONFIG_DIRS",
           "status": "ok",
-          "value": "/etc/xdg (défaut)",
+          "value": "/etc/xdg (default)",
           "privileged": false
         },
         {
           "key": "XDG_SESSION_TYPE",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         },
         {
           "key": "XDG_CURRENT_DESKTOP",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         }
       ]
diff --git a/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-user.json b/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-user.json
index cf24107..92414b4 100644
--- a/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-user.json
+++ b/crates/envprobe-core/tests/fixtures/reports/archarm-orbstack-user.json
@@ -26,7 +26,7 @@
         {
           "key": "version_id",
           "status": "unavailable",
-          "value": "VERSION_ID non défini",
+          "value": "VERSION_ID not set",
           "privileged": false
         },
         {
@@ -73,7 +73,7 @@
         {
           "key": "cmdline",
           "status": "ok",
-          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<masqué> earlycon=pl011,mmio32,0x40001000",
+          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<redacted> earlycon=pl011,mmio32,0x40001000",
           "privileged": false
         },
         {
@@ -139,7 +139,7 @@
         {
           "key": "CONFIG_PERF_EVENTS",
           "status": "ok",
-          "value": "absente de la config",
+          "value": "not in the config",
           "privileged": false
         },
         {
@@ -168,7 +168,7 @@
         {
           "key": "loadable",
           "status": "ok",
-          "value": "non (CAP_SYS_MODULE absente)",
+          "value": "no (CAP_SYS_MODULE missing)",
           "privileged": true
         }
       ]
@@ -197,13 +197,13 @@
         {
           "key": "net.core.bpf_jit_enable",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
           "key": "net.core.bpf_jit_harden",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_harden absent",
+          "value": "/proc/sys/net/core/bpf_jit_harden missing",
           "privileged": false
         },
         {
@@ -250,19 +250,19 @@
         {
           "key": "apparmor_profiles",
           "status": "unavailable",
-          "value": "/sys/kernel/security/apparmor/profiles absent",
+          "value": "/sys/kernel/security/apparmor/profiles missing",
           "privileged": true
         },
         {
           "key": "lockdown",
           "status": "unavailable",
-          "value": "/sys/kernel/security/lockdown absent",
+          "value": "/sys/kernel/security/lockdown missing",
           "privileged": false
         },
         {
           "key": "secure_boot",
           "status": "ok",
-          "value": "non (démarrage non EFI)",
+          "value": "no (non-EFI boot)",
           "privileged": false
         }
       ]
@@ -291,31 +291,31 @@
         {
           "key": "CAP_BPF",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         },
         {
           "key": "CAP_PERFMON",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         },
         {
           "key": "CAP_SYS_ADMIN",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         },
         {
           "key": "CAP_SYS_PTRACE",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         },
         {
           "key": "CAP_SYS_MODULE",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         },
         {
@@ -327,13 +327,13 @@
         {
           "key": "seccomp",
           "status": "ok",
-          "value": "désactivé",
+          "value": "disabled",
           "privileged": true
         },
         {
           "key": "no_new_privs",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         }
       ]
@@ -344,7 +344,7 @@
         {
           "key": "vmlinux",
           "status": "ok",
-          "value": "présent, 5279975 octets",
+          "value": "present, 5279975 bytes",
           "privileged": false
         },
         {
@@ -367,7 +367,7 @@
         {
           "key": "jit",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
@@ -541,25 +541,25 @@
         {
           "key": "prog.tracing",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.struct_ops",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.ext",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.lsm",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
@@ -786,7 +786,7 @@
         {
           "key": "sw_cpu_clock.user",
           "status": "ok",
-          "value": "ouvert",
+          "value": "opened",
           "privileged": true
         },
         {
@@ -798,7 +798,7 @@
         {
           "key": "hw_cpu_cycles.user",
           "status": "ok",
-          "value": "non supporté (ENOENT)",
+          "value": "unsupported (ENOENT)",
           "privileged": true
         },
         {
@@ -845,7 +845,7 @@
         {
           "key": "kallsyms",
           "status": "ok",
-          "value": "lisible, adresses masquées (kptr_restrict)",
+          "value": "readable, addresses hidden (kptr_restrict)",
           "privileged": true
         }
       ]
@@ -938,7 +938,7 @@
         {
           "key": "merged_usr",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": false
         },
         {
@@ -950,7 +950,7 @@
         {
           "key": "multiarch",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": false
         },
         {
@@ -1041,55 +1041,55 @@
         {
           "key": "XDG_CONFIG_HOME",
           "status": "ok",
-          "value": "/home/moha/.config (défaut)",
+          "value": "/home/moha/.config (default)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/share (défaut)",
+          "value": "/home/moha/.local/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CACHE_HOME",
           "status": "ok",
-          "value": "/home/moha/.cache (défaut)",
+          "value": "/home/moha/.cache (default)",
           "privileged": false
         },
         {
           "key": "XDG_STATE_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/state (défaut)",
+          "value": "/home/moha/.local/state (default)",
           "privileged": false
         },
         {
           "key": "XDG_RUNTIME_DIR",
           "status": "ok",
-          "value": "/run/user/501 (défini)",
+          "value": "/run/user/501 (set)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_DIRS",
           "status": "ok",
-          "value": "/usr/local/share:/usr/share (défaut)",
+          "value": "/usr/local/share:/usr/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CONFIG_DIRS",
           "status": "ok",
-          "value": "/etc/xdg (défaut)",
+          "value": "/etc/xdg (default)",
           "privileged": false
         },
         {
           "key": "XDG_SESSION_TYPE",
           "status": "ok",
-          "value": "tty (défini)",
+          "value": "tty (set)",
           "privileged": false
         },
         {
           "key": "XDG_CURRENT_DESKTOP",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         }
       ]
diff --git a/crates/envprobe-core/tests/fixtures/reports/debian-12-rootfs.json b/crates/envprobe-core/tests/fixtures/reports/debian-12-rootfs.json
index 99e48df..254fd68 100644
--- a/crates/envprobe-core/tests/fixtures/reports/debian-12-rootfs.json
+++ b/crates/envprobe-core/tests/fixtures/reports/debian-12-rootfs.json
@@ -32,7 +32,7 @@
         {
           "key": "id_like",
           "status": "unavailable",
-          "value": "ID_LIKE non défini",
+          "value": "ID_LIKE not set",
           "privileged": false
         },
         {
@@ -50,7 +50,7 @@
         {
           "key": "container",
           "status": "ok",
-          "value": "aucun détecté",
+          "value": "none detected",
           "privileged": false
         }
       ]
@@ -73,7 +73,7 @@
         {
           "key": "cmdline",
           "status": "ok",
-          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<masqué> earlycon=pl011,mmio32,0x40001000",
+          "value": "init=/opt/orb/vinit workqueue.power_efficient=1 cgroup.memory=nokmem,nosocket swiotlb=noforce slab_min_order=2 cgroup_v1_proc=1 nbd.nbds_max=4 can.stats_timer=0 isolcpus=7 arm64.nosme root=/dev/vda rootfstype=erofs ro console=hvc0 quiet ORB_S=<redacted> earlycon=pl011,mmio32,0x40001000",
           "privileged": false
         },
         {
@@ -139,7 +139,7 @@
         {
           "key": "CONFIG_PERF_EVENTS",
           "status": "ok",
-          "value": "absente de la config",
+          "value": "not in the config",
           "privileged": false
         },
         {
@@ -168,7 +168,7 @@
         {
           "key": "loadable",
           "status": "ok",
-          "value": "non (user namespace non initial)",
+          "value": "no (non-initial user namespace)",
           "privileged": true
         }
       ]
@@ -197,13 +197,13 @@
         {
           "key": "net.core.bpf_jit_enable",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
           "key": "net.core.bpf_jit_harden",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_harden absent",
+          "value": "/proc/sys/net/core/bpf_jit_harden missing",
           "privileged": false
         },
         {
@@ -250,19 +250,19 @@
         {
           "key": "apparmor_profiles",
           "status": "unavailable",
-          "value": "/sys/kernel/security/apparmor/profiles absent",
+          "value": "/sys/kernel/security/apparmor/profiles missing",
           "privileged": true
         },
         {
           "key": "lockdown",
           "status": "unavailable",
-          "value": "/sys/kernel/security/lockdown absent",
+          "value": "/sys/kernel/security/lockdown missing",
           "privileged": false
         },
         {
           "key": "secure_boot",
           "status": "ok",
-          "value": "non (démarrage non EFI)",
+          "value": "no (non-EFI boot)",
           "privileged": false
         }
       ]
@@ -291,49 +291,49 @@
         {
           "key": "CAP_BPF",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_PERFMON",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_ADMIN",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_PTRACE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "CAP_SYS_MODULE",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": true
         },
         {
           "key": "user_namespace",
           "status": "ok",
-          "value": "non initial (capabilities limitées au namespace)",
+          "value": "non-initial (capabilities limited to the namespace)",
           "privileged": true
         },
         {
           "key": "seccomp",
           "status": "ok",
-          "value": "désactivé",
+          "value": "disabled",
           "privileged": true
         },
         {
           "key": "no_new_privs",
           "status": "ok",
-          "value": "non",
+          "value": "no",
           "privileged": true
         }
       ]
@@ -344,7 +344,7 @@
         {
           "key": "vmlinux",
           "status": "ok",
-          "value": "présent, 5279975 octets",
+          "value": "present, 5279975 bytes",
           "privileged": false
         },
         {
@@ -367,7 +367,7 @@
         {
           "key": "jit",
           "status": "unavailable",
-          "value": "/proc/sys/net/core/bpf_jit_enable absent",
+          "value": "/proc/sys/net/core/bpf_jit_enable missing",
           "privileged": false
         },
         {
@@ -457,7 +457,7 @@
         {
           "key": "prog.cgroup_device",
           "status": "ok",
-          "value": "supporté",
+          "value": "supported",
           "privileged": true
         },
         {
@@ -541,25 +541,25 @@
         {
           "key": "prog.tracing",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.struct_ops",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.ext",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
           "key": "prog.lsm",
           "status": "unavailable",
-          "value": "non sondé : nécessite une cible BTF",
+          "value": "not probed: needs a BTF target",
           "privileged": false
         },
         {
@@ -786,7 +786,7 @@
         {
           "key": "sw_cpu_clock.user",
           "status": "ok",
-          "value": "ouvert",
+          "value": "opened",
           "privileged": true
         },
         {
@@ -798,7 +798,7 @@
         {
           "key": "hw_cpu_cycles.user",
           "status": "ok",
-          "value": "non supporté (ENOENT)",
+          "value": "unsupported (ENOENT)",
           "privileged": true
         },
         {
@@ -845,7 +845,7 @@
         {
           "key": "kallsyms",
           "status": "ok",
-          "value": "lisible, adresses masquées (kptr_restrict)",
+          "value": "readable, addresses hidden (kptr_restrict)",
           "privileged": true
         }
       ]
@@ -879,7 +879,7 @@
         {
           "key": "source",
           "status": "ok",
-          "value": "scan des répertoires",
+          "value": "directory scan",
           "privileged": false
         },
         {
@@ -938,7 +938,7 @@
         {
           "key": "merged_usr",
           "status": "ok",
-          "value": "oui",
+          "value": "yes",
           "privileged": false
         },
         {
@@ -950,7 +950,7 @@
         {
           "key": "multiarch",
           "status": "ok",
-          "value": "oui (/usr/lib/aarch64-linux-gnu)",
+          "value": "yes (/usr/lib/aarch64-linux-gnu)",
           "privileged": false
         },
         {
@@ -984,7 +984,7 @@
         {
           "key": "kind",
           "status": "ok",
-          "value": "autre (envprobe)",
+          "value": "other (envprobe)",
           "privileged": false
         },
         {
@@ -1041,55 +1041,55 @@
         {
           "key": "XDG_CONFIG_HOME",
           "status": "ok",
-          "value": "/home/moha/.config (défaut)",
+          "value": "/home/moha/.config (default)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/share (défaut)",
+          "value": "/home/moha/.local/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CACHE_HOME",
           "status": "ok",
-          "value": "/home/moha/.cache (défaut)",
+          "value": "/home/moha/.cache (default)",
           "privileged": false
         },
         {
           "key": "XDG_STATE_HOME",
           "status": "ok",
-          "value": "/home/moha/.local/state (défaut)",
+          "value": "/home/moha/.local/state (default)",
           "privileged": false
         },
         {
           "key": "XDG_RUNTIME_DIR",
           "status": "ok",
-          "value": "/run/user/501 (défini)",
+          "value": "/run/user/501 (set)",
           "privileged": false
         },
         {
           "key": "XDG_DATA_DIRS",
           "status": "ok",
-          "value": "/usr/local/share:/usr/share (défaut)",
+          "value": "/usr/local/share:/usr/share (default)",
           "privileged": false
         },
         {
           "key": "XDG_CONFIG_DIRS",
           "status": "ok",
-          "value": "/etc/xdg (défaut)",
+          "value": "/etc/xdg (default)",
           "privileged": false
         },
         {
           "key": "XDG_SESSION_TYPE",
           "status": "ok",
-          "value": "tty (défini)",
+          "value": "tty (set)",
           "privileged": false
         },
         {
           "key": "XDG_CURRENT_DESKTOP",
           "status": "ok",
-          "value": "non défini",
+          "value": "not set",
           "privileged": false
         }
       ]
diff --git a/crates/envprobe-core/tests/parsers.rs b/crates/envprobe-core/tests/parsers.rs
index 23ec4fe..9fe3ec2 100644
--- a/crates/envprobe-core/tests/parsers.rs
+++ b/crates/envprobe-core/tests/parsers.rs
@@ -1,4 +1,4 @@
-//! Parseurs testés sur des fichiers réels de plusieurs distros.
+//! Parsers tested on real files from several distros.
 
 use std::io::Write;
 
@@ -103,7 +103,7 @@ fn proc_status_variants() {
     let docker = status::parse(fixture!("status/docker-root"));
     let caps = docker.cap_eff().unwrap();
     assert_eq!(docker.seccomp(), Some(2));
-    // Docker garde CAP_NET_RAW (13) mais retire CAP_SYS_ADMIN (21) et CAP_BPF (39).
+    // Docker keeps CAP_NET_RAW (13) but drops CAP_SYS_ADMIN (21) and CAP_BPF (39).
     assert_eq!((caps >> 13) & 1, 1);
     assert_eq!((caps >> 21) & 1, 0);
     assert_eq!((caps >> 39) & 1, 0);
diff --git a/crates/envprobe-core/tests/reports.rs b/crates/envprobe-core/tests/reports.rs
index 37c018e..6afa73e 100644
--- a/crates/envprobe-core/tests/reports.rs
+++ b/crates/envprobe-core/tests/reports.rs
@@ -1,6 +1,6 @@
-//! Non-régression sur des rapports réels : schéma publié, désérialisation, diff.
+//! Regression tests on real reports: published schema, deserialization, diff.
 //!
-//! Régénérer le schéma : `UPDATE_SCHEMA=1 cargo test -p envprobe-core --test reports`.
+//! Regenerate the schema: `UPDATE_SCHEMA=1 cargo test -p envprobe-core --test reports`.
 
 use std::path::Path;
 
@@ -33,14 +33,14 @@ const FIXTURES: &[(&str, &str)] = &[
 
 fn load(name: &str) -> Report {
     let text = FIXTURES.iter().find(|(n, _)| *n == name).unwrap().1;
-    serde_json::from_str(text).unwrap_or_else(|e| panic!("{name} : {e}"))
+    serde_json::from_str(text).unwrap_or_else(|e| panic!("{name}: {e}"))
 }
 
 fn value<'a>(report: &'a Report, section: &str, key: &str) -> &'a Value {
     report
         .section(section)
         .and_then(|s| s.get(key))
-        .unwrap_or_else(|| panic!("{section}.{key} absent"))
+        .unwrap_or_else(|| panic!("{section}.{key} missing"))
 }
 
 #[test]
@@ -49,10 +49,11 @@ fn published_schema_is_up_to_date() {
     if std::env::var_os("UPDATE_SCHEMA").is_some() {
         std::fs::write(SCHEMA_PATH, &generated).unwrap();
     }
-    let published = std::fs::read_to_string(Path::new(SCHEMA_PATH)).expect("schéma publié absent");
+    let published =
+        std::fs::read_to_string(Path::new(SCHEMA_PATH)).expect("published schema missing");
     assert_eq!(
         published, generated,
-        "schéma périmé : relancer avec UPDATE_SCHEMA=1"
+        "stale schema: rerun with UPDATE_SCHEMA=1"
     );
 }
 
@@ -60,7 +61,7 @@ fn published_schema_is_up_to_date() {
 fn fixtures_and_live_report_validate_against_schema() {
     let schema: serde_json::Value =
         serde_json::from_str(&std::fs::read_to_string(SCHEMA_PATH).unwrap()).unwrap();
-    let validator = jsonschema::validator_for(&schema).expect("schéma valide");
+    let validator = jsonschema::validator_for(&schema).expect("valid schema");
     let live = serde_json::to_value(envprobe_core::probe(&[])).unwrap();
     let mut docs: Vec<(&str, serde_json::Value)> = FIXTURES
         .iter()
@@ -69,7 +70,7 @@ fn fixtures_and_live_report_validate_against_schema() {
     docs.push(("live", live));
     for (name, doc) in &docs {
         let errors: Vec<String> = validator.iter_errors(doc).map(|e| e.to_string()).collect();
-        assert!(errors.is_empty(), "{name} : {errors:?}");
+        assert!(errors.is_empty(), "{name}: {errors:?}");
     }
     let broken = serde_json::json!({"schema_version": 1, "envprobe_version": "x", "sections": [
         {"name": "k", "entries": [{"key": "a", "status": "maybe", "value": "v", "privileged": false}]}
@@ -105,7 +106,7 @@ fn host_vs_alpine_differs_in_userspace_not_kernel() {
     assert!(changed("packages", "managers"));
     assert!(
         d.iter().all(|s| s.name() != "kernel"),
-        "même noyau, aucune différence attendue"
+        "same kernel, no difference expected"
     );
     assert!(d.iter().all(|s| s.name() != "btf"));
     assert_eq!(value(&alpine, "libc", "kind"), &Value::ok("musl"));
@@ -124,7 +125,7 @@ fn debian_rootfs_report() {
     assert!(value(&debian, "fhs", "multiarch")
         .as_ok()
         .unwrap()
-        .starts_with("oui"));
+        .starts_with("yes"));
     assert_eq!(value(&debian, "shell", "sh"), &Value::ok("/usr/bin/dash"));
 }
 
@@ -133,8 +134,8 @@ fn user_vs_root_differs_on_privileges_only() {
     let user = load("archarm-orbstack-user");
     let root = load("archarm-orbstack-root");
     assert_eq!(value(&user, "bpf", "syscall"), &Value::denied("EPERM"));
-    assert_eq!(value(&root, "bpf", "syscall"), &Value::ok("disponible"));
-    assert_eq!(value(&root, "privileges", "CAP_BPF"), &Value::ok("oui"));
+    assert_eq!(value(&root, "bpf", "syscall"), &Value::ok("available"));
+    assert_eq!(value(&root, "privileges", "CAP_BPF"), &Value::ok("yes"));
     for s in diff(&user, &root) {
         assert!(
             [
@@ -147,7 +148,7 @@ fn user_vs_root_differs_on_privileges_only() {
                 "xdg"
             ]
             .contains(&s.name()),
-            "section inattendue : {}",
+            "unexpected section: {}",
             s.name()
         );
     }
@@ -159,6 +160,6 @@ fn user_namespace_is_reported_in_rootfs() {
     assert!(value(&alpine, "privileges", "user_namespace")
         .as_ok()
         .unwrap()
-        .starts_with("non initial"));
+        .starts_with("non-initial"));
     assert_eq!(value(&alpine, "bpf", "syscall"), &Value::denied("EPERM"));
 }
diff --git a/crates/envprobe/Cargo.toml b/crates/envprobe/Cargo.toml
index 346e4a9..baef461 100644
--- a/crates/envprobe/Cargo.toml
+++ b/crates/envprobe/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "envprobe"
-description = "Décrit l'environnement Linux courant"
+description = "Describes the current Linux environment"
 version.workspace = true
 edition.workspace = true
 license.workspace = true
diff --git a/crates/envprobe/src/main.rs b/crates/envprobe/src/main.rs
index 03973a7..320f10a 100644
--- a/crates/envprobe/src/main.rs
+++ b/crates/envprobe/src/main.rs
@@ -7,33 +7,33 @@ use clap::{Parser, Subcommand, ValueEnum};
 use envprobe_core::diff::{self, Change, SectionDiff};
 use envprobe_core::{Report, Value, SCHEMA_VERSION};
 
-/// Décrit l'environnement Linux courant (userspace + kernel).
+/// Describes the current Linux environment (userspace + kernel).
 #[derive(Parser, Debug)]
 #[command(version, about, args_conflicts_with_subcommands = true)]
 struct Cli {
     #[command(subcommand)]
     command: Option<Command>,
 
-    /// Rapport JSON complet sur stdout.
+    /// Full JSON report on stdout.
     #[arg(long)]
     json: bool,
 
-    /// Sections à sonder, séparées par des virgules (par exemple kernel,bpf).
+    /// Sections to probe, comma-separated (for example kernel,bpf).
     #[arg(long, value_delimiter = ',')]
     section: Vec<String>,
 }
 
 #[derive(Subcommand, Debug)]
 enum Command {
-    /// Compare deux rapports JSON ; code de sortie 1 s'ils diffèrent.
+    /// Compares two JSON reports; exit code 1 if they differ.
     Diff {
         a: PathBuf,
         b: PathBuf,
-        /// Couleurs dans la sortie.
+        /// Colors in the output.
         #[arg(long, value_enum, default_value_t = Color::Auto)]
         color: Color,
     },
-    /// Affiche le schéma JSON du rapport.
+    /// Prints the JSON schema of the report.
     Schema,
 }
 
@@ -63,7 +63,7 @@ fn run_probe(sections: &[String], json: bool) -> Result<ExitCode, String> {
     let known: Vec<&str> = envprobe_core::section_names().collect();
     if let Some(bad) = sections.iter().find(|s| !known.contains(&s.as_str())) {
         return Err(format!(
-            "section inconnue « {bad} » (connues : {})",
+            "unknown section \"{bad}\" (known: {})",
             known.join(", ")
         ));
     }
@@ -77,7 +77,7 @@ fn run_probe(sections: &[String], json: bool) -> Result<ExitCode, String> {
     Ok(ExitCode::SUCCESS)
 }
 
-/// Un lecteur fermé (`envprobe | head`) n'est pas une erreur.
+/// A closed reader (`envprobe | head`) is not an error.
 fn quiet_epipe(res: io::Result<()>) -> Result<(), String> {
     match res {
         Err(e) if e.kind() == io::ErrorKind::BrokenPipe => Ok(()),
@@ -106,13 +106,13 @@ fn print_text(report: &Report) -> io::Result<()> {
             writeln!(out, "  {:<width$}  {}{mark}", entry.key, entry.value)?;
         }
     }
-    writeln!(out, "\n* résultat dépendant des privilèges")
+    writeln!(out, "\n* result depends on privileges")
 }
 
 fn load_report(path: &Path) -> Result<Report, String> {
-    let text = fs::read_to_string(path).map_err(|e| format!("{} : {e}", path.display()))?;
+    let text = fs::read_to_string(path).map_err(|e| format!("{}: {e}", path.display()))?;
     let raw: serde_json::Value = serde_json::from_str(&text)
-        .map_err(|e| format!("{} : JSON invalide : {e}", path.display()))?;
+        .map_err(|e| format!("{}: invalid JSON: {e}", path.display()))?;
     match raw
         .get("schema_version")
         .and_then(serde_json::Value::as_u64)
@@ -120,13 +120,13 @@ fn load_report(path: &Path) -> Result<Report, String> {
         Some(v) if v == u64::from(SCHEMA_VERSION) => {}
         Some(v) => {
             return Err(format!(
-                "{} : schema_version {v} non pris en charge (attendu {SCHEMA_VERSION})",
+                "{}: unsupported schema_version {v} (expected {SCHEMA_VERSION})",
                 path.display()
             ))
         }
-        None => return Err(format!("{} : schema_version absent", path.display())),
+        None => return Err(format!("{}: schema_version missing", path.display())),
     }
-    serde_json::from_value(raw).map_err(|e| format!("{} : rapport invalide : {e}", path.display()))
+    serde_json::from_value(raw).map_err(|e| format!("{}: invalid report: {e}", path.display()))
 }
 
 struct Palette {
@@ -175,12 +175,12 @@ fn run_diff(a_path: &Path, b_path: &Path, color: Color) -> Result<ExitCode, Stri
             match d {
                 SectionDiff::OnlyInA(_) => writeln!(
                     out,
-                    "{}- section absente du second rapport{}",
+                    "{}- section missing from the second report{}",
                     p.minus, p.reset
                 )?,
                 SectionDiff::OnlyInB(_) => writeln!(
                     out,
-                    "{}+ section absente du premier rapport{}",
+                    "{}+ section missing from the first report{}",
                     p.plus, p.reset
                 )?,
                 SectionDiff::Changed { changes, .. } => {
@@ -196,9 +196,9 @@ fn run_diff(a_path: &Path, b_path: &Path, color: Color) -> Result<ExitCode, Stri
             }
         }
         if diffs.is_empty() {
-            writeln!(out, "\naucune différence")?;
+            writeln!(out, "\nno differences")?;
         } else {
-            writeln!(out, "\n{} section(s) différente(s)", diffs.len())?;
+            writeln!(out, "\n{} section(s) differ", diffs.len())?;
         }
         Ok(())
     })();
diff --git a/distroproof.toml b/distroproof.toml
index 3f03290..19825e3 100644
--- a/distroproof.toml
+++ b/distroproof.toml
@@ -1,8 +1,8 @@
-# Matrice de dogfooding : envprobe testé par distroproof sur les distros
-# cibles, avec des variantes de noyau et de privilèges.
+# Dogfooding matrix: envprobe tested by distroproof on the target distros,
+# with kernel and privilege variants.
 #
-#   distroproof up                    # TUI si terminal, sinon texte
-#   distroproof up --markdown out.md  # résumé pour un commentaire de PR
+#   distroproof up                    # TUI in a terminal, text otherwise
+#   distroproof up --markdown out.md  # summary for a PR comment
 
 [defaults]
 memory = "1G"
@@ -37,7 +37,7 @@ image = "arch"
 name = "alpine"
 image = "alpine"
 
-# Variantes : perf verrouillé, lockdown, PMU masquée avec capabilities.
+# Variants: locked-down perf, lockdown, hidden PMU with capabilities.
 [[target]]
 name = "ubuntu-paranoid"
 image = "ubuntu-22.04"
diff --git a/docs/ROADMAP.md b/docs/ROADMAP.md
index 3a0c9a3..721892b 100644
--- a/docs/ROADMAP.md
+++ b/docs/ROADMAP.md
@@ -1,124 +1,124 @@
-# Roadmap — distroproof (POC Rust)
+# Roadmap — distroproof (Rust POC)
 
 Oct 9, 2026 · @Mohamed Bekheira
 
-## Vision et conventions
+## Vision and conventions
 
-Objectif du POC : un outil Rust qui décrit précisément un environnement Linux (userspace + kernel), puis lance des VM « distro cible » pour y exécuter un programme et comparer les résultats. Nom : `distroproof`. On commence par la sonde (`envprobe`), seule et utile dès la phase 1.
+POC goal: a Rust tool that precisely describes a Linux environment (userspace + kernel), then starts "target distro" VMs to run a program in them and compare the results. Name: `distroproof`. We start with the probe (`envprobe`), standalone and useful from phase 1.
 
-Chaque phase est autonome : un agent la réalise sans lire les suivantes. Une phase n'est terminée que lorsque tous ses critères de sortie sont cochés.
+Each phase is self-contained: an agent completes it without reading the following ones. A phase is only done when all its exit criteria are checked.
 
-Règles pour l'agent, valables à toutes les phases :
+Rules for the agent, valid in every phase:
 
-- Rust stable, édition 2021, workspace Cargo. `cargo fmt`, `cargo clippy -- -D warnings` et `cargo test` passent avant chaque commit.
-- La sonde ne plante jamais : chaque information absente ou inaccessible devient une valeur `Unknown` / `Unavailable` avec la raison (permission, fichier absent, syscall refusé).
-- Sonder les fonctionnalités, ne jamais déduire depuis un numéro de version (backports RHEL).
-- La sonde n'a aucun effet de bord : lecture seule, pas d'écriture de sysctl, pas de chargement durable de programme BPF.
-- Binaire de la sonde compilé en statique (`x86_64-unknown-linux-musl`) pour tourner tel quel dans n'importe quelle VM cible.
-- Dépendances minimales et justifiées dans le message de commit. Pas de `unsafe` hors d'un module `sys` dédié et commenté.
-- Ne pas présumer root : chaque sonde indique si le résultat dépend des privilèges.
+- Stable Rust, 2021 edition, Cargo workspace. `cargo fmt`, `cargo clippy -- -D warnings` and `cargo test` pass before every commit.
+- The probe never crashes: any missing or inaccessible information becomes an `Unknown` / `Unavailable` value with the reason (permission, missing file, refused syscall).
+- Probe features, never infer from a version number (RHEL backports).
+- The probe has no side effects: read-only, no sysctl writes, no persistent BPF program loading.
+- The probe binary is built statically (`x86_64-unknown-linux-musl`) so it runs as is in any target VM.
+- Minimal dependencies, justified in the commit message. No `unsafe` outside a dedicated, commented `sys` module.
+- Don't assume root: each probe states whether its result depends on privileges.
 
-## Phase 0 — Setup du projet
+## Phase 0 — Project setup
 
-But : un squelette qui compile en statique et tourne en CI, avant toute fonctionnalité.
+Goal: a skeleton that builds statically and runs in CI, before any feature.
 
-Tâches :
+Tasks:
 
-1. Créer un workspace Cargo avec trois crates : `envprobe-core` (lib, les sondes), `envprobe` (binaire CLI) et `distroproof` (binaire orchestrateur, vide pour l'instant).
-2. Ajouter la cible musl et un profil release optimisé taille (`lto`, `strip`, `opt-level = "s"`).
-3. CLI avec `clap` : `envprobe` sans argument affiche un résumé lisible ; `--json` est réservé pour la phase 2.
-4. CI GitHub Actions : fmt, clippy, tests, build musl, et vérification que le binaire est bien statique (`file` ou `ldd` → « not a dynamic executable »).
-5. `README.md` court et ce fichier de roadmap dans `docs/ROADMAP.md`.
+1. Create a Cargo workspace with three crates: `envprobe-core` (lib, the probes), `envprobe` (CLI binary) and `distroproof` (orchestrator binary, empty for now).
+2. Add the musl target and a size-optimized release profile (`lto`, `strip`, `opt-level = "s"`).
+3. CLI with `clap`: `envprobe` with no argument prints a human-readable summary; `--json` is reserved for phase 2.
+4. GitHub Actions CI: fmt, clippy, tests, musl build, and a check that the binary is really static (`file` or `ldd` → "not a dynamic executable").
+5. A short `README.md` and this roadmap file in `docs/ROADMAP.md`.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] `cargo build --release --target x86_64-unknown-linux-musl` produit un binaire statique.
-- [x] La CI est verte sur une PR vide.
-- [x] `envprobe --version` fonctionne.
+- [x] `cargo build --release --target x86_64-unknown-linux-musl` produces a static binary.
+- [x] CI is green on an empty PR.
+- [x] `envprobe --version` works.
 
-## Phase 1 — Sonde d'environnement (envprobe)
+## Phase 1 — Environment probe (envprobe)
 
-But : `envprobe` affiche tout ce qui peut changer le comportement d'un programme userspace ou kernel-facing (perf, BPF) sur la machine courante. Un module Rust par catégorie, chacun exposant une fonction `probe() -> Section`.
+Goal: `envprobe` shows everything that can change the behavior of a userspace or kernel-facing program (perf, BPF) on the current machine. One Rust module per category, each exposing a `probe() -> Section` function.
 
-Ordre conseillé : identité et kernel d'abord, puis userspace, puis BPF/perf (le plus délicat).
+Suggested order: identity and kernel first, then userspace, then BPF/perf (the trickiest).
 
-| Catégorie | Informations | Sources |
+| Category | Information | Sources |
 | --- | --- | --- |
-| Identité | distro, version, famille (`ID_LIKE`), arch, virtualisé ou non, conteneur ou non | `/etc/os-release`, `uname()`, `/sys/class/dmi/id/*`, `/proc/1/cgroup`, `/.dockerenv`, `/run/systemd/container` |
-| Kernel | version, release, cmdline, config (`CONFIG_BPF*`, `KPROBES`, `UPROBES`, `FTRACE`, `DEBUG_INFO_BTF`, `PERF_EVENTS`) | `uname()`, `/proc/cmdline`, `/proc/config.gz` puis `/boot/config-$(uname -r)` |
-| Modules | modules chargés, chargement possible | `/proc/modules`, `/sys/module` |
+| Identity | distro, version, family (`ID_LIKE`), arch, virtualized or not, container or not | `/etc/os-release`, `uname()`, `/sys/class/dmi/id/*`, `/proc/1/cgroup`, `/.dockerenv`, `/run/systemd/container` |
+| Kernel | version, release, cmdline, config (`CONFIG_BPF*`, `KPROBES`, `UPROBES`, `FTRACE`, `DEBUG_INFO_BTF`, `PERF_EVENTS`) | `uname()`, `/proc/cmdline`, `/proc/config.gz` then `/boot/config-$(uname -r)` |
+| Modules | loaded modules, whether loading is possible | `/proc/modules`, `/sys/module` |
 | Sysctls | `perf_event_paranoid`, `perf_event_max_sample_rate`, `unprivileged_bpf_disabled`, `bpf_jit_enable`, `bpf_jit_harden`, `kptr_restrict`, `dmesg_restrict`, `yama.ptrace_scope` | `/proc/sys/kernel/*`, `/proc/sys/net/core/*` |
-| Sécurité | LSM actifs, mode SELinux, profils AppArmor, lockdown, Secure Boot | `/sys/kernel/security/lsm`, `/sys/fs/selinux/enforce`, `/sys/kernel/security/apparmor`, `/sys/kernel/security/lockdown`, efivars |
-| Privilèges | uid/euid, capabilities effectives (`CAP_BPF`, `CAP_PERFMON`, `CAP_SYS_ADMIN`), seccomp, `NoNewPrivs` | `/proc/self/status` (`CapEff`, `Seccomp`) |
-| BTF | présence et taille de vmlinux BTF, BTF des modules | `/sys/kernel/btf/vmlinux`, `/sys/kernel/btf/*` |
-| BPF | types de programmes, types de maps, helpers clés, JIT | appels `bpf(BPF_PROG_LOAD)` minimaux, équivalent de `bpftool feature probe` |
-| perf | `perf_event_open` en mode logiciel et matériel, PMU disponibles | appel test sur `PERF_COUNT_SW_CPU_CLOCK` et `PERF_COUNT_HW_CPU_CYCLES`, `/sys/bus/event_source/devices` |
-| Tracing | tracefs monté et où, debugfs, kallsyms lisible | `/proc/mounts`, `/sys/kernel/tracing`, `/sys/kernel/debug/tracing`, `/proc/kallsyms` |
-| libc | glibc ou musl, version | `gnu_get_libc_version()` si dispo, sinon lecture de `/lib/ld-musl-*` ou de l'interpréteur ELF de `/bin/sh` |
-| Libs | présence et version des libs courantes (libbpf, libelf, zlib, openssl, libz) | `ldconfig -p` si dispo, sinon scan de `/lib`, `/lib64`, `/usr/lib*` |
-| FHS | merged-usr, `/lib64` existe, multiarch Debian, chemins des libs | liens symboliques de `/bin`, `/lib`, `/sbin` ; `/usr/lib/x86_64-linux-gnu` |
-| Shell et outils | cible de `/bin/sh`, coreutils GNU ou busybox | `readlink /bin/sh`, `/bin/ls` vers busybox |
-| Init et services | PID 1 (systemd, OpenRC, runit…) | `/proc/1/comm`, `/proc/1/exe` |
-| Gestionnaire de paquets | apt, dnf, pacman, zypper, apk, xbps, nix | présence des binaires dans le `PATH` |
-| cgroups | v1, v2 ou hybride | `/sys/fs/cgroup`, `/proc/mounts` |
-| XDG | variables définies et valeurs effectives | variables d'environnement |
+| Security | active LSMs, SELinux mode, AppArmor profiles, lockdown, Secure Boot | `/sys/kernel/security/lsm`, `/sys/fs/selinux/enforce`, `/sys/kernel/security/apparmor`, `/sys/kernel/security/lockdown`, efivars |
+| Privileges | uid/euid, effective capabilities (`CAP_BPF`, `CAP_PERFMON`, `CAP_SYS_ADMIN`), seccomp, `NoNewPrivs` | `/proc/self/status` (`CapEff`, `Seccomp`) |
+| BTF | presence and size of vmlinux BTF, module BTF | `/sys/kernel/btf/vmlinux`, `/sys/kernel/btf/*` |
+| BPF | program types, map types, key helpers, JIT | minimal `bpf(BPF_PROG_LOAD)` calls, equivalent to `bpftool feature probe` |
+| perf | software and hardware `perf_event_open`, available PMUs | test call on `PERF_COUNT_SW_CPU_CLOCK` and `PERF_COUNT_HW_CPU_CYCLES`, `/sys/bus/event_source/devices` |
+| Tracing | tracefs mounted and where, debugfs, kallsyms readable | `/proc/mounts`, `/sys/kernel/tracing`, `/sys/kernel/debug/tracing`, `/proc/kallsyms` |
+| libc | glibc or musl, version | `gnu_get_libc_version()` if available, otherwise read `/lib/ld-musl-*` or the ELF interpreter of `/bin/sh` |
+| Libs | presence and version of common libs (libbpf, libelf, zlib, openssl, libz) | `ldconfig -p` if available, otherwise scan `/lib`, `/lib64`, `/usr/lib*` |
+| FHS | merged-usr, `/lib64` exists, Debian multiarch, library paths | symlinks of `/bin`, `/lib`, `/sbin`; `/usr/lib/x86_64-linux-gnu` |
+| Shell and tools | target of `/bin/sh`, GNU coreutils or busybox | `readlink /bin/sh`, `/bin/ls` pointing to busybox |
+| Init and services | PID 1 (systemd, OpenRC, runit…) | `/proc/1/comm`, `/proc/1/exe` |
+| Package manager | apt, dnf, pacman, zypper, apk, xbps, nix | binaries present in `PATH` |
+| cgroups | v1, v2 or hybrid | `/sys/fs/cgroup`, `/proc/mounts` |
+| XDG | defined variables and effective values | environment variables |
 
-Les sondes BPF et perf doivent utiliser des syscalls directs (via le crate `libc` ou `nix`), sans dépendre de libbpf, pour garder un binaire statique simple. Un échec `EPERM` ou `EACCES` est un résultat, pas une erreur.
+The BPF and perf probes must use direct syscalls (through the `libc` or `nix` crate), without depending on libbpf, to keep a simple static binary. An `EPERM` or `EACCES` failure is a result, not an error.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Toutes les catégories du tableau sont implémentées.
-- [x] Exécuté en utilisateur normal puis en root, la sortie diffère là où c'est attendu (privilèges, BPF, perf).
-- [x] Exécuté dans un conteneur Docker par défaut, la sonde détecte le conteneur et le seccomp sans planter.
-- [x] Tests unitaires sur les parseurs (`os-release`, `config.gz`, `/proc/self/status`) avec des fixtures de plusieurs distros.
+- [x] Every category in the table is implemented.
+- [x] Run as a normal user then as root, the output differs where expected (privileges, BPF, perf).
+- [x] Run in a default Docker container, the probe detects the container and seccomp without crashing.
+- [x] Unit tests on the parsers (`os-release`, `config.gz`, `/proc/self/status`) with fixtures from several distros.
 
-## Phase 2 — Sortie structurée et diff
+## Phase 2 — Structured output and diff
 
-But : rendre le rapport exploitable par une machine et comparer deux environnements, base de toute la suite.
+Goal: make the report machine-readable and compare two environments, the foundation for everything that follows.
 
-Tâches :
+Tasks:
 
-1. Modèle de données versionné (`schema_version`) avec `serde`. Chaque valeur porte son statut : `Ok(valeur)`, `Unavailable(raison)`, `Denied(errno)`.
-2. `envprobe --json` écrit le rapport complet sur stdout ; `--section kernel,bpf` filtre.
-3. Schéma JSON publié dans le dépôt, généré avec `schemars`.
-4. Sous-commande `envprobe diff a.json b.json` : affiche les différences par section, en couleur, avec un code de sortie non nul s'il y en a.
-5. Collecter des rapports réels comme fixtures : ta machine, un conteneur Debian, un conteneur Alpine, plus tout ce que tu as sous la main.
+1. Versioned data model (`schema_version`) with `serde`. Each value carries its status: `Ok(value)`, `Unavailable(reason)`, `Denied(errno)`.
+2. `envprobe --json` writes the full report to stdout; `--section kernel,bpf` filters it.
+3. JSON schema published in the repository, generated with `schemars`.
+4. `envprobe diff a.json b.json` subcommand: shows the differences per section, in color, with a non-zero exit code if there are any.
+5. Collect real reports as fixtures: your machine, a Debian container, an Alpine container, plus anything else at hand.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Le JSON valide contre le schéma publié.
-- [x] `diff` entre ta machine et un conteneur Alpine fait ressortir libc, `/bin/sh` et gestionnaire de paquets, mais pas le kernel (même noyau).
-- [x] Tests de non-régression sur au moins trois fixtures.
+- [x] The JSON validates against the published schema.
+- [x] `diff` between your machine and an Alpine container shows libc, `/bin/sh` and the package manager, but not the kernel (same kernel).
+- [x] Regression tests on at least three fixtures.
 
-## Phase 3 — VM avec noyau et rootfs de distro
+## Phase 3 — VM with the distro's kernel and rootfs
 
-But : `distroproof run --target debian-12 -- envprobe --json` démarre une VM avec le **vrai noyau de la distro** et son rootfs, y lance la commande et récupère la sortie. C'est la phase la plus risquée : commencer par une seule cible qui marche de bout en bout.
+Goal: `distroproof run --target debian-12 -- envprobe --json` starts a VM with the **real distro kernel** and its rootfs, runs the command in it and collects the output. This is the riskiest phase: start with a single target that works end to end.
 
-Tâches :
+Tasks:
 
-1. Choix techniques : QEMU + KVM piloté en sous-processus (pas de lib de virtualisation au début). Images cloud officielles des distros (qcow2) comme source, car elles contiennent noyau, initramfs et config d'origine.
-2. Cache local dans `$XDG_CACHE_HOME/distroproof/images` : téléchargement, vérification du checksum publié, overlay qcow2 jetable par exécution.
-3. Injection : partage du répertoire de travail via virtiofs ou 9p, ou à défaut une seconde image disque. Configuration initiale via cloud-init (seed ISO) pour créer l'utilisateur et lancer la commande.
-4. Récupération de stdout, stderr et du code de retour via la console série (`-serial`) ou virtio-vsock, puis extinction propre de la VM.
-5. Timeouts et nettoyage garantis, même si la VM ne boote pas.
-6. Cibles dans l'ordre : `debian-12`, `ubuntu-22.04`, `rocky-9`, `rocky-8`, `fedora-latest`, `arch`, `alpine`.
+1. Technical choices: QEMU + KVM driven as a subprocess (no virtualization library at first). Official distro cloud images (qcow2) as the source, since they contain the original kernel, initramfs and config.
+2. Local cache in `$XDG_CACHE_HOME/distroproof/images`: download, verification of the published checksum, throwaway qcow2 overlay per run.
+3. Injection: share the working directory through virtiofs or 9p, or failing that a second disk image. Initial configuration through cloud-init (seed ISO) to create the user and start the command.
+4. Collect stdout, stderr and the exit code through the serial console (`-serial`) or virtio-vsock, then shut the VM down cleanly.
+5. Guaranteed timeouts and cleanup, even if the VM fails to boot.
+6. Targets in order: `debian-12`, `ubuntu-22.04`, `rocky-9`, `rocky-8`, `fedora-latest`, `arch`, `alpine`.
 
-Exigence d'architecture (prépare la phase 6) : l'orchestrateur n'écrit jamais directement dans le terminal. Il émet des événements typés, par exemple `VmEvent { Downloading, Booting, Running, Output(line), Metrics(..), Exited(code), TimedOut }`, dans un channel tokio. La sortie texte, la sortie JSON et plus tard la TUI ne sont que des consommateurs de ce flux. Le PID de chaque processus QEMU et un socket QMP par VM (`-qmp unix:...`) sont exposés dès cette phase.
+Architecture requirement (prepares phase 6): the orchestrator never writes directly to the terminal. It emits typed events, for example `VmEvent { Downloading, Booting, Running, Output(line), Metrics(..), Exited(code), TimedOut }`, on a tokio channel. The text output, the JSON output and later the TUI are only consumers of this stream. The PID of each QEMU process and one QMP socket per VM (`-qmp unix:...`) are exposed from this phase on.
 
-Piste d'accélération à évaluer ensuite : extraire noyau et initramfs de l'image et booter en direct (`-kernel`, `-initrd`), à la manière de virtme-ng, pour passer sous les 5 secondes.
+Speed-up to evaluate afterwards: extract the kernel and initramfs from the image and boot them directly (`-kernel`, `-initrd`), like virtme-ng does, to get under 5 seconds.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Les 7 cibles bootent et renvoient un rapport `envprobe` JSON.
-- [x] Le rapport de chaque VM montre bien le noyau de la distro (4.18 sur Rocky 8, 5.14 sur Rocky 9…) et non celui de l'hôte.
-- [x] Une exécution répétée réutilise le cache et laisse le disque propre.
-- [x] Temps de boot mesuré et affiché par cible.
+- [x] The 7 targets boot and return a JSON `envprobe` report.
+- [x] Each VM's report shows the distro's kernel (4.18 on Rocky 8, 5.14 on Rocky 9…) and not the host's.
+- [x] A repeated run reuses the cache and leaves the disk clean.
+- [x] Boot time is measured and shown per target.
 
-## Phase 4 — Fichier déclaratif et matrice
+## Phase 4 — Declarative file and matrix
 
-But : décrire sa matrice de test dans un fichier versionné du projet testé, à la manière d'une infra as code. `distroproof up` lit le fichier et lance toutes les cibles en parallèle.
+Goal: describe the test matrix in a versioned file of the project under test, infrastructure-as-code style. `distroproof up` reads the file and runs every target in parallel.
 
-Exemple de format visé (`distroproof.toml`) :
+Target format example (`distroproof.toml`):
 
 ```toml
 [defaults]
@@ -142,78 +142,78 @@ kernel_cmdline = "lockdown=confidentiality"
 
 [run]
 setup = "./scripts/install-deps.sh"
-command = "./target/release/montool --selftest"
-as_user = "test"   # ou "root"
+command = "./target/release/mytool --selftest"
+as_user = "test"   # or "root"
 ```
 
-Tâches :
+Tasks:
 
-1. Parser et valider le fichier (`serde` + `toml`), messages d'erreur avec ligne et colonne.
-2. Variantes par cible : sysctls, cmdline noyau, utilisateur root ou non, capabilities accordées, PMU exposée ou non (`-cpu host` vs modèle générique).
-3. Exécution parallèle bornée (`--jobs`), avec affichage de la progression par cible.
-4. `envprobe` est lancé automatiquement avant la commande de l'utilisateur et son rapport joint au résultat.
+1. Parse and validate the file (`serde` + `toml`), with error messages giving line and column.
+2. Per-target variants: sysctls, kernel cmdline, root or non-root user, granted capabilities, PMU exposed or not (`-cpu host` vs a generic model).
+3. Bounded parallel execution (`--jobs`), with per-target progress display.
+4. `envprobe` runs automatically before the user's command and its report is attached to the result.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Une matrice de 5 cibles avec variantes tourne en une commande.
-- [x] Le rapport `envprobe` de chaque cible reflète bien les variantes demandées (paranoid, lockdown).
-- [x] Un fichier invalide donne une erreur claire sans lancer de VM.
+- [x] A 5-target matrix with variants runs in one command.
+- [x] Each target's `envprobe` report reflects the requested variants (paranoid, lockdown).
+- [x] An invalid file gives a clear error without starting any VM.
 
-## Phase 5 — Tests et rapport
+## Phase 5 — Tests and report
 
-But : savoir en un coup d'œil où le programme marche, où il casse, et pourquoi, en reliant chaque échec à une différence d'environnement.
+Goal: see at a glance where the program works, where it breaks, and why, by tying each failure to an environment difference.
 
-Tâches :
+Tasks:
 
-1. Rapport de matrice : tableau cibles × résultat (succès, échec, timeout), durée, extrait de stderr.
-2. Corrélation : pour chaque cible en échec, `envprobe diff` automatique contre la cible réussie la plus proche, pour pointer le suspect (BTF absent, paranoid à 3, musl…).
-3. Formats de sortie : terminal, JSON, JUnit XML (pour la CI) et Markdown (pour un commentaire de PR).
-4. Intégration CI : exemple de workflow GitHub Actions avec KVM activé et cache des images.
-5. Dogfooding : faire tourner `envprobe` lui-même dans la matrice comme premier projet testé.
+1. Matrix report: targets × result table (success, failure, timeout), duration, stderr excerpt.
+2. Correlation: for each failed target, an automatic `envprobe diff` against the closest successful target, to point out the suspect (missing BTF, paranoid set to 3, musl…).
+3. Output formats: terminal, JSON, JUnit XML (for CI) and Markdown (for a PR comment).
+4. CI integration: example GitHub Actions workflow with KVM enabled and image caching.
+5. Dogfooding: run `envprobe` itself in the matrix as the first project under test.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Un échec volontaire (programme exigeant BTF) est détecté sur une cible sans BTF, et le rapport désigne BTF comme cause probable.
-- [x] La matrice tourne en CI sur une PR et publie un résumé Markdown.
+- [x] A deliberate failure (a program requiring BTF) is detected on a target without BTF, and the report names BTF as the probable cause.
+- [x] The matrix runs in CI on a PR and publishes a Markdown summary.
 
-## Phase 6 — TUI de monitoring
+## Phase 6 — Monitoring TUI
 
-But : une TUI moderne qui donne la vue d'ensemble de la matrice en temps réel, dans l'esprit de [btop](https://github.com/aristocratos/btop) pour les graphes et jauges, et de [TUIOS](https://github.com/Gaurav-Gosain/tuios) pour la gestion des panneaux (tiling, interface modale façon vim, palette de commandes). Elle se branche uniquement sur le bus d'événements de la phase 3, sans toucher à l'orchestrateur.
+Goal: a modern TUI giving a real-time overview of the matrix, in the spirit of [btop](https://github.com/aristocratos/btop) for graphs and gauges, and of [TUIOS](https://github.com/Gaurav-Gosain/tuios) for pane management (tiling, vim-style modal interface, command palette). It plugs only into the phase 3 event bus, without touching the orchestrator.
 
-Stack : `ratatui` + `crossterm`, `tokio` pour la boucle d'événements, `tui-term` + `vt100` pour afficher la console série d'une VM dans un panneau avec ses séquences ANSI.
+Stack: `ratatui` + `crossterm`, `tokio` for the event loop, `tui-term` + `vt100` to show a VM's serial console in a pane with its ANSI sequences.
 
-Vues :
+Views:
 
-- **Dashboard** : une carte par cible (style btop) avec état coloré, temps de boot, durée, jauges CPU et mémoire, sparkline de charge sur les dernières secondes.
-- **Détail** : logs série en direct de la cible sélectionnée, avec défilement et recherche.
-- **Rapport** : le rapport `envprobe` de la cible et son diff contre une autre cible, sections repliables.
-- **Console** : console série interactive d'une VM dans un panneau, pour déboguer à la main.
-- **Layout** : panneaux en tiling redimensionnables, plusieurs workspaces (une matrice par workspace, par exemple).
+- **Dashboard**: one card per target (btop style) with colored state, boot time, duration, CPU and memory gauges, load sparkline over the last seconds.
+- **Detail**: live serial logs of the selected target, with scrolling and search.
+- **Report**: the target's `envprobe` report and its diff against another target, with collapsible sections.
+- **Console**: interactive serial console of a VM in a pane, for manual debugging.
+- **Layout**: resizable tiled panes, several workspaces (one matrix per workspace, for example).
 
-Métriques : CPU et mémoire lus depuis `/proc/<pid QEMU>/stat` et `/proc/<pid>/status` (rafraîchissement 1 s), état de la VM et stats mémoire invité via QMP (`query-status`, balloon), débit disque et réseau via `query-blockstats`.
+Metrics: CPU and memory read from `/proc/<QEMU pid>/stat` and `/proc/<pid>/status` (1 s refresh), VM state and guest memory stats through QMP (`query-status`, balloon), disk and network throughput through `query-blockstats`.
 
-Interactions :
+Interactions:
 
-- Navigation modale façon vim (`hjkl`, `/` pour chercher), palette de commandes sur `:` ou `Ctrl+P`, support souris.
-- Actions sur une cible : relancer, tuer, mettre en pause et reprendre (QMP `stop` / `cont`), ouvrir la console, lancer un diff.
-- Filtrer les cibles par état (échecs seulement, en cours…).
+- Vim-style modal navigation (`hjkl`, `/` to search), command palette on `:` or `Ctrl+P`, mouse support.
+- Actions on a target: restart, kill, pause and resume (QMP `stop` / `cont`), open the console, start a diff.
+- Filter targets by state (failures only, running…).
 
-Rendu : thèmes configurables dans `$XDG_CONFIG_HOME/distroproof/theme.toml`, true color avec repli 256 couleurs, caractères Braille pour les graphes comme btop. Activée seulement si stdout est un TTY ou avec `--tui` ; sinon repli automatique sur la sortie texte, ce qui garde la CI intacte.
+Rendering: themes configurable in `$XDG_CONFIG_HOME/distroproof/theme.toml`, true color with a 256-color fallback, Braille characters for graphs like btop. Enabled only if stdout is a TTY or with `--tui`; otherwise automatic fallback to text output, which keeps CI intact.
 
-Critères de sortie :
+Exit criteria:
 
-- [x] Une matrice de 7 cibles s'affiche en temps réel, avec états, jauges et logs, sans scintillement ni blocage de l'interface pendant les boots.
-- [x] Pause, reprise, relance et kill fonctionnent depuis la TUI.
-- [x] La console série interactive d'une VM est utilisable dans un panneau.
-- [x] Sans TTY, la même commande produit la sortie texte habituelle.
-- [x] La TUI reste fluide sur un terminal de 80 × 24 et s'adapte au redimensionnement.
+- [x] A 7-target matrix is shown in real time, with states, gauges and logs, without flicker or UI freezes during boots.
+- [x] Pause, resume, restart and kill work from the TUI.
+- [x] A VM's interactive serial console is usable in a pane.
+- [x] Without a TTY, the same command produces the usual text output.
+- [x] The TUI stays smooth on an 80 × 24 terminal and adapts to resizing.
 
-## Pistes futures
+## Future directions
 
-Hors POC, à considérer une fois la phase 5 validée :
+Outside the POC, to consider once phase 5 is validated:
 
-- **Boot rapide** : boot direct noyau + initramfs et rootfs partagé en virtiofs, voire microVM (Firecracker, Cloud Hypervisor, libkrun) pour viser la seconde.
-- **Noyaux à la carte** : en plus des noyaux de distro, des noyaux LTS upstream (5.10, 5.15, 6.1, 6.6, 6.12) ou un noyau compilé par l'utilisateur.
-- **Arm64** : mêmes cibles via QEMU TCG ou un runner arm64.
-- **Mode `envprobe` standalone** : distribuer la sonde seule, comme `doctor` intégrable dans n'importe quel outil perf/BPF.
-- **Base de profils** : publier les rapports `envprobe` des distros courantes pour comparer sans même lancer de VM.
+- **Fast boot**: direct kernel + initramfs boot and a rootfs shared over virtiofs, or even microVMs (Firecracker, Cloud Hypervisor, libkrun) to aim for one second.
+- **Kernels on demand**: besides distro kernels, upstream LTS kernels (5.10, 5.15, 6.1, 6.6, 6.12) or a user-built kernel.
+- **Arm64**: the same targets through QEMU TCG or an arm64 runner.
+- **Standalone `envprobe`**: ship the probe on its own, as a `doctor` that any perf/BPF tool can embed.
+- **Profile database**: publish `envprobe` reports for common distros, to compare without even starting a VM.
diff --git a/docs/how-to-use/demo.md b/docs/how-to-use/demo.md
index 9681b40..7affae8 100644
--- a/docs/how-to-use/demo.md
+++ b/docs/how-to-use/demo.md
@@ -1,82 +1,81 @@
-# Démo de distroproof
+# distroproof demo
 
-Six actes, du plus simple au plus complet. Les cinq premiers sont scriptés
-par [`scripts/demo.sh`](../../scripts/demo.sh) ; le sixième, la TUI, se joue
-à la main en suivant le déroulé ci-dessous. Tout tourne sur de vraies VM.
+Six acts, from the simplest to the most complete. The first five are scripted
+by [`scripts/demo.sh`](../../scripts/demo.sh); the sixth, the TUI, is played
+by hand following the walkthrough below. Everything runs on real VMs.
 
-## Préparation
+## Setup
 
 ```sh
-# Arch : sudo pacman -S qemu-base edk2-ovmf ; Debian/Ubuntu : qemu-system-x86 qemu-utils ovmf
+# Arch: sudo pacman -S qemu-base edk2-ovmf ; Debian/Ubuntu: qemu-system-x86 qemu-utils ovmf
 rustup target add x86_64-unknown-linux-musl
 cargo build --release --target x86_64-unknown-linux-musl
 export PATH="$PWD/target/x86_64-unknown-linux-musl/release:$PATH"
 distroproof images pull debian-12 ubuntu-18.04 ubuntu-22.04 rocky-8 rocky-9 alpine
 ```
 
-Le premier `pull` télécharge environ 3 Gio. Lancez une fois chaque cible
-avant la démo : le premier boot extrait noyau et initramfs, les suivants
-bootent en direct en quelques secondes.
+The first `pull` downloads about 3 GiB. Run each target once before the demo:
+the first boot extracts the kernel and initramfs, later ones boot directly in
+a few seconds.
 
 ```sh
-scripts/demo.sh --list   # les actes
-scripts/demo.sh          # actes 1 à 5 (~1 min avec le cache chaud)
-scripts/demo.sh 5        # un seul acte
+scripts/demo.sh --list   # the acts
+scripts/demo.sh          # acts 1 to 5 (~1 min with a warm cache)
+scripts/demo.sh 5        # a single act
 ```
 
-## Actes scriptés
+## Scripted acts
 
-1. **Le catalogue et le cache** : `distroproof images` liste les cibles, leur
-   source et ce qui est déjà en cache (image vérifiée, noyau extrait).
-2. **Le vrai noyau de chaque distro** : `uname -r` sur l'hôte, puis dans
-   Rocky 8 (4.18), Rocky 9 (5.14) et Alpine (`virt`). Ce ne sont pas des
-   conteneurs : chaque VM tourne sur le noyau de sa distro.
-3. **Deux distros, un diff** : rapport `envprobe` dans Debian 12 et dans
-   Alpine, puis `envprobe diff` : libc (glibc → musl), `/bin/sh`, gestionnaire
-   de paquets, et cette fois le noyau aussi.
-4. **Une matrice déclarative** : `distroproof check` valide
-   `distroproof.toml` ; un fichier qui vise une image inexistante est refusé
-   avec ligne et colonne, sans lancer de VM ; puis `distroproof up` lance la
-   matrice de dogfooding avec ses variantes (paranoid, lockdown, PMU masquée).
-5. **Pourquoi ça casse** : [`examples/require-btf`](../../examples/require-btf)
-   exige `/sys/kernel/btf/vmlinux`. Il casse sur Ubuntu 18.04 et distroproof
-   désigne le BTF comme cause probable, puis écrit le résumé Markdown destiné
-   à la PR.
+1. **The catalog and the cache**: `distroproof images` lists the targets,
+   their source and what is already cached (verified image, extracted kernel).
+2. **Each distro's real kernel**: `uname -r` on the host, then in Rocky 8
+   (4.18), Rocky 9 (5.14) and Alpine (`virt`). These are not containers: each
+   VM runs on its distro's kernel.
+3. **Two distros, one diff**: an `envprobe` report in Debian 12 and in Alpine,
+   then `envprobe diff`: libc (glibc → musl), `/bin/sh`, package manager, and
+   this time the kernel too.
+4. **A declarative matrix**: `distroproof check` validates
+   `distroproof.toml`; a file targeting a nonexistent image is rejected with
+   line and column, without starting any VM; then `distroproof up` runs the
+   dogfooding matrix with its variants (paranoid, lockdown, hidden PMU).
+5. **Why it breaks**: [`examples/require-btf`](../../examples/require-btf)
+   requires `/sys/kernel/btf/vmlinux`. It breaks on Ubuntu 18.04 and
+   distroproof names BTF as the probable cause, then writes the Markdown
+   summary meant for the PR.
 
-## Acte 6 — La TUI
+## Act 6 — The TUI
 
 ```sh
 distroproof up --hold
 ```
 
-`--hold` garde chaque VM allumée après la commande, avec un shell root sur la
-console série : c'est ce qui rend la console interactive utilisable une fois
-la matrice terminée. Sans `--hold`, la console montre le boot puis s'arrête
-avec la VM.
+`--hold` keeps each VM up after the command, with a root shell on the serial
+console: that is what makes the interactive console usable once the matrix is
+done. Without `--hold`, the console shows the boot and then stops with the VM.
 
-Déroulé conseillé :
+Suggested walkthrough:
 
-| Étape | Touches | Ce qu'on montre |
+| Step | Keys | What to show |
 | --- | --- | --- |
-| Vue d'ensemble | — | une carte par cible : état, temps de boot, jauges CPU et mémoire, graphe Braille ; l'interface reste fluide pendant les boots |
-| Navigation | `hjkl`, `f` | sélection d'une cible ; `f` filtre : toutes, en cours, échecs, terminées |
-| Logs | `L`, `/` `noyau`, `n` `N` | logs série en direct de la cible, recherche et saut entre occurrences |
-| Pause, reprise | `espace` | `stop` / `cont` via QMP : la jauge CPU retombe à zéro puis repart |
-| Kill, relance | `x`, `r` | la carte passe en échec, puis la VM redémarre sur un overlay neuf |
-| Rapport | `R`, `Entrée`, `h` `l` | rapport `envprobe` replié par section, déplier et replier |
-| Diff | `d`, `d`, `D` | diff contre la cible suivante qui a un rapport ; `D` revient au rapport seul |
-| Console | `c`, `i`, `Ctrl+]` | console série dans un panneau ; `i` pour saisir (`uname -a`, `dmesg \| tail`), `Ctrl+]` pour sortir |
-| Tiling | `Ctrl+W v`, `Ctrl+W s`, `Ctrl+W hjkl`, `Ctrl+W <>+-`, `Ctrl+W q` | découper, changer de panneau, redimensionner, fermer |
-| Épingler | `p` | fixe le panneau sur la cible sélectionnée, pour suivre deux cibles côte à côte |
-| Palette | `:` ou `Ctrl+P` | toutes les actions par leur nom |
-| Aide, sortie | `?`, `q` | `q` deux fois si des VM tournent encore : tout est arrêté et nettoyé |
+| Overview | — | one card per target: state, boot time, CPU and memory gauges, Braille graph; the UI stays smooth during boots |
+| Navigation | `hjkl`, `f` | select a target; `f` filters: all, running, failed, finished |
+| Logs | `L`, `/` `kernel`, `n` `N` | the target's live serial logs, search and jump between matches |
+| Pause, resume | `space` | QMP `stop` / `cont`: the CPU gauge drops to zero, then picks up again |
+| Kill, restart | `x`, `r` | the card turns to failed, then the VM restarts on a fresh overlay |
+| Report | `R`, `Enter`, `h` `l` | `envprobe` report folded by section, expand and collapse |
+| Diff | `d`, `d`, `D` | diff against the next target that has a report; `D` goes back to the plain report |
+| Console | `c`, `i`, `Ctrl+]` | serial console in a pane; `i` to type (`uname -a`, `dmesg \| tail`), `Ctrl+]` to leave |
+| Tiling | `Ctrl+W v`, `Ctrl+W s`, `Ctrl+W hjkl`, `Ctrl+W <>+-`, `Ctrl+W q` | split, switch pane, resize, close |
+| Pin | `p` | pin the pane to the selected target, to follow two targets side by side |
+| Palette | `:` or `Ctrl+P` | every action by name |
+| Help, quit | `?`, `q` | press `q` twice if VMs are still running: everything is stopped and cleaned up |
 
-Plusieurs matrices côte à côte, un workspace par fichier (`1`, `2` pour
-passer de l'une à l'autre) :
+Several matrices side by side, one workspace per file (`1`, `2` to switch
+between them):
 
 ```sh
 distroproof up -f distroproof.toml -f examples/require-btf/distroproof.toml
 ```
 
-Pour vérifier le repli : `distroproof up | cat` donne la sortie texte
-habituelle, sans TUI, comme en CI.
+To check the fallback: `distroproof up | cat` gives the usual text output,
+without the TUI, just like in CI.
diff --git a/examples/require-btf/distroproof.toml b/examples/require-btf/distroproof.toml
index ae1f57b..3d21980 100644
--- a/examples/require-btf/distroproof.toml
+++ b/examples/require-btf/distroproof.toml
@@ -1,5 +1,5 @@
-# Échec volontaire : require-btf.sh casse sur Ubuntu 18.04 (noyau 4.15 sans
-# BTF) et distroproof doit désigner le BTF comme cause probable.
+# Deliberate failure: require-btf.sh breaks on Ubuntu 18.04 (kernel 4.15
+# without BTF) and distroproof must name BTF as the probable cause.
 #
 #   distroproof up -f examples/require-btf/distroproof.toml
 
diff --git a/examples/require-btf/require-btf.sh b/examples/require-btf/require-btf.sh
index 445e04e..244706e 100755
--- a/examples/require-btf/require-btf.sh
+++ b/examples/require-btf/require-btf.sh
@@ -1,9 +1,9 @@
 #!/bin/sh
-# Programme exigeant le BTF du noyau, comme un outil BPF CO-RE (libbpf) :
-# il échoue sur un noyau compilé sans CONFIG_DEBUG_INFO_BTF.
+# Program that requires kernel BTF, like a BPF CO-RE tool (libbpf): it fails
+# on a kernel built without CONFIG_DEBUG_INFO_BTF.
 if [ ! -r /sys/kernel/btf/vmlinux ]; then
     echo "libbpf: failed to find valid kernel BTF" >&2
-    echo "erreur : BTF du noyau introuvable (/sys/kernel/btf/vmlinux)" >&2
+    echo "error: kernel BTF not found (/sys/kernel/btf/vmlinux)" >&2
     exit 1
 fi
-echo "BTF présent : $(wc -c </sys/kernel/btf/vmlinux) octets"
+echo "BTF present: $(wc -c </sys/kernel/btf/vmlinux) bytes"
diff --git a/schema/envprobe-report.schema.json b/schema/envprobe-report.schema.json
index 5070b3e..dfa7655 100644
--- a/schema/envprobe-report.schema.json
+++ b/schema/envprobe-report.schema.json
@@ -1,10 +1,10 @@
 {
   "$defs": {
     "Entry": {
-      "description": "Une information du rapport.",
+      "description": "One piece of information in the report.",
       "oneOf": [
         {
-          "description": "Valeur obtenue.",
+          "description": "Value obtained.",
           "properties": {
             "status": {
               "const": "ok",
@@ -21,7 +21,7 @@
           "type": "object"
         },
         {
-          "description": "Information absente ou impossible à obtenir (fichier absent, syscall inexistant…) ; contient la raison.",
+          "description": "Information missing or impossible to obtain (missing file, nonexistent syscall…); holds the reason.",
           "properties": {
             "status": {
               "const": "unavailable",
@@ -38,7 +38,7 @@
           "type": "object"
         },
         {
-          "description": "Accès refusé (EPERM, EACCES, seccomp…) ; contient l'errno et le contexte.",
+          "description": "Access denied (EPERM, EACCES, seccomp…); holds the errno and the context.",
           "properties": {
             "status": {
               "const": "denied",
@@ -60,7 +60,7 @@
           "type": "string"
         },
         "privileged": {
-          "description": "Le résultat change selon les privilèges du processus (root, capabilities).",
+          "description": "The result depends on the process's privileges (root, capabilities).",
           "type": "boolean"
         }
       },
@@ -71,7 +71,7 @@
       "type": "object"
     },
     "Section": {
-      "description": "Une catégorie du rapport, par exemple « kernel » ou « bpf ».",
+      "description": "A report category, for example \"kernel\" or \"bpf\".",
       "properties": {
         "entries": {
           "items": {
@@ -91,7 +91,7 @@
     }
   },
   "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "description": "Rapport complet, tel qu'écrit par `envprobe --json`.",
+  "description": "Full report, as written by `envprobe --json`.",
   "properties": {
     "envprobe_version": {
       "type": "string"
diff --git a/scripts/demo.sh b/scripts/demo.sh
index 6526f80..cb71fae 100755
--- a/scripts/demo.sh
+++ b/scripts/demo.sh
@@ -1,23 +1,23 @@
 #!/usr/bin/env bash
-# Démonstration de distroproof : chaque bloc lance le vrai binaire sur de
-# vraies VM et montre la commande puis sa sortie. Rien n'est simulé.
+# distroproof demo: each block runs the real binary on real VMs and shows the
+# command, then its output. Nothing is simulated.
 #
-#   scripts/demo.sh           les cinq actes non interactifs (~1 min, cache chaud)
-#   scripts/demo.sh 3         un seul acte
-#   scripts/demo.sh --list    les actes, sans rien lancer
+#   scripts/demo.sh           the five non-interactive acts (~1 min, warm cache)
+#   scripts/demo.sh 3         a single act
+#   scripts/demo.sh --list    the acts, without running anything
 #
-# L'acte 6 (la TUI) est interactif : voir docs/how-to-use/demo.md.
-# Prérequis : qemu-system-x86_64, qemu-img, curl, /dev/kvm, OVMF pour
-# rocky-9. Le premier lancement télécharge les images (~3 Gio).
-# Rien n'est écrit hors d'un répertoire temporaire et du cache d'images.
+# Act 6 (the TUI) is interactive: see docs/how-to-use/demo.md.
+# Requirements: qemu-system-x86_64, qemu-img, curl, /dev/kvm, OVMF for
+# rocky-9. The first run downloads the images (~3 GiB).
+# Nothing is written outside a temporary directory and the image cache.
 set -u
 
 ACTS=(
-    "1|Le catalogue et le cache"
-    "2|Le vrai noyau de chaque distro"
-    "3|Deux distros, un diff"
-    "4|Une matrice déclarative"
-    "5|Pourquoi ça casse"
+    "1|The catalog and the cache"
+    "2|Each distro's real kernel"
+    "3|Two distros, one diff"
+    "4|A declarative matrix"
+    "5|Why it breaks"
 )
 
 case "${1:-}" in
@@ -34,11 +34,11 @@ ROOT="$(cd "$(dirname "$0")/.." && pwd)"
 BIN="${BINARY:-$ROOT/target/x86_64-unknown-linux-musl/release/distroproof}"
 ENVPROBE="$(dirname "$BIN")/envprobe"
 if [ ! -x "$BIN" ] || [ ! -x "$ENVPROBE" ]; then
-    echo "binaires absents : cargo build --release --target x86_64-unknown-linux-musl" >&2
+    echo "binaries missing: cargo build --release --target x86_64-unknown-linux-musl" >&2
     exit 2
 fi
 if ! command -v "${DISTROPROOF_QEMU:-qemu-system-x86_64}" >/dev/null; then
-    echo "QEMU introuvable : installez qemu (Arch : qemu-base edk2-ovmf)" >&2
+    echo "QEMU not found: install qemu (Arch: qemu-base edk2-ovmf)" >&2
     exit 2
 fi
 
@@ -50,11 +50,11 @@ bold=''; dim=''; reset=''
 if [ -t 1 ]; then bold=$'\033[1m'; dim=$'\033[2m'; reset=$'\033[0m'; fi
 
 act() {
-    printf '\n%sActe %s — %s%s\n' "$bold" "$1" "$2" "$reset"
-    printf '%s%s%s\n' "$dim" "$(printf '─%.0s' $(seq 1 $((${#2} + 9))))" "$reset"
+    printf '\n%sAct %s — %s%s\n' "$bold" "$1" "$2" "$reset"
+    printf '%s%s%s\n' "$dim" "$(printf '─%.0s' $(seq 1 $((${#2} + 8))))" "$reset"
 }
 
-# Montre la commande telle qu'on la taperait, puis sa sortie indentée.
+# Shows the command as one would type it, then its indented output.
 run() {
     local shown=''
     for a in "$@"; do
@@ -70,12 +70,12 @@ run() {
 wanted() { [ -z "$ONLY" ] || [ "$ONLY" = "$1" ]; }
 
 if wanted 1; then
-    act 1 "Le catalogue et le cache"
+    act 1 "The catalog and the cache"
     run "$BIN" images
 fi
 
 if wanted 2; then
-    act 2 "Le vrai noyau de chaque distro"
+    act 2 "Each distro's real kernel"
     run uname -r
     for t in rocky-8 rocky-9 alpine; do
         run "$BIN" run --target "$t" --progress none -- uname -r
@@ -84,7 +84,7 @@ if wanted 2; then
 fi
 
 if wanted 3; then
-    act 3 "Deux distros, un diff"
+    act 3 "Two distros, one diff"
     "$BIN" run --target debian-12 --progress none -- envprobe --json >"$SCRATCH/debian.json"
     "$BIN" run --target alpine --progress none -- envprobe --json >"$SCRATCH/alpine.json"
     printf '\n%s$ distroproof run --target debian-12 -- envprobe --json > debian.json%s\n' "$dim" "$reset"
@@ -96,15 +96,15 @@ if wanted 3; then
 fi
 
 if wanted 4; then
-    act 4 "Une matrice déclarative"
+    act 4 "A declarative matrix"
     run "$BIN" check
-    printf '[[target]]\nname = "rhel7"\nimage = "rocky-7"\n' >"$SCRATCH/faux.toml"
-    run "$BIN" up -f "$SCRATCH/faux.toml"
+    printf '[[target]]\nname = "rhel7"\nimage = "rocky-7"\n' >"$SCRATCH/bogus.toml"
+    run "$BIN" up -f "$SCRATCH/bogus.toml"
     run "$BIN" up --no-tui --progress none --jobs 5
 fi
 
 if wanted 5; then
-    act 5 "Pourquoi ça casse"
+    act 5 "Why it breaks"
     run cat examples/require-btf/require-btf.sh
     run "$BIN" up -f examples/require-btf/distroproof.toml --no-tui --progress none \
         --markdown "$SCRATCH/summary.md"
diff --git a/scripts/probe-rootfs.sh b/scripts/probe-rootfs.sh
index e5003d7..16330bc 100755
--- a/scripts/probe-rootfs.sh
+++ b/scripts/probe-rootfs.sh
@@ -1,9 +1,9 @@
 #!/bin/sh
-# Lance envprobe dans un rootfs de distro extrait (Alpine minirootfs, image
-# LXC…), isolé par des namespaces user, mount et pid : ni root ni Docker requis.
-# Le noyau reste celui de l'hôte, seul l'userspace change.
+# Runs envprobe in an extracted distro rootfs (Alpine minirootfs, LXC
+# image…), isolated by user, mount and pid namespaces: neither root nor Docker
+# needed. The kernel stays the host's; only the userspace changes.
 #
-#   scripts/probe-rootfs.sh <rootfs> <binaire envprobe statique> [args…]
+#   scripts/probe-rootfs.sh <rootfs> <static envprobe binary> [args…]
 set -eu
 
 rootfs=$(realpath "$1")
diff --git a/scripts/selftest.sh b/scripts/selftest.sh
index c1643a7..b9bd1cb 100755
--- a/scripts/selftest.sh
+++ b/scripts/selftest.sh
@@ -1,12 +1,12 @@
 #!/bin/sh
-# Autotest d'envprobe lancé par distroproof dans chaque VM (dogfooding) :
-# la sonde doit tourner sans planter, produire un rapport complet et se
-# comparer à elle-même sans différence.
+# envprobe self-test run by distroproof in each VM (dogfooding): the probe
+# must run without crashing, produce a complete report and compare with
+# itself without any difference.
 set -eu
 envprobe --json >/tmp/envprobe.json
 sections=$(grep -c '"name":' /tmp/envprobe.json)
 if [ "$sections" -lt 18 ]; then
-    echo "rapport incomplet : $sections sections sur 18" >&2
+    echo "incomplete report: $sections of 18 sections" >&2
     exit 1
 fi
 envprobe diff --color never /tmp/envprobe.json /tmp/envprobe.json >/dev/null