La version 1.13 du langage de programmation Julia est disponible

Jade Emy — Mon, 14 Sep 2026 11:21:05 GMT

La version 1.13 du langage de programmation Julia est disponible, avec des gains de vitesse significatifs au niveau de la pr�compilation, du d�marrage et du ramasse-miettes

Le projet Julia a publi� la version 1.13 de son langage de programmation. Cette version met fortement l'accent sur la r�duction de la latence, l'un des points faibles de longue date de Julia. Selon l'annonce, la pr�compilation des paquets prend d�sormais environ 30 % moins de temps que dans Julia 1.12, et 10 � 20 % moins de temps que la version 1.10 � support � long terme, selon la machine, tandis que le d�marrage lui-m�me est environ 20 % plus rapide que dans la version pr�c�dente. Un autre point fort majeur est une modification apport�e au ramasse-miettes. Le co�t d�un ramassage complet �volue d�sormais en fonction du tas effectivement cr�� par un programme plut�t que de la quantit� de code charg�.

Julia est un langage de programmation de haut niveau, performant et dynamique con�u pour le calcul scientifique et les applications de calcul num�rique. Sa syntaxe est famili�re aux utilisateurs d'autres environnements de d�veloppement tels que MATLAB, R, Scilab, et Python. Julia est connue pour sa vitesse et ses capacit�s avanc�es en termes de calcul parall�le et de gestion de donn�es volumineuses. Julia combine les avantages des langages compil�s (tels que C et Fortran) avec la flexibilit� des langages dynamiques.

Bien qu'�tant un langage g�n�raliste dans sa conception, Julia est majoritairement utilis� dans le monde scientifique. On le retrouve notamment dans des domaines tels que la science des donn�es, la mod�lisation num�rique, la statistique, l'apprentissage automatique ou encore la biologie et la climatologie. Les utilisateurs du langage sont en majorit� des ing�nieurs, des chercheurs ou des �tudiants, qui l'utilisent pour faire de la recherche scientifique ou comme un passe-temps. Certains utilisateurs trouvent dans Julia un langage avec une syntaxe simple comme Python tout en ayant des performances �lev�es.

Le projet Julia a publi� la version 1.13 de son langage de programmation. Cette version met fortement l'accent sur la r�duction de la latence, l'un des points faibles de longue date de Julia. Selon l'annonce, la pr�compilation des paquets prend d�sormais environ 30 % moins de temps que dans Julia 1.12, et 10 � 20 % moins de temps que la version 1.10 � support � long terme, selon la machine, tandis que le d�marrage lui-m�me est environ 20 % plus rapide que dans la version pr�c�dente. Afin de limiter les r�gressions futures, le projet a �galement int�gr� la surveillance de la latence dans son propre pipeline de d�veloppement : des t�ches d�int�gration continue d�di�es au temps de premier trac�/ex�cution (TTFX) s�ex�cutent d�sormais sur les pull requests et � chaque commit vers la branche master, les r�sultats �tant suivis publiquement.

Un autre point fort majeur est une modification apport�e au ramasse-miettes. Les objets pr�sents dans l�image syst�me et les images de paquets sont d�sormais charg�s en tant qu�objets marqu�s de mani�re permanente et ignor�s par la phase de marquage du ramasse-miettes, les rares mutations qui se produisent �tant suivies s�par�ment. En cons�quence, le co�t d�un ramassage complet �volue d�sormais en fonction du tas effectivement cr�� par un programme plut�t que de la quantit� de code charg�. La diff�rence est frappante au vu des chiffres pr�sent�s dans l�article de blog : le temps d�ex�cution d�un GC.gc() complet dans une nouvelle session �tait d�environ 0,035 seconde dans Julia 1.12, contre environ 0,0005 seconde dans la version 1.13, soit une r�duction de pr�s de 70 fois.

Au-del� des performances, cette version apporte toute une s�rie de fonctionnalit�s pratiques destin�es aux d�veloppeurs. Une nouvelle macro publique @__FUNCTION__ vient s�ajouter � @__MODULE__ et @__FILE__ pour r�f�rencer la fonction contenante la plus interne, y compris les fonctions anonymes. En coulisses, l�algorithme de hachage par d�faut pour les cha�nes de caract�res et de nombreux types num�riques a �t� remplac� : MurmurHash3 a c�d� la place � RapidhashNano, un hachage en continu �crit en Julia pur qui, selon les d�veloppeurs, est nettement plus rapide et plus facile � maintenir.

Le d�bogage b�n�ficie �galement d�am�liorations : un nouvel indicateur de ligne de commande --trace-eval affiche la progression de l��valuation au niveau sup�rieur afin de faciliter la d�tection des blocages dans les scripts et les suites de tests ; il est activ� automatiquement lorsque la journalisation de d�bogage est activ�e pour les ex�cutions en int�gration continue (CI). Enfin, l�outil exp�rimental de � trimming � juliac est d�sormais disponible sous la forme d�un v�ritable paquet appel� JuliaC.jl, prenant en charge le � trimming � d�un plus grand nombre de constructions telles que les finaliseurs, @cfunction et mapreduce, ce qui constitue une avanc�e pour la production de binaires Julia compil�s plus l�gers.

Voici quelques points forts de Julia 1.13 :

Am�liorations de la latence (TTFX)

Julia 1.13 met environ 30 % moins de temps � pr�compiler les paquets que la version 1.12, et environ 10 � 20 % moins de temps que la version 1.10 (LTS), selon la machine.

Le � Time To First X � (TTFX), c'est-�-dire le temps �coul� entre le d�marrage de Julia et l'obtention d'un premier r�sultat, se compose de trois co�ts principaux : la pr�compilation des paquets, leur chargement et l'ex�cution du code. Gr�ce aux workflows propos�s par la communaut� sur Julia-TTFX-Snippets, nous avons commenc� � mesurer ces co�ts de mani�re plus syst�matique � partir d�exemples concrets et � optimiser Julia en fonction de ceux-ci.

Le graphique ci-dessous pr�sente la moyenne g�om�trique des 39 workflows actuellement propos�s, sur deux machines. La pr�compilation correspond au meilleur temps sur deux ex�cutions ; les temps de chargement et d�ex�cution correspondent au meilleur temps sur trois ex�cutions.

Ce suivi fait d�sormais partie int�grante du processus de d�veloppement de Julia : de nouvelles t�ches de CI TTFX sont ex�cut�es sur les pull requests pertinentes et � chaque commit sur la branche master, et les r�sultats sont suivis sur perf.julialang.org/ttfx. Ce suivi a �t� mis en place le 7 septembre 2026 ; les mesures effectu�es avant cette date �taient ponctuelles.

Le d�marrage de Julia 1.13 est �galement environ 20 % plus rapide que celui de la version 1.12.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
% hyperfine --warmup 3 --runs 20 -N \
  --command-name "julia 1.12" "julia +1.12 --startup-file=no -e ''" \
  --command-name "julia 1.13" "julia +1.13 --startup-file=no -e ''"
Benchmark 1: julia 1.12
  Time (mean ± σ):      69.1 ms ±   1.0 ms    [User: 50.1 ms, System: 18.1 ms]
  Range (min … max):    68.0 ms …  72.6 ms    20 runs
 
Benchmark 2: julia 1.13
  Time (mean ± σ):      56.7 ms ±   0.5 ms    [User: 49.1 ms, System: 18.9 ms]
  Range (min … max):    56.0 ms …  58.1 ms    20 runs
 
Summary
  julia 1.13 ran
    1.22 ± 0.02 times faster than julia 1.12

Am�liorations du REPL

Mise en �vidence de la syntaxe

Le REPL de Julia dispose d�sormais d�une mise en �vidence de la syntaxe (sans avoir � charger un paquet externe tel que OhMyREPL.jl) :

Par d�faut, le jeu de couleurs est assez sobre, mais il est facile � personnaliser (voir la documentation du REPL). � titre d�exemple, voici le m�me code en utilisant le jeu de couleurs Monokai :

Nouvelle recherche dans l�historique de type fzf

La recherche dans l�historique (accessible par d�faut via Ctrl-R) a �t� repens�e et fonctionne d�sormais de mani�re similaire � l�outil de recherche floue en ligne de commande fzf :

Entre autres, la nouvelle recherche dans l�historique prend en charge :

- La recherche floue dans l�historique.
- L�affichage du mode REPL utilis� pour la commande.
- La s�lection de plusieurs r�sultats de recherche � placer dans le tampon de l�invite.
- La mise en �vidence de la syntaxe du code, en accord avec celle du REPL lui-m�me.

Acc�dez � la recherche dans l�historique et tapez ? pour consulter l�aide compl�te.

Collage entre crochets sous Windows

Le collage entre crochets permet � une application s�ex�cutant dans un terminal de savoir quand du texte est coll� (par opposition � une simple saisie). Cela permet un traitement plus efficace et plus pr�cis du texte coll�. Cette fonctionnalit� est disponible depuis longtemps sous Linux et macOS, mais elle est d�sormais enfin disponible sous Windows.

@__FUNCTION__

� l�instar des macros existantes @__MODULE__ et @__FILE__, la nouvelle macro @__FUNCTION__ fait r�f�rence � la fonction contenante la plus interne, m�me si cette fonction est anonyme. Cela devrait fonctionner dans tous les types de fonctions et constitue une API publique, contrairement � la variable interne #self#.

Code:

1
2
3
4
julia> fact = n -> n <= 1 ? 1 : n * @__FUNCTION__()(n - 1);
 
julia> fact(5)
120

Modifications apport�es au hachage

La fonction de hachage a �t� remplac�e. L�algorithme de hachage par octet est d�sormais RapidhashNano. Ce hachage est utilis� par d�faut pour AbstractString et de nombreux types num�riques tels que BigInt, Rational, ainsi que les valeurs Real ou Integer de grande taille. Il est d�sormais �galement beaucoup plus facile pour les types personnalis�s d�adopter les impl�mentations g�n�riques sans avoir � se convertir au pr�alable en un type pris en charge (comme String). Ce changement offre plusieurs avantages par rapport � l�impl�mentation pr�existante bas�e sur MurmurHash3. Il offre des performances nettement sup�rieures, s�agit d�un hachage en continu qui ne n�cessite donc plus de conna�tre la longueur de l�entr�e � l�avance, et a �t� r��crit en Julia pur (au lieu de C) pour une meilleure lisibilit� et maintenabilit�.

Pour illustrer l�am�lioration des performances sur les longues cha�nes de caract�res :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
using BenchmarkTools, Downloads
 
io = IOBuffer()
Downloads.download("https://www.gutenberg.org/cache/epub/1080/pg1080.txt", io)
s = String(take!(io));
 
# 1.12
@btime hash($s)
  8.555 μs (0 allocations: 0 bytes)
0x5fbd2717019846ea
 
# 1.13
@btime hash($s)
  1.742 μs (0 allocations: 0 bytes)
0x718308e795047519

Et une d�monstration de l�utilisation d�une solution de repli plus rapide :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
struct MyString <: AbstractString
    s::String
end
m = MyString(s);
 
# 1.12
Base.iterate(m::MyString) = iterate(m.s)
Base.iterate(m::MyString, i::Integer) = iterate(m.s, i)
@btime hash($m)
  204.583 μs (21 allocations: 107.02 KiB)
0x5fbd2717019846ea
 
# 1.13
Base.codeunit(m::MyString) = codeunit(m.s)
Base.codeunits(m::MyString) = codeunits(m.s)
@btime hash($m)
  1.750 μs (0 allocations: 0 bytes)
0x718308e795047519

Le hachage des petites donn�es � largeur fixe a �galement �t� modifi�. L��tape finale de m�lange est d�sormais une construction XMX � un seul tour avec des constantes soigneusement ajust�es, et l��tape de m�lange produit d�sormais correctement un effet d�avalanche lors de la composition d�appels de hachage ; auparavant, l��tape de m�lange se simplifiait toujours en une fonction lin�aire � chaque profondeur de composition. Cette modification de l��tape de m�lange introduit une d�pendance aux donn�es (et donc potentiellement une baisse de performances) lors du hachage s�quentiel d��l�ments dans une boucle serr�e, par exemple foldr(hash, collection), mais l�algorithme de hachage d�AbstractArray a �t� partiellement d�roul� pour les tailles petites � moyennes, en maintenant plusieurs accumulateurs de hachage en parall�le, et sera bien plus rapide pour la plupart des longueurs.

Quelques rappels importants : la fonction hash reste non cryptographique. De plus, la graine par d�faut a chang�. Les m�thodes de hachage personnalis�es doivent toujours accepter la graine en tant qu�argument, comme hash(x::MyType, h::UInt), et ne jamais fournir de valeur par d�faut, comme hash(x::MyType, h::UInt=0), car la graine correcte est d�termin�e par l�appelant.

Acc�l�ration du ramasse-miettes (GC) en ignorant les objets d�image lors du marquage

Chaque session Julia commence avec un grand nombre d�objets charg�s � partir de l�image syst�me, et chaque paquet charg� apporte sa propre image de paquet contenant encore davantage d�objets : tables de m�thodes, informations de type, code compil�, constantes, etc. Ces objets ne sont jamais lib�r�s et sont rarement modifi�s ; pourtant, jusqu�� pr�sent, un ramasse-miettes complet les parcourait tous pour les marquer comme accessibles, au m�me titre que n�importe quel autre objet du tas. Pour une session comportant quelques paquets volumineux charg�s, cela pouvait facilement constituer le co�t principal d�un ramassage complet.

Dans Julia 1.13, les objets de l�image syst�me et des images de paquets sont charg�s en tant qu�objets marqu�s de mani�re permanente, et la phase de marquage ne les parcourt jamais. Les rares modifications qui affectent les objets d�image (par exemple, lorsqu�une m�thode est ajout�e � une fonction existante) sont suivies s�par�ment, de sorte que tout nouvel objet vers lequel ils pointent reste en vie. Il en r�sulte que le co�t d�un ramassage complet �volue d�sormais en fonction de la taille du tas effectivement cr�� par votre programme, et non plus en fonction de la quantit� de code charg�e.

Le moyen le plus simple de constater la diff�rence est de chronom�trer un ramassage complet dans une nouvelle session :

Code:

1
2
3
4
5
6
7
# 1.12
julia> @time GC.gc()
  0.035493 seconds (99.90% gc time)
 
# 1.13
julia> @time GC.gc()
  0.000528 seconds (99.08% gc time)

Le tableau ci-dessous indique la dur�e d�un ramassage complet (GC.gc(true)) sur un Apple M4 Pro, d�abord dans une session vierge, puis apr�s le chargement de plusieurs paquets de taille croissante. Les collectes incr�mentielles (jeune g�n�ration) ne sont pas affect�es par ce changement et sont tout aussi rapides sur les deux versions.

�tant donn� que les collectes compl�tes sont d�clench�es plus souvent pour les programmes disposant d�un tas actif volumineux, cela se traduit �galement par une r�duction du temps global de GC dans les charges de travail r�elles. L�exemple suivant ins�re des vecteurs al�atoires dans un Dict qui est conserv� d�une it�ration � l�autre, de sorte qu�une grande partie des objets allou�s soit promue vers l�ancienne g�n�ration :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
function work(n)
    d = Dict{Int,Vector{Float64}}()
    for i in 1:n
        d[i % 50_000] = rand(64)
    end
    return length(d)
end
 
# 1.12
julia> @time work(5_000_000)
  1.699095 seconds (10.00 M allocations: 2.688 GiB, 79.80% gc time)
 
# 1.13
julia> @time work(5_000_000)
  0.566276 seconds (10.00 M allocations: 2.688 GiB, 44.32% gc time)

Corrections du planificateur et des interruptions

Les threads inactifs sont d�sormais plac�s dans une t�che d�di�e du planificateur au lieu de rester attach�s � la derni�re t�che qu�ils ont ex�cut�e, ce qui permet aux t�ches termin�es d��tre collect�es rapidement par le ramasse-miettes. Cette modification s�accompagne d�un ensemble de corrections li�es au planificateur, notamment celles qui r�tablissent la fiabilit� des interruptions :

- La combinaison Ctrl-C atteint � nouveau le code utilisateur, y compris les scripts bloqu�s en mode veille ou en E/S, et la fonction Distributed.interrupt fonctionne.
- Le REPL r�siste � des appuis r�p�t�s et mal synchronis�s sur Ctrl-C.
- @spawn r�veille un seul thread inactif dans le pool de threads de la t�che au lieu de tous les threads. Le code faisant un usage intensif de spawn gagne en vitesse : pas du tout sous macOS, de 1,1 � 1,6 fois sur une machine Linux � 16 c�urs, et de 10 � 300 fois sous Windows et sur les machines fortement surcharg�es, o� le r�veil de chaque thread constituait le co�t principal.
- Plusieurs probl�mes de perte de t�ches et de blocages ont �t� corrig�s.

Le d�veloppement d�un m�canisme d�annulation de t�ches appropri� est en cours et pr�vu pour Julia 1.14.

Source : Annonce de Julia 1.13

Et vous ?

:fleche: Pensez-vous que cette version est cr�dible ou pertinente ?
:fleche: Quel est votre avis sur le sujet ?

Voir aussi :

:fleche: La version 1.12 du langage de programmation Julia est disponible, avec la red�finition des constantes et des structures, de nouvelles fonctionnalit�s de multithreading et bien plus encore

:fleche: La version 1.11 du langage de programmation Julia est disponible, apportant un nouveau type "Memory" et de nouvelles fonctionnalit�s � l'inf�rence

:fleche: Le potentiel du langage de programmation Julia pour le calcul en physique des hautes �nergies, un domaine qui n�cessite d'�normes quantit�s de calcul et de stockage, selon une �tude scientifique

Images attach�es

Forum du club des d�veloppeurs et IT Pro - Julia

La version 1.13 du langage de programmation Julia est disponible