Skip to content

Benchmarks autres langages

Henri Lepic edited this page Nov 21, 2026 · 5 revisions

Mesures réalisées le 17 novembre 2026 sur 32 librairies TypeScript, Python et Rust et sur ZeRechnung v0.1.0. Le protocole est celui de la page Benchmarks (librairies Go) : mêmes fichiers du corpus officiel ZUGFeRD, mêmes opérations, résultat vérifié avant chaque mesure. Le harnais est versionné dans le dossier bench/polyglot du dépôt.

Ce qu'il faut retenir

  • ZeRechnung reste le plus rapide dans 13 colonnes sur 16, face à 13 librairies TypeScript, 8 Python et 11 Rust. Les trois exceptions sont détaillées plus bas.
  • Rust est le seul écosystème qui s'en approche. Aucune des librairies suivantes n'applique le schematron EN 16931 complet :
    • einvoice-validator extrait le XML en 32,5 µs (×1,1) ;
    • zugferd-rs lit une facture de 13 Ko en 24,0 µs (×1,5) et l'écrit en 6,7 µs (×2,2) ;
    • pdfa injecte en 88,4 µs, à 4 % de ZeRechnung, mais refuse les hôtes à flux xref.
  • Valider avec tout le schematron EN 16931 coûte de 0,5 à 100 ms ailleurs. einvoice-validator (Rust) met 473 µs, @sweberdev/summand (TypeScript) 802 µs, saxonche avec les XSLT officiels (Python) 903 µs, et les autres jusqu'à 102 ms. ZeRechnung applique les 793 assertions du CEN en 23,1 µs, avec les mêmes verdicts que la référence officielle. Le premier appel de ces validateurs compile les feuilles de style (de 22 à 320 ms) ; les règles de ZeRechnung sont du code compilé, il n'y a rien à charger.
  • Les librairies les plus téléchargées ne valident pas les règles métier. Hors ligne, @stackforge-eu/factur-x (TypeScript, 94 000 téléchargements par semaine) et factur-x d'Akretion (Python, 411 000 par mois) s'arrêtent au schéma XSD ; @e-invoice-eu/core et node-zugferd ne font que générer.
  • Six librairies seulement rendent les verdicts de la référence sur les 26 XML valides du corpus : ZeRechnung, @conformo/toolkit, @sweberdev/summand, en16931 (TypeScript), saxonche avec les XSLT officiels et erechnung-validator. Huit autres signalent à tort de 3 à 20 factures valides.
  • Hors ZeRechnung, Rust devance les librairies Go partout, sauf pour la validation complète. Sur ce point, pdf0 (Go, 126 µs) reste, toutes langues confondues, le validateur fidèle à la référence le plus rapide après ZeRechnung.
  • TypeScript lit plus vite que les librairies Go existantes (69,6 µs contre 124 µs), mais extrait, injecte et valide plus lentement.
  • Python est derrière, sauf pour la lecture du XML de 1,3 Mo. lxml (écrit en C) l'emporte alors sur tout le monde, ZeRechnung compris.

Le meilleur de chaque langage

Pour chaque opération, la librairie la plus rapide de chaque langage parmi celles qui réussissent. En gras, le meilleur temps de la ligne.

Opération ZeRechnung (Go) Autres librairies Go TypeScript Python Rust
Extraction, PDF de 149 Ko 29,3 µs 75,2 µs (speedata) 184 µs (@attestwire/en16931) 78,5 µs (zugferd-pdf) 32,5 µs (einvoice-validator)
Lecture, XML de 13 Ko 16,3 µs 124 µs (fX) 69,6 µs (@ekwo-ai/factur-x) 221 µs (pycheval, 7 XML lus sur 26) 24,0 µs (zugferd-rs)
Lecture, XML de 1,3 Mo 1,11 ms 6,76 ms (dotwave) 1,74 ms (@conformo/toolkit) 702 µs (mcp-einvoicing-de) 1,63 ms (pdf-invoice)
Validation EN 16931 complète, XML de 13 Ko 23,1 µs 126 µs (pdf0) 802 µs (@sweberdev/summand) 903 µs (saxonche + XSLT officiels) 473 µs (einvoice-validator)
Écriture, XML de 13 Ko 3,1 µs 20,2 µs (fX) 10,9 µs (@ekwo-ai/factur-x, modèle construit à la main) 76,6 µs (pycheval) 6,7 µs (zugferd-rs)
Injection, hôte à xref classique 84,6 µs 361 µs (kanjo, PDF cassé sur un hôte à flux xref) 1,14 ms (@stackforge-eu/factur-x) 765 µs (mcp-einvoicing-de) 88,4 µs (pdfa, refuse un hôte à flux xref)
Injection, hôte à flux xref 87,8 µs 522 µs (pdf0), 546 µs (recette pdfcpu du banc) 1,14 ms (@stackforge-eu/factur-x) 662 µs (mcp-einvoicing-de) 178 µs (pdf-invoice)
Contrôle complet, PDF de 149 Ko 75,0 µs 1,14 ms (DCNWS) 359 µs (@attestwire/en16931) 212 µs (zugferd-pdf, conteneur seulement) 479 µs (en16931)
  • « Validation EN 16931 complète » ne retient que les validateurs qui appliquent tout le schematron CEN, par les XSLT officiels ou une réécriture complète. Des validateurs plus partiels sont plus rapides : pdf-invoice (Rust, 14 règles) valide en 27,1 µs mais signale 20 des 26 factures valides ; en16931 (Rust, une partie des règles CII-SR et CII-DT) valide en 75 µs.
  • Les chiffres des autres librairies Go viennent de la campagne Go du même jour (page Benchmarks), sur la même machine et avec le même protocole. Ceux de ZeRechnung viennent de cette campagne-ci, en 3 séries. La page Benchmarks en retient 6, et l'écart entre les deux mesures est de 5 % au plus.
  • Le contrôle complet de ZeRechnung (75,0 µs) inclut les contrôles PDF/A du conteneur (polices, JavaScript et actions, /Info, LZW). Pour une facture EN 16931 dans un PDF, il applique aussi le schematron Factur-X 1.09.2 au lieu des règles CEN. Il était de 85,6 µs dans la campagne précédente (commit 4194b98), avant l'optimisation du parcours PDF/A (PR #46). Il reste 2,8 fois plus rapide que zugferd-pdf, qui ne contrôle que le conteneur.

Les trois colonnes où ZeRechnung n'est pas premier

  • Extraction du PDF MINIMUM (89 Ko) : pdfa (Rust) prend le premier flux /EmbeddedFile trouvé dans les octets, sans lire la structure du PDF. Cela marche sur ce fichier (496 ns contre 10,7 µs), mais pas sur 72 des 104 PDF du corpus.
  • Lecture du XML de 1,3 Mo : les lecteurs Python fondés sur lxml (libxml2, écrit en C) gardent la pièce jointe base64 sous forme de texte. mcp-einvoicing-de lit ce fichier en 702 µs, ZeRechnung en 1,11 ms : il décode la pièce jointe.
  • Validation du XML de 19 Ko : pdf-invoice (Rust) est à égalité (40,2 µs contre 40,9 µs) avec 14 règles, contre les 793 assertions du CEN pour ZeRechnung.

Méthode

Environnement

Machine Apple M4 Pro, 14 cœurs, 24 Go de mémoire
Système macOS 26.6 (Darwin 25.6.0)
Alimentation sur batterie, mode hautes performances (powermode 2)
Go 1.26.4, ZeRechnung v0.1.0 (commit a580779)
TypeScript Node 22.15.0, sans option
Python CPython 3.13.18
Rust rustc 1.93.1, profil release par défaut, sans option de CPU
Commande ./run.sh bench dans bench/polyglot (COUNT=3, BENCHTIME=1)
Valeur retenue médiane des 3 séries

Chronométrage

Le chronométrage reproduit go test -bench . -count 3 -benchtime 1s :

  1. Le nombre d'appels N croît par paliers (1, 2, 5, 10, 20, 50…) jusqu'à ce qu'une série dure au moins 1 s. Cette montée en charge sert aussi d'échauffement (JIT de V8, caches).
  2. Suivent 3 séries de N appels, chronométrées avec l'horloge monotone du langage (process.hrtime.bigint(), time.perf_counter_ns(), std::time::Instant).
  3. Les mesures se font en processus, sur un seul fil, sans GC forcé, sur des octets déjà en mémoire.

La colonne « Premier appel » donne la durée du tout premier appel dans le processus : chargement paresseux, compilation des schematrons. En TypeScript et en Python, chaque benchmark tourne dans son propre processus, et ce premier appel est donc un appel à froid ; en Rust, un processus sert à toute une librairie. Elle n'est pas mesurée pour Go.

Opérations et fichiers

Les fichiers d'entrée et les opérations sont ceux de la page Benchmarks : mêmes octets du corpus ZUGFeRD (commit 84f8d8f), mêmes deux PDF hôtes, mêmes noms de benchmarks. Le contrôle complet (CheckPDF) doit passer par une fonction native de la librairie qui contrôle le conteneur et le XML ; une extraction suivie d'une validation ne compte pas.

Règles communes :

  • Vérifier avant de mesurer. Un premier appel hors mesure contrôle le résultat : le XML extrait doit être un CII, et le PDF produit par une injection doit se relire. En cas de résultat faux ou d'exception, l'opération est notée « échec » et n'est pas mesurée.
  • Validation : le jeu de règles le plus complet que la librairie applique hors ligne, sans règles françaises (le corpus est allemand).
  • Écriture : le modèle est construit une fois hors mesure, par le lecteur de la librairie ou, à défaut, à la main à partir du contenu de EN16931_Einfach.
  • Librairies écartées : clients d'API distantes, librairies qui exigent Java, paquets vides. La raison est donnée dans les fiches de chaque langage : TypeScript, Python, Rust.

Le Mac s'est mis en veille pendant la campagne (capot fermé, de 17 h 57 à 19 h 21). @ekwo-ai/factur-x et @conformo/toolkit, les deux librairies TypeScript mesurées pendant ce temps, ont été remesurées ensuite. Toutes les autres mesures ont été prises machine éveillée.

Versions mesurées

  • TypeScript : @attestwire/en16931 0.14.1 · @conformo/toolkit 0.2.4 · @e-invoice-eu/core 3.4.4 · @ekwo-ai/factur-x 0.25.2 · @fin.cx/einvoice 11.3.1 · @kontor-mcp/core 1.0.4 · @lucaapp/zugferd-ts 0.1.0 · @stackforge-eu/factur-x 1.4.6 · @stafyniaksacha/facturx 0.6.1 · @sweberdev/summand 2.0.1 · en16931 0.1.0 · factur-x-kit 0.3.2 · node-zugferd 0.1.1-beta.1
  • Python : drafthorse 2025.2.0 · erechnung 0.3.0 · factur-x 7.9 · getafix 0.5.0 · mcp-einvoicing-de 0.11.4 · pycheval 0.4.0 · saxonche 13.1.1 (avec les XSLT officiels CEN 1.3.17 et KoSIT XRechnung, schematron 2.6.0) · zugferd-pdf 0.1.2
  • Rust : core-invoice-formats 2.0.3 · einvoice 0.1.1 · einvoice-validator 0.4.0 · en16931-formats 0.10.1 · erechnung-validator 0.1.1 · factur-x 0.3.1 · pdf-invoice 1.4.0 · pdfa 0.1.10 · zugferd 0.3.0 · zugferd-rs 0.2.2 · lopdf 0.47.0 (plancher : extraction écrite à la main, pas une librairie Factur-X)

Exactitude sur le corpus

Sur les 26 XML CII valides du corpus, les schematrons officiels (CEN EN 16931 1.3.17 et KoSIT XRechnung) en signalent 6 : BR-CL-25 deux fois, CII-SR-465 quatre fois sur les exemples XRECHNUNG. CII-SR-465 est un avertissement dans les artefacts du CEN, et la configuration KoSIT l'élève au rang d'erreur. Un validateur fidèle au seul CEN en signale donc 2. Les relevés de cette campagne sont identiques à ceux de la précédente.

Signalés Librairies
6, comme la référence ZeRechnung (Go), @conformo/toolkit, @sweberdev/summand, en16931 (TypeScript, sans distinguer avertissements et erreurs), saxonche + XSLT officiels, erechnung-validator ; getafix aussi, mais par 6 exceptions de lecture et non par des règles
2, comme le CEN seul @attestwire/en16931, @kontor-mcp/core, mcp-einvoicing-de, einvoice-validator, en16931 (Rust)
3 à 20, faux positifs @ekwo-ai/factur-x (3, des clés IBAN), core-invoice (7), zugferd-rs (7), @lucaapp/zugferd-ts (8), @stafyniaksacha/facturx (12), factur-x Rust (17), factur-x-kit (18), pdf-invoice (20)
0 @stackforge-eu/factur-x, @fin.cx/einvoice, factur-x (Python), drafthorse : schéma XSD seul ou règles trop partielles

Les 104 PDF hybrides sont tous extraits par ZeRechnung et par 15 des 19 autres librairies qui savent extraire (et par lopdf, le plancher Rust). Les autres : @stafyniaksacha/facturx 100, pdf-invoice 101, pycheval 65, pdfa 32.

Détail par librairie :

Librairie Langage XML valides signalés XML lus PDF extraits
ZeRechnung Go 6/26 26/26 104/104
@attestwire/en16931 TypeScript 2/26 26/26 104/104
@conformo/toolkit TypeScript 6/26 26/26 104/104
@ekwo-ai/factur-x TypeScript 3/26 26/26 104/104
@fin.cx/einvoice TypeScript 0/26 26/26 104/104
@kontor-mcp/core TypeScript 2/26 26/26 104/104
@lucaapp/zugferd-ts TypeScript 8/26 19/26 104/104
@stackforge-eu/factur-x TypeScript 0/26 — 104/104
@stafyniaksacha/facturx TypeScript 12/26 26/26 100/104
@sweberdev/summand TypeScript 6/26 — 104/104
en16931 TypeScript 6/26 — —
factur-x-kit TypeScript 18/26 13/26 —
drafthorse Python 0/26 26/26 —
factur-x Python 0/26 26/26 104/104
getafix Python 6/26 20/26 104/104
mcp-einvoicing-de Python 2/26 20/26 104/104
pycheval Python — 7/26 65/104
saxonche-schematron Python 6/26 — —
zugferd-pdf Python — — 104/104
core-invoice Rust 7/26 23/26 —
einvoice Rust — 26/26 —
einvoice-validator Rust 2/26 — 104/104
en16931 Rust 2/26 26/26 104/104
erechnung-validator Rust 6/26 — —
factur-x Rust 17/26 9/26 —
lopdf Rust — — 104/104
pdf-invoice Rust 20/26 26/26 101/104
pdfa Rust — — 32/104
zugferd-rs Rust 7/26 19/26 104/104

Résultats

Dans chaque tableau, le meilleur temps de la colonne est en gras et « (×n) » rapporte le temps à celui de ZeRechnung (v0.1.0, commit a580779). Les lignes sont triées sur la première colonne de mesure ; « Premier appel » donne la durée du premier appel dans le processus pour cette même colonne (non mesurée pour Go). « échec » : résultat faux ou exception ; « — » : opération que la librairie ne propose pas, ou non mesurée (voir les particularités connues).

Extraction

Librairie Langage EN 16931, 149 Ko EN 16931, 1,1 Mo MINIMUM FNFE, 89 Ko EXTENDED ZF 2.0, 157 Ko Premier appel
ZeRechnung Go 29,3 µs 33,3 µs 10,7 µs 34,7 µs —
einvoice-validator Rust 32,5 µs (×1,1) 41,7 µs (×1,3) 22,9 µs (×2,1) 37,1 µs (×1,1) 1,44 ms
lopdf Rust 72,6 µs (×2,5) 95,7 µs (×2,9) 43,2 µs (×4,0) 66,0 µs (×1,9) 391 µs
pdfa Rust 78,1 µs (×2,7) échec 496 ns (×0,05) échec 140 µs
zugferd-pdf Python 78,5 µs (×2,7) 116 µs (×3,5) 52,2 µs (×4,9) 93,5 µs (×2,7) 1,72 ms
mcp-einvoicing-de Python 78,7 µs (×2,7) 115 µs (×3,5) 51,9 µs (×4,9) 228 µs (×6,6) 421 µs
pdf-invoice Rust 79,4 µs (×2,7) 102 µs (×3,1) 47,9 µs (×4,5) 74,5 µs (×2,1) 768 µs
zugferd-rs Rust 91,4 µs (×3,1) 116 µs (×3,5) 54,0 µs (×5,1) 84,1 µs (×2,4) 898 µs
@attestwire/en16931 TypeScript 184 µs (×6,3) 199 µs (×6,0) 106 µs (×9,9) 206 µs (×5,9) 4,62 ms
pycheval Python 199 µs (×6,8) échec 176 µs (×17) échec 929 µs
getafix Python 225 µs (×7,7) 376 µs (×11) 210 µs (×20) 207 µs (×6,0) 1,07 ms
factur-x Python 241 µs (×8,2) 375 µs (×11) 193 µs (×18) 266 µs (×7,7) 2,46 ms
@lucaapp/zugferd-ts TypeScript 253 µs (×8,6) 293 µs (×8,8) 122 µs (×11) 227 µs (×6,5) 4,70 ms
@ekwo-ai/factur-x TypeScript 269 µs (×9,2) 315 µs (×9,5) 134 µs (×13) 242 µs (×7,0) 4,52 ms
@conformo/toolkit TypeScript 281 µs (×9,6) 10,13 ms (×305) 134 µs (×13) 244 µs (×7,0) 4,59 ms
@stackforge-eu/factur-x TypeScript 285 µs (×9,7) 331 µs (×10,0) 143 µs (×13) 248 µs (×7,2) 5,02 ms
@stafyniaksacha/facturx TypeScript 373 µs (×13) 3,15 ms (×95) 169 µs (×16) 436 µs (×13) 7,39 ms
en16931 Rust 388 µs (×13) 703 µs (×21) 248 µs (×23) 281 µs (×8,1) 1,56 ms
@fin.cx/einvoice TypeScript 402 µs (×14) 492 µs (×15) 135 µs (×13) 431 µs (×12) 50,70 ms
@kontor-mcp/core TypeScript 683 µs (×23) 1,46 ms (×44) 659 µs (×62) 737 µs (×21) 8,61 ms
@sweberdev/summand TypeScript 892 µs (×30) 20,19 ms (×607) 437 µs (×41) 1,04 ms (×30) 3,36 ms

Lecture XML → modèle

Librairie Langage 13 Ko 19 Ko 1,3 Mo Premier appel
ZeRechnung Go 16,3 µs 28,8 µs 1,11 ms —
zugferd-rs Rust 24,0 µs (×1,5) 36,9 µs (×1,3) échec 2,07 ms
pdf-invoice Rust 25,6 µs (×1,6) 38,6 µs (×1,3) 1,63 ms (×1,5) 760 µs
core-invoice Rust 44,4 µs (×2,7) 66,5 µs (×2,3) 3,65 ms (×3,3) 312 µs
@ekwo-ai/factur-x TypeScript 69,6 µs (×4,3) 114 µs (×4,0) 23,70 ms (×21) 1,73 ms
en16931 Rust 73,5 µs (×4,5) 126 µs (×4,4) 6,75 ms (×6,1) 1,49 ms
@conformo/toolkit TypeScript 92,1 µs (×5,7) 157 µs (×5,4) 1,74 ms (×1,6) 1,56 ms
@attestwire/en16931 TypeScript 135 µs (×8,3) 242 µs (×8,4) 3,27 ms (×3,0) 2,30 ms
@lucaapp/zugferd-ts TypeScript 162 µs (×10) 287 µs (×10) échec 2,44 ms
pycheval Python 221 µs (×14) échec échec 888 µs
factur-x-kit TypeScript 268 µs (×16) échec échec 8,39 ms
einvoice Rust 323 µs (×20) 544 µs (×19) 11,96 ms (×11) 1,56 ms
mcp-einvoicing-de Python 335 µs (×21) 477 µs (×17) 702 µs (×0,6) 1,06 ms
drafthorse Python 586 µs (×36) 982 µs (×34) 1,07 ms (×1,0) 3,21 ms
@stafyniaksacha/facturx TypeScript 947 µs (×58) 1,69 ms (×59) 5,55 ms (×5,0) 8,09 ms
@kontor-mcp/core TypeScript 1,08 ms (×66) 1,67 ms (×58) 4,35 ms (×3,9) 12,34 ms
getafix Python 1,22 ms (×75) 2,08 ms (×72) échec 2,72 ms
factur-x Python 1,40 ms (×86) 1,98 ms (×69) 11,79 ms (×11) 4,99 ms
@fin.cx/einvoice TypeScript 2,09 ms (×128) 3,72 ms (×129) 7,11 ms (×6,4) 13,51 ms
factur-x Rust échec échec 1,61 ms (×1,5) —

Lecture et validation

Librairie Langage Valides signalés /26 13 Ko 19 Ko 1,3 Mo Premier appel
ZeRechnung Go 6/26 23,1 µs 40,9 µs 800 µs —
pdf-invoice Rust 20/26 27,1 µs (×1,2) 40,2 µs (×1,0) 1,65 ms (×2,1) 46,2 µs
@ekwo-ai/factur-x TypeScript 3/26 69,8 µs (×3,0) 114 µs (×2,8) 21,66 ms (×27) 1,71 ms
core-invoice Rust 7/26 75,1 µs (×3,2) 117 µs (×2,9) 5,45 ms (×6,8) 585 µs
en16931 Rust 2/26 75,4 µs (×3,3) 128 µs (×3,1) 6,70 ms (×8,4) 1,66 ms
@attestwire/en16931 TypeScript 2/26 202 µs (×8,7) 331 µs (×8,1) 6,84 ms (×8,6) 9,27 ms
factur-x-kit TypeScript 18/26 289 µs (×13) échec échec 10,26 ms
einvoice-validator Rust 2/26 473 µs (×20) 776 µs (×19) 4,10 ms (×5,1) 22,09 ms
factur-x Python 0/26 486 µs (×21) 513 µs (×13) 5,14 ms (×6,4) 781 µs
drafthorse Python 0/26 492 µs (×21) 529 µs (×13) 7,98 ms (×10,0) 1,82 ms
@sweberdev/summand TypeScript 6/26 802 µs (×35) 1,36 ms (×33) 7,49 ms (×9,4) 16,68 ms
@stackforge-eu/factur-x TypeScript 0/26 828 µs (×36) 878 µs (×21) 10,06 ms (×13) 32,98 ms
saxonche-schematron Python 6/26 903 µs (×39) 1,46 ms (×36) 12,61 ms (×16) 133,18 ms
getafix Python 6/26 1,55 ms (×67) 2,57 ms (×63) échec 3,01 ms
zugferd-rs Rust 7/26 1,96 ms (×85) 2,73 ms (×67) 5,15 ms (×6,4) 5,79 ms
@fin.cx/einvoice TypeScript 0/26 3,09 ms (×134) 5,28 ms (×129) 10,57 ms (×13) 17,20 ms
en16931 TypeScript 6/26 14,19 ms (×614) 25,91 ms (×633) 39,72 ms (×50) 159,55 ms
erechnung-validator Rust 6/26 31,16 ms (×1 347) 54,77 ms (×1 339) 82,99 ms (×104) 150,36 ms
@kontor-mcp/core TypeScript 2/26 44,31 ms (×1 916) 51,53 ms (×1 260) 71,43 ms (×89) 142,98 ms
@stafyniaksacha/facturx TypeScript 12/26 60,76 ms (×2 627) 76,86 ms (×1 879) 78,84 ms (×99) 131,89 ms
@conformo/toolkit TypeScript 6/26 71,49 ms (×3 091) 78,08 ms (×1 909) 121,80 ms (×152) 117,26 ms
mcp-einvoicing-de Python 2/26 102,14 ms (×4 416) 105,90 ms (×2 589) 155,68 ms (×195) 318,56 ms
@lucaapp/zugferd-ts TypeScript 8/26 2,67 s (×115 305) 8,84 s (×216 176) 4,15 s (×5 195) 2,89 s
factur-x Rust 17/26 échec échec 1,61 ms (×2,0) —

Écriture modèle → XML

Librairie Langage 13 Ko 19 Ko Premier appel
ZeRechnung Go 3,1 µs 5,0 µs —
zugferd-rs Rust 6,7 µs (×2,2) 11,6 µs (×2,3) 59,3 µs
core-invoice Rust 10,6 µs (×3,4) 16,9 µs (×3,4) 52,3 µs
@ekwo-ai/factur-x TypeScript 10,9 µs (×3,5) — 431 µs
@stackforge-eu/factur-x TypeScript 14,3 µs (×4,6) — 488 µs
@conformo/toolkit TypeScript 21,5 µs (×6,9) 37,3 µs (×7,5) 1,65 ms
zugferd Rust 28,3 µs (×9,2) — 293 µs
einvoice Rust 36,2 µs (×12) 70,7 µs (×14) 1,03 ms
@attestwire/en16931 TypeScript 41,5 µs (×13) 80,2 µs (×16) 964 µs
en16931 Rust 45,8 µs (×15) 79,3 µs (×16) 1,55 ms
@stafyniaksacha/facturx TypeScript 72,5 µs (×23) 120 µs (×24) 1,18 ms
pycheval Python 76,6 µs (×25) échec 130 µs
@lucaapp/zugferd-ts TypeScript 106 µs (×34) 190 µs (×38) 5,03 ms
mcp-einvoicing-de Python 109 µs (×35) 183 µs (×37) 180 µs
zugferd-pdf Python 120 µs (×39) — 260 µs
erechnung Python 124 µs (×40) — 528 µs
factur-x-kit TypeScript 171 µs (×55) échec 4,97 ms
@fin.cx/einvoice TypeScript 336 µs (×109) 454 µs (×91) 3,47 ms
getafix Python 399 µs (×129) 693 µs (×139) 853 µs
factur-x Python 665 µs (×215) 820 µs (×165) 1,44 ms
node-zugferd TypeScript 928 µs (×301) — 4,84 ms
drafthorse Python 961 µs (×311) 1,31 ms (×263) 1,31 ms
@e-invoice-eu/core TypeScript 39,44 ms (×12 772) — 82,44 ms
factur-x Rust échec échec —
pdf-invoice Rust échec échec —

Injection dans un PDF

Librairie Langage hôte à xref classique hôte à flux xref Premier appel
ZeRechnung Go 84,6 µs 87,8 µs —
pdfa Rust 88,4 µs (×1,04) échec 104 µs
pdf-invoice Rust 156 µs (×1,8) 178 µs (×2,0) 172 µs
zugferd-rs Rust 200 µs (×2,4) 214 µs (×2,4) 220 µs
mcp-einvoicing-de Python 765 µs (×9,0) 662 µs (×7,5) 1,47 ms
zugferd-pdf Python 855 µs (×10) 747 µs (×8,5) 5,20 ms
@stackforge-eu/factur-x TypeScript 1,14 ms (×13) 1,14 ms (×13) 15,74 ms
@fin.cx/einvoice TypeScript 2,01 ms (×24) 1,95 ms (×22) 49,30 ms
drafthorse Python 2,07 ms (×24) 2,09 ms (×24) 3,20 ms
getafix Python 2,09 ms (×25) 2,12 ms (×24) 2,91 ms
pycheval Python 2,51 ms (×30) 2,56 ms (×29) 3,39 ms
@ekwo-ai/factur-x TypeScript 2,64 ms (×31) 2,64 ms (×30) 12,75 ms
@lucaapp/zugferd-ts TypeScript 2,72 ms (×32) 2,64 ms (×30) 12,94 ms
@conformo/toolkit TypeScript 2,87 ms (×34) 2,98 ms (×34) 16,23 ms
factur-x Python 4,05 ms (×48) 3,85 ms (×44) 6,72 ms
@stafyniaksacha/facturx TypeScript échec échec —
en16931 Rust échec échec —

Contrôle d'un PDF hybride

Librairie Langage 149 Ko 1,1 Mo Premier appel
ZeRechnung Go 75,0 µs 85,4 µs —
zugferd-pdf Python 212 µs (×2,8) 269 µs (×3,2) 464 µs
@attestwire/en16931 TypeScript 359 µs (×4,8) 408 µs (×4,8) 11,45 ms
en16931 Rust 479 µs (×6,4) 812 µs (×9,5) 509 µs
@sweberdev/summand TypeScript 1,84 ms (×25) 21,50 ms (×252) 17,88 ms
erechnung-validator Rust 31,74 ms (×423) 35,68 ms (×418) 32,48 ms
@conformo/toolkit TypeScript 73,69 ms (×983) 96,17 ms (×1 126) 118,80 ms

Les appels mesurés pour chaque librairie et les particularités de chaque harnais sont dans les tableaux complets de la campagne.

Normes appliquées

Ce relevé vient du code des librairies, pas de leur README ; les fichiers et les lignes sont cités dans les fiches COVERAGE.md de chaque langage. Le tableau retient les librairies les plus téléchargées et les plus complètes de chaque langage.

Librairie Langage XSD EN 16931 (CII) Profils Factur-X BR-FR BR-DE (XRechnung) Peppol BIS 3 en CII Conteneur PDF/A-3 UBL
ZeRechnung (ce projet) Go Factur-X 1.09.2, CII D16B (XRECHNUNG), UBL 2.1 793 assertions, CEN 1.3.17 544 règles (schematrons 1.09 et 1.09.2) FNFE-MPE 1.4.0.04 KoSIT 3.0.2, Leitweg-ID et GEBA 3.0.21 (90 assertions) 69 contrôles, conversion partielle lecture, écriture, validation EN 16931, BR-FR, BR-DE, Peppol
@stackforge-eu/factur-x (94 000/sem.) TS Factur-X 1.09 non XSD seul non non non non non
@e-invoice-eu/core (63 000/sem.) TS non non (génération) génération non génération non non écriture
@conformo/toolkit TS oui CEN 1.3.17 (SaxonJS) XSD seul Flux 2, si country: "FR" KoSIT 3.0.2 UBL seulement partiel oui
@sweberdev/summand TS oui CEN 1.3.16 XMP comparé à BT-24 non KoSIT 2.6.0 non partiel validation
@stafyniaksacha/facturx TS Factur-X 1.09 via le schematron Factur-X 1.09 (SaxonJS) oui, sans gravités non non non non non
factur-x, Akretion (411 000/mois) Python Factur-X 1.09 seulement par un serveur Saxon HTTP XSD ; schematron par serveur 124 règles, par serveur non non non lecture, écriture
drafthorse (157 000/mois) Python Factur-X 1.0.07 non XSD seul non non non non non
mcp-einvoicing-de Python non FeRD 1.09.2 ou CEN 1.3.16 (saxonche) oui (saxonche) non KoSIT 3.0.2 non non oui
en16931 + en16931-formats (9 700 tél.) Rust non CEN 1.3.17 réécrit, 447 des 522 CII-SR et CII-DT partiel non KoSIT 2.6.0 oui, 3.0.21 partiel oui
einvoice-validator Rust oui XSLT CEN 1.3.17 exécuté en Rust seulement avec la feature fetch (téléchargement) idem idem idem non validation
erechnung-validator Rust oui CEN 1.3.16 Factur-X 1.09.2, 5 profils non KoSIT 3.0.2 non non validation
zugferd-rs Rust Factur-X 1.09.2 partiel (XPath 1.0) XSD non non non 21 règles veraPDF oui

Aucune librairie TypeScript, Python ou Rust ne réunit les règles EN 16931 complètes, les règles de profil Factur-X, les règles françaises, les règles allemandes, Peppol en CII et le contrôle du conteneur. Les deux plus proches :

  • @conformo/toolkit (TypeScript) : CEN, KoSIT et BR-FR, UBL, création de PDF/A-3. Il n'a pas le schematron de profil Factur-X, n'applique Peppol qu'en UBL et dépend de SaxonJS (licence Saxonica). Une validation lui prend 71 ms.
  • erechnung-validator (Rust) : CEN, KoSIT et schematrons Factur-X des 5 profils. Il n'a ni BR-FR, ni Peppol, ni contrôle du conteneur, ni lecture vers un modèle. Une validation lui prend 31 ms.

La conversion en PDF/A-3 du PDF hôte, que font zugferd-rs, @lucaapp/zugferd-ts et @conformo/toolkit (mcp-einvoicing-de ajoute un OutputIntent sRGB), existe aussi dans ZeRechnung depuis la PR #68, après la campagne de mesure : elle est partielle, en pur Go, et refuse ce qui demanderait un moteur PDF, comme l'incorporation d'une police. Le banc ne la mesure pas. ZeRechnung lit, écrit et valide aussi la syntaxe UBL, comme plusieurs de ces librairies (@conformo/toolkit, en16931, zugferd-rs, mcp-einvoicing-de, @lucaapp/zugferd-ts…), mais le banc ne mesure que le CII.

Particularités connues

  • pdfa (Rust) extrait par recherche d'octets : 496 ns sur le PDF MINIMUM, mais 32 PDF sur 104 seulement.
  • erechnung-validator apparaît dans le contrôle complet avec sa propre fonction beide_pdf, qui extrait et valide le XML sans contrôler le conteneur.
  • en16931 (Rust) refuse d'injecter dans les deux PDF hôtes, parce que leur XMP contient déjà des propriétés fx:. @stafyniaksacha/facturx échoue sur tout hôte dont le trailer a un /ID.
  • Modèles construits à la main pour l'écriture quand la librairie ne sait pas lire le CII : @stackforge-eu/factur-x, @e-invoice-eu/core, node-zugferd, @ekwo-ai/factur-x, zugferd-pdf, erechnung, zugferd (Rust). Leur écriture du XML de 19 Ko n'est pas mesurée.
  • Installation : npm ci --ignore-scripts (le postinstall de @fin.cx/einvoice télécharge des schematrons non figés), wheels Python seulement, cargo build --ignore-rust-version pour einvoice-validator, RAYON_NUM_THREADS=1 pour lopdf.

Reproduire

Le harnais est versionné dans le dossier bench/polyglot, avec son protocole et son README. Chaque langage a son propre dossier, autonome.

cd bench/polyglot
./run.sh setup     # corpus (via bench/ecosystem), npm ci, venv + artefacts XSLT officiels, cargo build --release
./run.sh survey    # exactitude sur le corpus, les quatre langages
./run.sh bench     # benchmarks, un langage après l'autre
./run.sh report    # results/<date>/tables.md et env.txt

survey et bench acceptent une liste de langages (./run.sh bench rust go). Prérequis : Go 1.26, Node 22 et npm, Python 3.13 (Homebrew), Rust 1.93, et pour zugferd-rs libxml2 et libclang. Les mesures durent environ 45 minutes sur un Apple M4 Pro, dont 18 pour TypeScript à cause des validateurs lents ; les relevés d'exactitude, une dizaine. Les lancer sur une machine au repos, sur secteur ou en mode hautes performances, capot ouvert : caffeinate empêche la veille d'inactivité, pas celle du capot fermé.

Les sorties brutes de la campagne du 17 novembre 2026 (v0.1.0) sont dans results/2026-11-17/. Elles remplacent celles de la campagne précédente du même jour (commit 4194b98), que conserve l'historique git.

Licences : le harnais est sous licence MIT, comme le dépôt, et ses dépendances ne sont pas importées par ZeRechnung. Certaines ont des licences restrictives : AGPL-3.0 (pdf-invoice), EUPL-1.2 (@stackforge-eu/factur-x, artefacts CEN), licence Saxonica (SaxonJS, utilisé par @conformo, @kontor-mcp et @stafyniaksacha), MPL-2.0 (saxonche).

Clone this wiki locally