From 8532fdf1e8fb675d18285feb5a394a9a5688e55c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9my=20Rakic?= Date: Thu, 28 Aug 2025 14:34:24 +0000 Subject: [PATCH 1/5] add announcement / call for testing for lld on 1.90.0 --- content/rust-lld-on-stable-1.90.0/index.md | 65 ++++++++++++++++++ .../ripgrep-comparison.png | Bin 0 -> 10192 bytes 2 files changed, 65 insertions(+) create mode 100644 content/rust-lld-on-stable-1.90.0/index.md create mode 100644 content/rust-lld-on-stable-1.90.0/ripgrep-comparison.png diff --git a/content/rust-lld-on-stable-1.90.0/index.md b/content/rust-lld-on-stable-1.90.0/index.md new file mode 100644 index 000000000..6c21a79da --- /dev/null +++ b/content/rust-lld-on-stable-1.90.0/index.md @@ -0,0 +1,65 @@ ++++ +path = "2025/08/29/rust-lld-on-1.90.0-stable" +title = "Faster linking times with 1.90.0 stable on Linux using `rust-lld`" +authors = ["Rémy Rakic"] + +[extra] +team = "the compiler performance working group" +team_url = "https://www.rust-lang.org/governance/teams/compiler#team-wg-compiler-performance" ++++ + +TL;DR: rustc will use `rust-lld` by default on `x86_64-unknown-linux-gnu` on stable, starting in 1.90.0, to significantly reduce linking times. Test it out on beta now, and please report issues if you encounter any. + +#### Some context + +Linking time is often a big part of compilation time. When rustc needs to build a binary or a shared library, it will usually call the default linker installed on the system to do that (this can be changed on the command-line or by the target for which the code is compiled). + +The linkers do an important job, with concerns about stability, backwards-compatibility and so on. For these and other reasons, on the most popular operating systems they usually are older programs, designed when computers only had a single core. So, they usually tend to be slow on a modern machine. For example, when building ripgrep 13 in debug mode on Linux, roughly half of the time is actually spent in the linker. + +There are different linkers, however, and the usual advice to improve linking times is to use one of these newer and faster linkers, like LLVM's [`lld`](https://lld.llvm.org/) or Rui Ueyama's [`mold`](https://github.com/rui314/mold). + +Some of Rust's wasm and aarch64 targets already use `lld` by default. When using rustup, rustc ships with a version of `lld` for this purpose. When CI builds LLVM to use in the compiler, it also builds the linker and packages it. It's referred to as `rust-lld` to avoid colliding with any `lld` already installed on the user's machine. + +Since improvements to linking times are substantial, it would be a good default to use in the most popular targets. This has been discussed for a long time, for example in issues [#39915](https://github.com/rust-lang/rust/issues/39915) and [#71515](https://github.com/rust-lang/rust/issues/71515). + +To expand our testing, we have enabled rustc to use `rust-lld` by default on nightly, [in May 2024](https://blog.rust-lang.org/2024/05/17/enabling-rust-lld-on-linux.html). No major issues have been reported since then. + +We believe we've done all the internal testing that we could, on CI, crater, on our benchmarking infrastructure and on nightly, and plan to enable `rust-lld` to be the linker used by default on `x86_64-unknown-linux-gnu` for stable builds in 1.90.0. + +#### Benefits + +While this also enables the compiler to use more linker features in the future, the most immediate benefit is much improved linking times. + +Here are more details from the ripgrep example mentioned above: for an incremental rebuild, linking is reduced 7x, resulting in a 40% reduction in end-to-end compilation times. For a from-scratch debug build, it is a 20% improvement. + +![Before/after comparison of a `ripgrep` incremental debug build](ripgrep-comparison.png) + +Most binaries should see some improvements here, but it's especially significant with e.g. bigger binaries, or for incremental rebuilds, or when involving debuginfo. These usually see bottlenecks in the linker. + +Here's [a link](https://perf.rust-lang.org/compare.html?start=b3e117044c7f707293edc040edb93e7ec5f7040a&end=baed03c51a68376c1789cc373581eea0daf89967&stat=instructions%3Au&tab=compile) to the complete results from our benchmarks. + +This testing period did go well indeed, and we can stabilize using this faster linker by default for `x86_64-unknown-linux-gnu` users. + +#### Possible drawbacks + +From our prior testing, we don't really expect issues to happen in practice. It is a drop-in replacement for the vast majority of cases, but `lld` is not _bug-for-bug_ compatible with GNU ld. + +In any case, using `rust-lld` can be disabled if any problem occurs: use the `-C linker-features=-lld` flag to revert to using the system's default linker. + +Some crates somehow relying on these differences could need additional link args, though we also expect this to be quite rare. + +Some of the big gains in performance come from parallelism, which could be undesirable in resource-constrained environments, or for heavy projects that are already reaching hardware limits. + +#### Summary, and call for testing + +rustc will use `rust-lld` on `x86_64-unknown-linux-gnu`, starting with the 1.90.0 stable release, for much improved linking times. This version 1.90.0 will be released next month, on the 18th of September 2025. + +This linker change is already available on the current beta (`1.90.0-beta.6`). To help everyone prepare for this landing on stable, please test your projects on beta and let us know if you encounter problems, by [opening an issue](https://github.com/rust-lang/rust/issues/new/choose) on GitHub. + +If that happens, you can revert to the default linker with the `-C linker-features=-lld` flag. Either by adding it to the usual `RUSTFLAGS` environment variable, or to a project's [`.cargo/config.toml`](https://doc.rust-lang.org/cargo/reference/config.html) configuration file, +like so: + +```toml +[target.x86_64-unknown-linux-gnu] +rustflags = ["-Clinker-features=-lld"] +``` diff --git a/content/rust-lld-on-stable-1.90.0/ripgrep-comparison.png b/content/rust-lld-on-stable-1.90.0/ripgrep-comparison.png new file mode 100644 index 0000000000000000000000000000000000000000..98ccf43de85774e6506a0f9feba40671a5babd90 GIT binary patch literal 10192 zcmeI2c{o)4|Nm`eP$5ZWmk=?HNReeo5=F8k%-q?_GTE~)VeBeIxtT#CWGpcTL)o)r zD*ISMG?p1*G7QG=Xt_W4=f1!H{jT42{r>p6u5q0+XU=$I9B(D6`G(r@SmY&go1M4J=D| zOz2r|3d1>MeQl5vzq(k#Xos&T2^DWbKa1|nAw};qhnMo)-}bQ^59rEJnOKa|9UjSv zxGsFoYc^qcd|YH0_44IO%pXfdmxGt5qMkl|dj9ifGm^V!Yb)qva-~!6v#hKvXkDfX z;#q5J>qm_d^g>ChK@t1|lk+)AF>uXU6_uWRgY@qHVhi?0L|o{N^HxshGFR}|1dqCS zvw-Lqqv5Whc9f6}8(Yj)=5f+$^6dc;F;e9L(Kf$~H)=~qRvDYZXUm8$=9)eExNzHn_F@VehUNgm9JlW zzY$7YkkRN%<918V+W>o{UEzIo;N&!ETxAVESy#}9&Hd9Sw7}zFAcH|`JGZFY2o81nr$f*Q)J?}ZjtGsevfJKLY)QgrW}CUsK&k^B zM;x&3IDE`S{xR8oruLT`+ml7PqiPo{o%evvF2>Y+Fu8A8Wg32)Yeco9))%J{eZON1 zQXH#WT~J}dj4AhMKUMjuy;IpPPjrQQd?ix_dIPUUtime)Nm9$Z|P|K&JJJ$~kl~=$!hiMl{ z*&mx_77kJKS`tSWY%f(i@kMBae;?7y6ZK3vZBy_}f~3Zu^zO`FsHQ)pecG49x?z+O zq@LBI@K)3FONSOgAa*tbPdm>Qz>8jaW=dG=4A39DIE! zcLy{G;v4M>Ry7irBsrXVmy&xoToH=kx_&3KsWusl-Zr_qog$#Aptpe|F)9oOPJr7^ zkZ!EBqd{YT%qcGhYpgw&jC|vq#Tg02&K=9wH(B2cK@i5-`TUG$v z+!KQgoYNnx4u9E%H9RsfwZ#yFoS@|(m_Zx)hGyQwa@3b4eG|E?eWr_M8`TjN6<>4H zeEF%mjHsy>+d)JrZJdQgeVtNL1L>qHXo-xS&@j$1@s5t5+rmG|3Qi2{o0~3XDu*9& zem|l;mR@N#eTm|8Qjmz<14X?Nf})t>U+@&B0IBKPvxGfBR=;}Q*i^zr^L5<`lHw~X z+0qv^EFTq`2Xrdq+EN&*1y;3W5zYbgclbc}u)uSuM7aODxy1}YHSokO?zPJE=C@Cr zExf-f{NBRe$#Q-u#M!Xx3MH5k#fD#O^|c_8w`9BUikhBv?&(9tWZ7q$jP>cygC}co zP6*cJu^WndGEU0a=UHFUg$~@=ag*t^yrXtyv;#j{QLPckOXWBPe9D|T!&N!NNDI&3 z-Q+oE7{(t^!NOw68*`Gqw^KZ!Cz=U2h&Kj?-ZtVNL;pjWw75YvaxG@n98@M&g@kY> zoXTEO_(?T+64@j-SLf2mrC2l~^V}-*^A1pj{vME$K^Q;XaYIq{r?#TSSrR$vgzQws zPJD-&W}E{eB9`m?0jwbtbVBjoiw8e7uTKZ93|%U%sVg`)ANzRi z<-_WDy7D1PY{i;>s!48Ref@>?@f+JUaClB5cC$72BBA|pt}xqOsW3F=s7y2TjX0pJ zCw?ibFIguGFZAl!>0cJheZk{V5482 z)HNH=AsL|&eb7yezyyRLtMSo;EdODThic&iZ1_N#?9?~Nwet4V(S?j#dp=v`q>H8X z2=HBI3*L8PL<`Lf4CP+5q9oApFTcn^%x|~hf)DY?G5H6mtSt31+a(Djoj*@&2F46=tza%!TPR-jQCZI*F+8~f0v)p$PpfskHl(gQSuJlG}D#_>u zTX3lD(|lo>(7lSTN3uA=?b;JIzBL;r=n|X+W%eO=dlPn>~#^@EvOJ|0FqG zU2XNtm!#T~-~^O<;K1VI;=cVj@43ggfbVznwqCq=(OqnTIrenAHD16G_OJ^v;=qS5}U9?%X*?{>gF>%95MAj~B;AzCU{J2rWAB>a_XcjEazk z(baO z@9nNlFm&Wltj%GnZ6=5mF93c9JVwF?sVf!J0;#(Ft)I``;);dU*3h^GlS;a z8jBDdV0YvOdr_K*Z1q4#%0wd~Nkm=svdG4^jOZNLEV2iFt47&RS|sl43Ub!3w5HHwb@kvgw`~qccqoHu~lO>J>`sdx`5OE)1-3TOWeJ%?Lz(-qKgqg$D&+8^RfC)z8(=e$bY~I@r~i z3FqDWkba@zl?X-FH^rf?6z(vy{Mc{B1A9GnS#H51HBiy%))L!4qEA?3AiU{(>y;^3p?4wyC7zq5;F5P7}k za!71UpGm;-mYi;3=ZuTorfdl88v***1{t9l<);JDV@Ta`wIWp!Zp7Dl!{>x`;H__^Ni1 zxH2k(y*0R4+nZqMC%S4{5kXyp<=GP9oLB)3p_4)*5`mt4t7-+UjNQO;w4l0 zs)d~V^U$;n+tt(2ST%D)l&YPnuY&fzog$|w=f;e{mRVDuhM}6O;RDbKDYw~(U*Ur` zXE_fFplM0bzGm>#bNRmHqm0Bh+q^}ms@Slx>eOmuSy|j5zxE*V2t>k;$Ugh7S9Z;P zwB~v-8dH&czKtD)mYp(rqSKjI81Vd>0wg3>ULw*#xsD|CKw|kTMITH*KFOEZ;ORbb zSl}p81*P_+E-{~^)s``2x}7&@O6eEQt7z8l0#q1`w6(9?C;V)#t#uG{*R{5f8#xt!g1FK$F9{P6W-6be(uQw#;ymTNRjL z|M|8)ywqS?)TR$22cm-$u;qW&tA6@pgVBu!g;%n0HSWv~yp-*s5pCYMM@ul@C2kez z-OLM!{hVlalJX^j-zl*S)?ZG7)`jruJ;C)3uOpe*Oh7|O0KT~~`Q`{nlJA=v{<4Tng${95_gVj(x8hf1Yho?cgNyuaMk-QAsGfq^AnXc(%+VpW8`ZmfP~Uu^JMcw%|$)-h|%pVm%N z_UhtrrK6LRlXHRklLLxsYA(Kheu;F+#?YTQqhd>(=}Om2(tG{(nht8op*v_5$3VEc zW~8O1vG&+FUcGlR{-w)buDZ3s2wFE48Em=gCWB&a&I^>rcq=uQzMZP;Wcz?EWC z>;29eAK-H?YWBsr4#aD7il-LtU|omWT4a!Ap4GV;(#B18I_a(J!!u`rl&{B5{GIYa ze55e6#qCqvg#uuh5UBgQ#(9naqLIJz_{hkyIA2~)z=puI=+MXO{FcJdeos4tXiF2K zpo6^Cfcv7-o2@RmMIn92doWx2`D$W3HND)VJ@)&U!{G`en8+~r_9!YoqrWG=8w?-q zq;G5;_@1(PaY>o?GvEeX;3>!ul6^Kf2ySUC3eCB%@+dH;QGN;q^4}2jC683SH7L(8 zvJ~>(w;9qea8-7ym_dHsp6YMA<6FCJyS3;k$QGQQ_rUGi>>sQ8jLt;}c(?+OG$_bj~pylFZ z1IV5h!g``-5u-I8&QV1E0}@j{*ESIH`o0$R-ruj9kIkRL31s>Z!)?||7}=^mch^nw z3NO~nFkfsbdG%_4OT7`HPL62S>38EX*kRAvHkyPZWQ}AXfi)dzFS(}R5VGMav+#9Q zEg#j52NtHIFy0g$GfzxRXj~Qq;!Es%8VDh(U*e^@3-t-mLVR}i-q8=b@-pu!R##6KcU{CaV6@4c;qLDdEkZdRlH zWwm?o+l12MHdUk*)OhU;%=C$sss3j^VTq6=q4SEPSW&MR;pWgn(S~%z&PG=ZB5sLt zC6M%jr`&sMeR=Zm12sR&K68>?hS}uQ$iWo@tZK&v_mKQ=WnUA>1t(T+J>qT7i}AA5 z6y3S07C$TGM|rn#n6hnVMyT^B+m=7}Y0U;^tglhuMEcJOUlYS|z!QJTo#k%WSH9y+EAUOj|(Pmj)7Tr){QC|i%_JbP2D7P3lF00rX#{Ec{{DW6z^dM; z9G0cG57?0x@fWCc^Q_>A@!+z4&ahe zar0p?_+A{_C0+p))F?_B8JE%jF8|aETV!uE4>$ask8{J3oQ1BOih~GvTDZAW&6Zt_ z=|}iR^IgwS)ulUgfQiQzhA!b@V$B>NYPJ?T8@^{qp}m^B^;7e_E3exUjVc^h zz+F|lV;vRw{?3vWjU(WWOFA|#OhLBl)nmD}!8M!}o3+)L=ca7LxJ9nJW+8F4Ep-&R zRT}W|eg}=`OnGa&ZYXB$@Ww3Xhgw`}Yo9c!i$3Q=`!nihQfEuB{tO?rVM7~yNqehn ztJo7!l@&-~c$E*&&e_d|_!NwRU+1@!#(-ujGWh`Rp_zBCJ&|2L<|GQNzqdol3|q$9 zSN8uH&t!e82$)##H)gr-meO2pM*G4cT=dw|rrF3(Gcp^g5C`)QIWK>^c@&8!U|x8LH_k-F=V z-23H`@Bw9BHFhxkomc?h!Eo0aVL|@i6ySa3FF(TA{igt5yRA#`lNCC0CKjkM<%mzv z-}bJ)@i?0i7W_C5$NJ!^tEwETvD_$0uy&}w|1jV=Bq;-iPWhCRC+Nrnv^3Z6e(WO1 zX-Ps6THtm=b+w}ctlk;G0q)32V5env?o+`f#>BQ5sU1}w?BQo2eyq4 zSS)`(@#f>lkKbw&&UYgD>DNgg1Xz@Lvq#X-qyPE5}KjkJr{8$pdClbx!lWzs(4pKNv- zSx{H68C&oNSdg$F6pomxKsLa#6U_h4eLq8l`bbMIqTzCh3l9HeBAtVtB5fo>Kc;rF z982pVGHVkCGfP4A0Dr|>x z$e658kNwpP6(mVxD*-mcexaIbYE}!`{wf-&qkdv`klPhN$Vsa)?sJDr0H)>&%MW#s z%GhlQIEa@T94i@OZvdEYZlu#fEQ!2Y1eNF~;Xh&?y*sTO5bdAF;xn-@G$KOQPFoDY za+D)L{YHm|jtpY`Cif5Jp9aidqZlCinGatTCjbv0X2P3M0eAklHkpMQ`k-5xBC@N;Aa?QSf@RW_6hT^a58(t~|ra9*Dp6cPW5CDj5he!)kn6LW@^Z+z>CSDuQkk6q-zSO2;MLYI>0`9+r)L}k z1J#Z&9&$S{-o1Ibs{AzG%+qMI&?a5M=2%Go{r*kmLo{PoomHIgNT@~8=<%yiC9=p?001abOS7`tT%0 zB*9t<71O!;wKvnLH~Z-(Z7DNPFZlp{LA={+$R+fsoR84?8q3J~pyQvaTn4+hwzde7 zgepbx8!abVYTXrV>$X3(ZCjEB%B4IA>DCUA?;GSy%&A8E@r6MQ_iEvlEgR8A$f%1? z_tz1ba+fo-BE~C@*0bL7XVbOIQ_i`%xk;x9_b@TB$M3!iupd6KJ}cLiF1zs|9{`(3 zXCUGH@!=55Rp2R7fu=#kAF6~Kvf=SX_FNL-VD9RQkGR@e)tIR5{TgdJ)iHbT(Vq&8xQjr5%^7WL#I{AJ)5FaGpnR*YG^~P>x1M2!YdFYN zls9m76-~$XmZAs!bp|_KD{+xGL+Nt`%>u$c_johG)-|WC(;6#6cjgTC5@(G|bl7j# zg=_+i1zQcJl~ZlFH$KCP?HVN1M!NB`v;r3|nQBVakTqv3*p#0?Fd1-6Ev`O#Pt_qv zN3#6fJaUcz)>a%v2^`_|9QG2VJr$haB%qiRZz)%*HS8y9Jf;b8d2$k8TEj|X;(6`^ zR#V;t zXi)rcD}O{xnWmk;SU##^Ewjh2pp={CrjQpJg5tc#pC9f~8)n<<&aCffK~Q!BLPIPG0|L;WbD z`l{So1`9seHk^qk-GXv0o)*MRnO^7TV^5E#zv36sEh)Zt zvO;%detmhG^}R%!RCaK~2(qK*b~c6BB_K{|Il3GeO|!;d)W@o5yJ2)FPug1^Cm zMY~`ZItDUxJ2P@?+P|0#Z;SaJHj6dI>2=P|ulN94(BA*vf+p){MliTTPjC9f{gUr+ z4jyVc7%l=brM)>njIuGMobo{E5EkBgyJv4)e2r-Ixt@LaRZMzMfx}S6SC|Ii)d`mL z(U0VhirQG_Bv&;%+6biQdhu9K3f>w{ssFo-di{t%c=;2XYwOm9$=nzIJtDR<+{8q-w*M`a<;5o*$6Z}oaX`81194$5y5a{ z&FMWW)VewKr+t?Dp z_R?WmF)F@2*DcyXMaf80smk#pDLJGcRpn@QBO&QRa1rW=y)z3e#o`EVDOO z^6v)Ke&mLtj>Lki8zFv;TMFeCj2>Ri(2`VNLbBI4}bYXB{jjl*Y`F@WLI03AP&|Kw5HiiXt?CN z#>Cacy9fa~wx@)=QTwJQZa;`F+eiA#Yf}LddmS%(Ntl){OT(4KxaKrpz+f|Zpy*6E zTUq_JONY;Slo#Fe+YI<^7M)%OB$p4x!t~n&`pfPS0%Y7P z;n-Q7-{1Ty@l6Y#7QrZplj$GdGqHI}hM{{QcZc@ Date: Thu, 28 Aug 2025 17:03:17 +0200 Subject: [PATCH 2/5] add suggestions from review MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-authored-by: Jakub Beránek --- content/rust-lld-on-stable-1.90.0/index.md | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/content/rust-lld-on-stable-1.90.0/index.md b/content/rust-lld-on-stable-1.90.0/index.md index 6c21a79da..74060a9aa 100644 --- a/content/rust-lld-on-stable-1.90.0/index.md +++ b/content/rust-lld-on-stable-1.90.0/index.md @@ -1,6 +1,6 @@ +++ path = "2025/08/29/rust-lld-on-1.90.0-stable" -title = "Faster linking times with 1.90.0 stable on Linux using `rust-lld`" +title = "Faster linking times with 1.90.0 stable on Linux using the LLD linker" authors = ["Rémy Rakic"] [extra] @@ -8,7 +8,7 @@ team = "the compiler performance working group" team_url = "https://www.rust-lang.org/governance/teams/compiler#team-wg-compiler-performance" +++ -TL;DR: rustc will use `rust-lld` by default on `x86_64-unknown-linux-gnu` on stable, starting in 1.90.0, to significantly reduce linking times. Test it out on beta now, and please report issues if you encounter any. +TL;DR: rustc will start using the LLD linker by default on the `x86_64-unknown-linux-gnu` target starting with the Rust 1.90.0 stable release, which should significantly reduce linking times. Test it out on beta now, and please report any encountered issues. #### Some context @@ -38,8 +38,6 @@ Most binaries should see some improvements here, but it's especially significant Here's [a link](https://perf.rust-lang.org/compare.html?start=b3e117044c7f707293edc040edb93e7ec5f7040a&end=baed03c51a68376c1789cc373581eea0daf89967&stat=instructions%3Au&tab=compile) to the complete results from our benchmarks. -This testing period did go well indeed, and we can stabilize using this faster linker by default for `x86_64-unknown-linux-gnu` users. - #### Possible drawbacks From our prior testing, we don't really expect issues to happen in practice. It is a drop-in replacement for the vast majority of cases, but `lld` is not _bug-for-bug_ compatible with GNU ld. @@ -52,7 +50,7 @@ Some of the big gains in performance come from parallelism, which could be undes #### Summary, and call for testing -rustc will use `rust-lld` on `x86_64-unknown-linux-gnu`, starting with the 1.90.0 stable release, for much improved linking times. This version 1.90.0 will be released next month, on the 18th of September 2025. +rustc will use `rust-lld` on `x86_64-unknown-linux-gnu`, starting with the 1.90.0 stable release, for much improved linking times. Rust 1.90.0 will be released next month, on the 18th of September 2025. This linker change is already available on the current beta (`1.90.0-beta.6`). To help everyone prepare for this landing on stable, please test your projects on beta and let us know if you encounter problems, by [opening an issue](https://github.com/rust-lang/rust/issues/new/choose) on GitHub. From 244fcaefe0b1d6232a4075a526f8fbd11974bd6f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9my=20Rakic?= Date: Mon, 1 Sep 2025 20:31:12 +0200 Subject: [PATCH 3/5] clarify timeline Co-authored-by: Mark Rousskov --- content/rust-lld-on-stable-1.90.0/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/rust-lld-on-stable-1.90.0/index.md b/content/rust-lld-on-stable-1.90.0/index.md index 74060a9aa..6521edf7a 100644 --- a/content/rust-lld-on-stable-1.90.0/index.md +++ b/content/rust-lld-on-stable-1.90.0/index.md @@ -8,7 +8,7 @@ team = "the compiler performance working group" team_url = "https://www.rust-lang.org/governance/teams/compiler#team-wg-compiler-performance" +++ -TL;DR: rustc will start using the LLD linker by default on the `x86_64-unknown-linux-gnu` target starting with the Rust 1.90.0 stable release, which should significantly reduce linking times. Test it out on beta now, and please report any encountered issues. +TL;DR: rustc will start using the LLD linker by default on the `x86_64-unknown-linux-gnu` target starting with the next stable release (1.90.0, scheduled for 2025-09-18), which should significantly reduce linking times. Test it out on beta now, and please report any encountered issues. #### Some context From 55f2151115a7cb569abd4d8f81ac5ca2e256294b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9my=20Rakic?= Date: Mon, 1 Sep 2025 18:32:55 +0000 Subject: [PATCH 4/5] add call to action to paragraph about issues --- content/rust-lld-on-stable-1.90.0/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/rust-lld-on-stable-1.90.0/index.md b/content/rust-lld-on-stable-1.90.0/index.md index 6521edf7a..e8d6c7035 100644 --- a/content/rust-lld-on-stable-1.90.0/index.md +++ b/content/rust-lld-on-stable-1.90.0/index.md @@ -44,7 +44,7 @@ From our prior testing, we don't really expect issues to happen in practice. It In any case, using `rust-lld` can be disabled if any problem occurs: use the `-C linker-features=-lld` flag to revert to using the system's default linker. -Some crates somehow relying on these differences could need additional link args, though we also expect this to be quite rare. +Some crates somehow relying on these differences could need additional link args, though we also expect this to be quite rare. Let us know if you encounter problems, by [opening an issue](https://github.com/rust-lang/rust/issues/new/choose) on GitHub. Some of the big gains in performance come from parallelism, which could be undesirable in resource-constrained environments, or for heavy projects that are already reaching hardware limits. From 93d7f2875723ab13c83797c785aef6e08e0aeed0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?R=C3=A9my=20Rakic?= Date: Mon, 1 Sep 2025 18:34:31 +0000 Subject: [PATCH 5/5] update publication date --- content/rust-lld-on-stable-1.90.0/index.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/content/rust-lld-on-stable-1.90.0/index.md b/content/rust-lld-on-stable-1.90.0/index.md index e8d6c7035..f410b4b9c 100644 --- a/content/rust-lld-on-stable-1.90.0/index.md +++ b/content/rust-lld-on-stable-1.90.0/index.md @@ -1,5 +1,5 @@ +++ -path = "2025/08/29/rust-lld-on-1.90.0-stable" +path = "2025/09/01/rust-lld-on-1.90.0-stable" title = "Faster linking times with 1.90.0 stable on Linux using the LLD linker" authors = ["Rémy Rakic"]