Benchmarks canoniques multilingues

Cette page rapporte une exécution locale complète de la suite canonique benchLANG le 12/07/2026. Les 19 implémentations de langage configurées ont réalisé les cinq charges de travail avec des résultats valides.

La suite a été exécutée sur Linux 7.0.0 x86-64 avec un AMD Ryzen 9 5900X (12 cœurs, 24 threads) et 30 Go de RAM. Chaque langage a été compilé une fois et exécuté une fois. La machine n'était pas isolée, la fréquence de son processeur n'était pas verrouillée et d'autres charges système étaient présentes. Ces mesures constituent donc un instantané reproductible et non une revendication de classement statistiquement stable.

Les charges de travail canoniques sont :

Le temps d'exécution est le temps écoulé interne de la charge de travail. Le temps de compilation est le temps écoulé pour la construction de la suite. LOC compte le fichier source complet pour cette langue. Le pic RSS est mesuré pour le processus complet de la suite avec /usr/bin/time -v, et la taille binaire est l'artefact complet généré par la suite. Étant donné que les cinq charges de travail partagent un fichier source, les métriques de build, LOC, RSS et binaires se répètent dans chaque tableau de charge de travail. — signifie que le chemin d'exécution du lancement source, piloté par JIT ou interprété n'a pas produit de phase de compilation mesurée séparément ou de binaire autonome.

Tamis principal

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
C 2.608 0,33 172 33,1 Mo 28,3 Ko
Rust 2.609 2,69 142 33,3 Mo 2,04 Mio
Nim 2.612 1,44 119 50,0 Mio 52,1 Ko
Zig 2.612 4.23 180 32,9 Mo 204,0 Ko
D 2.614 3.10 133 97,3 Mo 1,13 Mio
Java 2,615 — 127 561,8 Mo —
Fortran 2.616 0,59 233 33,6 Mo 32,5 Ko
Ada 2.617 0,98 224 34,8 Mo 48,7 Ko
seed 2.622 0,84 218 33,2 Mo 27,8 Ko
C# 2.630 4.37 129 116,9 Mo 77,1 Ko
JavaScript (Chignon) 2.649 — 108 342,8 Mo —
JavaScript (nœud) 2.663 — 108 303,2 Mo —
Fléchette 2.905 1.22 130 69,8 Mo 6,45 Mo
Allez 3.054 2,83 157 52,9 Mo 1,53 Mo
OCaml 3.090 0,31 118 87,4 Mo 1,86 Mo
Pascal 3.110 0,22 205 32,2 Mo 548,3 Ko
PHP 3.198 — 127 179,2 Mo —
Python (PyPy3) 3.297 — 127 376,5 Mo —
Python (Python3) 60.688 — 127 153,1 Mo —

Fibonacci récursif

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
Nim 0,096 1,44 119 50,0 Mio 52,1 Ko
Fortran 1.682 0,59 233 33,6 Mo 32,5 Ko
C 1.710 0,33 172 33,1 Mo 28,3 Ko
Ada 1.762 0,98 224 34,8 Mo 48,7 Ko
seed 2.979 0,84 218 33,2 Mo 27,8 Ko
Zig 3.074 4.23 180 32,9 Mo 204,0 Ko
Rust 3.082 2,69 142 33,3 Mo 2,04 Mio
D 3.083 3.10 133 97,3 Mo 1,13 Mio
C# 3.323 4.37 129 116,9 Mo 77,1 Ko
Java 3.974 — 127 561,8 Mo —
OCaml 5.235 0,31 118 87,4 Mo 1,86 Mo
Allez 5.584 2,83 157 52,9 Mo 1,53 Mo
Pascal 5.709 0,22 205 32,2 Mo 548,3 Ko
JavaScript (Chignon) 7.489 — 108 342,8 Mo —
Fléchette 7.850 1.22 130 69,8 Mo 6,45 Mo
JavaScript (nœud) 11.452 — 108 303,2 Mo —
Python (PyPy3) 12.589 — 127 376,5 Mo —
PHP 18.944 — 127 179,2 Mo —
Python (Python3) 113.390 — 127 153,1 Mo —

Le résultat Nim est rapporté exactement tel que mesuré, mais son temps fib(45) est un fort signal de spécialisation d'optimiseur ou de repliement constant. Elle ne doit pas être utilisée comme preuve comparative tant que la charge de travail n’a pas obtenu un apport anti-pliement.

Traitement des chaînes

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
Zig 1.448 4.23 180 32,9 Mo 204,0 Ko
seed 1.513 0,84 218 33,2 Mo 27,8 Ko
JavaScript (nœud) 1.812 — 108 303,2 Mo —
Rust 2.105 2,69 142 33,3 Mo 2,04 Mio
C 2.124 0,33 172 33,1 Mo 28,3 Ko
Nim 2.188 1,44 119 50,0 Mio 52,1 Ko
C# 2.228 4.37 129 116,9 Mo 77,1 Ko
Ada 2.310 0,98 224 34,8 Mo 48,7 Ko
D 2.430 3.10 133 97,3 Mo 1,13 Mio
JavaScript (Chignon) 2.742 — 108 342,8 Mo —
Allez 2.823 2,83 157 52,9 Mo 1,53 Mo
Fortran 3.405 0,59 233 33,6 Mo 32,5 Ko
Java 4.018 — 127 561,8 Mo —
OCaml 4.093 0,31 118 87,4 Mo 1,86 Mo
Python (PyPy3) 4.896 — 127 376,5 Mo —
Fléchette 5.871 1.22 130 69,8 Mo 6,45 Mo
PHP 7.251 — 127 179,2 Mo —
Pascal 12.094 0,22 205 32,2 Mo 548,3 Ko
Python (Python3) 38.324 — 127 153,1 Mo —

Mandelbrot

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
Nim 1.855 1,44 119 50,0 Mio 52,1 Ko
Allez 1.911 2,83 157 52,9 Mo 1,53 Mo
Fortran 2.028 0,59 233 33,6 Mo 32,5 Ko
Ada 2.036 0,98 224 34,8 Mo 48,7 Ko
C 2.103 0,33 172 33,1 Mo 28,3 Ko
D 2.116 3.10 133 97,3 Mo 1,13 Mio
Rust 2.116 2,69 142 33,3 Mo 2,04 Mio
seed 2.119 0,84 218 33,2 Mo 27,8 Ko
Zig 2.119 4.23 180 32,9 Mo 204,0 Ko
C# 2.120 4.37 129 116,9 Mo 77,1 Ko
Fléchette 2.166 1.22 130 69,8 Mo 6,45 Mo
Java 2.166 — 127 561,8 Mo —
JavaScript (nœud) 2.167 — 108 303,2 Mo —
OCaml 2.173 0,31 118 87,4 Mo 1,86 Mo
JavaScript (Chignon) 2.177 — 108 342,8 Mo —
Pascal 2.179 0,22 205 32,2 Mo 548,3 Ko
Python (PyPy3) 2.280 — 127 376,5 Mo —
PHP 5.994 — 127 179,2 Mo —
Python (Python3) 73.626 — 127 153,1 Mo —

Arbres binaires

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
Java 0,550 — 127 561,8 Mo —
OCaml 0,924 0,31 118 87,4 Mo 1,86 Mo
JavaScript (Chignon) 0,930 — 108 342,8 Mo —
Nim 0,939 1,44 119 50,0 Mio 52,1 Ko
Fléchette 0,959 1.22 130 69,8 Mo 6,45 Mo
C# 1.121 4.37 129 116,9 Mo 77,1 Ko
JavaScript (nœud) 1.223 — 108 303,2 Mo —
seed 1.263 0,84 218 33,2 Mo 27,8 Ko
Pascal 1.560 0,22 205 32,2 Mo 548,3 Ko
Fortran 1.600 0,59 233 33,6 Mo 32,5 Ko
C 1.626 0,33 172 33,1 Mo 28,3 Ko
Ada 1.795 0,98 224 34,8 Mo 48,7 Ko
Zig 1.943 4.23 180 32,9 Mo 204,0 Ko
Allez 1.951 2,83 157 52,9 Mo 1,53 Mo
Rust 2.233 2,69 142 33,3 Mo 2,04 Mio
D 3.352 3.10 133 97,3 Mo 1,13 Mio
Python (PyPy3) 5.801 — 127 376,5 Mo —
PHP 6.796 — 127 179,2 Mo —
Python (Python3) 16.851 — 127 153,1 Mo —

Suite complète

La durée d'exécution d'une suite complète correspond à la somme indiquée par chaque implémentation pour les cinq charges de travail. Il est inclus à titre d'aperçu ; les tableaux de charge de travail ci-dessus restent la principale comparaison.

Langue Exécution(s) Compiler(s) LOC Pic RSS Binaire
Nim 7.698 1,44 119 50,0 Mio 52,1 Ko
C 10.171 0,33 172 33,1 Mo 28,3 Ko
seed 10.496 0,84 218 33,2 Mo 27,8 Ko
Ada 10.521 0,98 224 34,8 Mo 48,7 Ko
Zig 11.194 4.23 180 32,9 Mo 204,0 Ko
Fortran 11.331 0,59 233 33,6 Mo 32,5 Ko
C# 11.424 4.37 129 116,9 Mo 77,1 Ko
Rust 12.146 2,69 142 33,3 Mo 2,04 Mio
Java 13.331 — 127 561,8 Mo —
D 13.595 3.10 133 97,3 Mo 1,13 Mio
Allez 15.322 2,83 157 52,9 Mo 1,53 Mo
OCaml 15.515 0,31 118 87,4 Mo 1,86 Mo
JavaScript (Chignon) 15.989 — 108 342,8 Mo —
JavaScript (nœud) 19.319 — 108 303,2 Mo —
Fléchette 19.752 1.22 130 69,8 Mo 6,45 Mo
Pascal 24.652 0,22 205 32,2 Mo 548,3 Ko
Python (PyPy3) 28.863 — 127 376,5 Mo —
PHP 42.224 — 127 179,2 Mo —
Python (Python3) 302.933 — 127 153,1 Mo —

Le seed Le fichier de corpus a été réécrit par la suite (15/10/2026) dans l'idiome de surface actuel (if let/while let, [0 as usize; 32], text.split_ascii + SplitToken.slice, tôt return, expr; déclarations), ce qui modifie le seed ligne uniquement : 173 loc, et sur le même hôte Ryzen 9 5900X, une réexécution a mesuré 8,384 s temps de suite complète, 0.76s compiler, 58.3 KiB binaire, 33.0 MiB pic RSS avec des sommes de contrôle inchangées. Une entrée C++ (g++ -std=c++23 -O3 -march=native -flto) a été ajouté au harnais lors du même changement et a mesuré 7,605s, 159 loc, 1.44s compiler, 53.8 KiB, 35.7 MiB sur cet hôte. Les deux sont des observations uniques sur une machine non isolée ; les tableaux ci-dessus restent l'instantané du 12/07/2026 qu'ils décrivent.

Reproduction

L'exécution complète utilisée :

cd benchLANG
./run_benchmarks.sh --runs 1 --timeout 600

Les corrections du cache de la chaîne d'outils locale ont été suivies de réexécutions ciblées pour Zig, Go, Nim, C# et Dart. Les tableaux fusionnent uniquement le dernier résultat réussi pour chaque langue.