For the past few years, I was sponsored by Futurewei to work on upstream Rust. It was great to have the freedom to work on anything I wanted in Rust, be it new features, performance optimizations, bot/tooling/CI improvements or even non-technical work, such as mentoring, governance, surveys or preparing Rust talks. Alas, nothing lasts forever, and my open source funding ended this February.

While I did not have much time for Rust during the following months anyway, I have applied for the Sovereign Tech Fellowship grant in the meantime, and I was very lucky to actually get into this year’s cohort of funded open source maintainers! And what is even better is that another Rust maintainer, Denis Cornehl, who maintains docs.rs, got into the same cohort too.

My funding started in June, and should last for a year, which is awesome, because now I can again fully focus on working on Rust. I thought that I would post periodic (bi-monthly) updates about the upstream Rust work that I do, similar to the one I shared earlier this year. Every two months, I’ll try to pick a few highlights, summarize the rest of interesting stuff that I worked on, and also provide contribution statistics and a raw list of opened PRs.

This post details my open source Rust work done in June and July 2026.

Compile time improvements

After a relatively long time, I spent some effort on optimizing Rust compile times, which was fun, as this is one of my favourite activities. I approached it from a couple of angles.

Optimizing Cargo

During my bors talk at RustWeek 2026, I noted that the compile times of tests in bors are pretty terrible. Recently, I finally spent some time analyzing the causes of it. I thought that I would be working on removing bottlenecks from the compiler (and I still plan to do that!), but by profiling, I actually found some bottlenecks in Cargo, so I took a detour and spent a few days to try to make it faster.

I sent a couple of pull requests to Cargo that removed unnecessary cloning (#17167, #17176, #17178), switched to a better data structure (#17180) or pre-allocated memory (#17177). With the exception of #17167, the perf. effect of those PRs was very small.

What helped much more was replacing the hashing algorithm used by hashmaps and sets in Cargo. Most of its associative data structures were using the default hasher from the standard library, which is quite slow. I switched all such data structures to use FxHash, the hashing algorithm used by the Rust compiler, in #17169. This resulted in ~8-10% wall-time improvement for no-op Cargo invocations on Zed, which was quite cool.

Finally, as discussed later in this post, I also configured Rust’s CI to optimize Cargo with PGO in #159149.

The changes I made were mostly only micro-optimizations, rather than algorithmic changes, which typically means that you won’t get that much speedup. That being said, the “final” results are still quite nice. I took nightly Cargo from 1st of July, which is a day before I started working on the optimizations, and compared it with 5a8cd237d4fad99d862aed51fab8cb5345c970131, which is the merge commit of the PR that added PGO to Cargo. I am not aware of other performance work happening in Cargo in the meantime and the Cargo submodule was since synced to rust-lang/rust, so this benchmark should mostly correspond to the improvements that I made.

I tested a no-op (also called “fresh”, meaning that all sources were up-to-date and the Rust compiler was not invoked) cargo test --no-run execution on bors:

/pr/pe/ru/bors [benchmark]$ hyperfine "cargo +nightly-2026-07-01 test --no-run" "cargo +5a8cd237d4fad99d862aed51fab8cb5345c97013 test --no-run" --runs 50
Benchmark 1: cargo +nightly-2026-07-01 test --no-run
Time (mean ± σ):     227.6 ms ±   3.8 ms    [User: 141.2 ms, System: 90.3 ms]
Range (min … max):   222.1 ms … 239.2 ms    50 runs

Benchmark 2: cargo +5a8cd237d4fad99d862aed51fab8cb5345c97013 test --no-run
Time (mean ± σ):     184.3 ms ±   6.6 ms    [User: 104.2 ms, System: 84.3 ms]
Range (min … max):   178.4 ms … 216.9 ms    50 runs

Summary
cargo +5a8cd237d4fad99d862aed51fab8cb5345c97013 test --no-run ran
1.24 ± 0.05 times faster than cargo +nightly-2026-07-01 test --no-run

I consistently saw a 20% wall-time improvement on bors. On Zed, I measured a similar 18% wall-time win (fresh cargo check time went from 1100ms to 930ms).

Since I was using the “Performance Optimizer Observation Platform” (poop) a lot while benchmarking Cargo during my optimization experiments, here are its results on bors:

poop "cargo +nightly-2026-07-01 test --no-run" "cargo +5a8cd237d4fad99d862aed51fab8cb5345c97013 test --no-run"

Benchmark 1 (22 runs): cargo +nightly-2026-07-01 test --no-run
measurement          mean ± σ            min … max           outliers         delta
wall_time           228ms ± 12.8ms     219ms …  271ms          3 (14%)        0%
peak_rss            106MB ±  402KB     106MB …  107MB          0 ( 0%)        0%
cpu_cycles          559M  ± 22.0M      540M  …  636M           2 ( 9%)        0%
instructions       1.01G  ± 6.23M     1.01G  … 1.04G           1 ( 5%)        0%
cache_references   35.3M  ±  461K     34.6M  … 37.1M           2 ( 9%)        0%
cache_misses       9.29M  ±  112K     9.08M  … 9.64M           2 ( 9%)        0%
branch_misses      4.37M  ± 55.4K     4.32M  … 4.58M           1 ( 5%)        0%

Benchmark 2 (28 runs): cargo +5a8cd237d4fad99d862aed51fab8cb5345c97013 test --no-run
measurement          mean ± σ            min … max           outliers         delta
wall_time           183ms ± 6.30ms     179ms …  214ms          1 ( 4%)        ⚡- 19.7% ±  2.5%
peak_rss           90.6MB ±  167KB    90.2MB … 90.9MB          1 ( 4%)        ⚡- 14.7% ±  0.2%
cpu_cycles          415M  ± 8.49M      408M  …  446M           2 ( 7%)        ⚡- 25.7% ±  1.6%
instructions        736M  ± 5.41M      735M  …  764M           1 ( 4%)        ⚡- 27.4% ±  0.3%
cache_references   26.1M  ±  489K     25.5M  … 28.2M           1 ( 4%)        ⚡- 26.1% ±  0.8%
cache_misses       5.98M  ± 82.0K     5.84M  … 6.29M           1 ( 4%)        ⚡- 35.6% ±  0.6%
branch_misses      3.47M  ± 29.5K     3.43M  … 3.58M           1 ( 4%)        ⚡- 20.7% ±  0.6%

Around a quarter less executed instructions. Not bad for a few days of work! That being said, those were the low-hanging fruits, and I expect that further improvements using a similar approach would be difficult. Larger wins could be gained by parallelization or algorithmic changes, e.g. related to caching. And of course, those wins were only on no-op Cargo builds. In situations where the Rust compiler has to be invoked, it will typically dwarf any overhead coming from the execution of Cargo itself. But not always, and every win helps, so I’m nevertheless happy with the result.

Speaking of parallelization, it would help if Cargo was loading TOML manifests in parallel, as this takes a considerable chunk of its no-op execution time. Possible approaches to achieve this are described in this Cargo issue. I spent a few days trying to perform this parallelization, but I don’t have much to show for it. I ran into several problems related to how the Cargo codebase is currently structured (some things are not 'static or Send/Sync, which makes parallelization annoying, and Cargo doesn’t use tokio, so running async functions concurrently or in parallel is tricky).

It would probably require larger refactorings to Cargo to make this parallelization feasible. In the end, I managed to implement a very hacky version of a parallel worker queue, which provided a 15% wall-time win on Zed with 8 threads (on top of the previous optimizations, except for PGO). But it actually involves unsafe to deal around one variable not being 'static, and it is nowhere near being production ready. Maybe I will come back to this sometime later. If this sounds interesting to you, feel free to pick up this work (though I would suggest talking to the Cargo team on Zulip first).

I would like to thank the Cargo team, especially Ed Page and Weihang Lo, for their quick reviews and fruitful discussions.

Macro bloat of #[sqlx::test]

This is also related to the build times of bors. I already blogged about this in detail recently, so I will keep this section short. Bors uses hundreds of #[sqlx::test] macro attributes, and it turns out that each such attribute was embedding all database migrations into the source code. There is a way to avoid it (described in the linked blog post), which I applied to bors. And then I tried to document this and make it easier to fix directly in sqlx. This work is still ongoing.

Using Profile-Guided Optimizations (PGO) for more Rust tools

A few years ago, I spent a lot of time improving the way we use PGO and BOLT to optimize the Rust compiler and LLVM. Recently, I thought that it might be worth it to optimize also other parts of the toolchain (such as rustdoc, Cargo or Clippy) with PGO too.

First, I modified bootstrap2 in #158912 to allow specifying PGO profiles in a granular way, for individual tools and components. Then I used this new machinery to PGO optimize:

  • rustdoc (#159091), which resulted in an average ~4% wall-time improvement on doc builds.
  • Cargo (#159149), which improved the performance of a no-op cargo run on bors by ~5%3.
  • Clippy (#159642), which resulted in an average ~5% wall-time improvement on Clippy builds.
    • This one is a bit on hold at the moment, because we need to make our CI faster first, so that we can afford the additional PGO training time. Making CI faster is one of efforts that I was also working on this month, more on that below.

While I was working on this, the newly introduced additional PGO training made our Linux CI job that produces these optimized artifacts (dist-x86_64-linux) too slow, so I took another look at optimizing it. By adding some parallelization in #159524, I made the job ~20 minutes faster, which more or less balanced out the additional time required to perform more PGO.

Perhaps more importantly, @Mark-Simulacrum started looking into throwing more hardware at this slow job, so in the near future, it might actually get much faster than it is today! That would be really cool, as it would allow us to get performance results on PRs very quickly.

Investigating performance of the new build dir layout in Cargo

The Cargo team is planning to stabilize a new layout of the build directory, which would unlock a lot of cool improvements. In fact, the Cargo team already stabilized this recently, but it since had to be reverted; I’ll describe why below.

The new build dir layout has one property that is a bit annoying. Before, Cargo used to put all artifacts of dependencies (mainly .rlib and .rmeta files) into a single directory, and then passed a single flag to rustc (-L <dir>), so that the compiler could look them up in this directory. With the new build dir layout, Cargo instead creates a separate directory per dependency, and then passes each directory to rustc with a separate -L argument. This might not sound so bad, until you get to projects like Zed, which have over two thousands dependencies.

There are two issues with this. The first one is operating system limits on the length of command-line arguments. Passing thousand of CLI paths, where each path can have 100 bytes or more, quickly adds up. Of course, this was a problem long before the new build dir layout, especially on Windows. Cargo can already work around this using argfiles; if an invocation of rustc fails because of the command-line length limit, Cargo will instead write the arguments into an (arg)file, and then pass that file to rustc using the @argfile syntax. This sort of works, although it is not optimal for performance, because Cargo has to start rustc twice, and also write a file to disk for each process invocation. Another issue is that some tools do not handle argfiles when dealing with Rust compilation, which means that they might stop working with the new build dir layout. This was the case for sccache, because it did not support argfiles. Luckily, that is being fixed now.

So what is the problem, when we have the argfile workaround? Well, shortly after stabilization, I tried the new build dir layout on Zed, and it failed. It turns out that not just the command-line length is a problem, but also environment variable length. Recently, Cargo started passing many more paths than before to the LD_LIBRARY_PATH variable4. On Zed, this resulted in this environment variable having over 150 KiB (!) of data. Unsurprisingly, Linux didn’t like that.

The second issue is the performance of dependency lookups in the Rust compiler. Historically, the compiler was optimized precisely for the case of being passed a single -L argument, which was supposed to contain all the necessary dependencies. The compiler thus does a lot of preprocessing to optimize lookups of dependencies in a single large dependency. With the new build dir layout, this is completely opposite, because the compiler receives hundreds or even thousands of -L arguments, but each such directory typically contains only a single file.

This means that the previous optimizations can actually be harmful to performance, and also result in quadratic behavior. On our artificial large-workspace benchmark, which contains hundreds of crates that depend on one another, the old dir layout resulted in ~4 thousand dependency queries in the compiler, while the new dir layout resulted in ~2 million queries. In absolute terms, it was only a ~20ms difference, but it is still not ideal to do so much unneeded work.

This was interesting to me, because over the past year I did some work on optimizing search path lookups (#145408, #153131). So I rewrote the dependency lookup in a way that would be independent on the number of -L paths passed to the compiler, and thus be fast with both the old and the new build dir layout. This work was done in #158823. Enabling the new build dir layout made the large-workspace benchmark ~twice slower, and merging this PR made it ~2x faster, so it more or less balanced itself out.

@ranger-ross, who implemented the new build dir layout and is pushing its stabilization (and who recently became a member of the Cargo team :tada:) already implemented several optimizations to avoid passing unnecessary paths to rustc (#17168, #17191, #17236). I also tried to help slightly with this in #17174, which avoids passing unnecessary lint flags when compiling dependencies (for which most lints do not report warnings anyway).

While that helps, the fact remains that Cargo still passes a lot of paths to rustc with the new build dir layout. I suppose that we will have to see whether this will be an issue in practice or not. Having the dependencies exist in separate directories is core to the new build dir layout, but maybe we could do some workarounds to merge both approaches. For example, Cargo could create a single temporary directory with symlinks pointing to the individual dependency files. But it is hard to tell how fast that would be.

Anyway, after these optimizations landed, the new build dir layout was re-enabled, and it is now used by default in nightly Cargo. If you have use-cases that are broken by the new build dir layout, please report them here. I hope that the new build dir layout will work fine on nightly :crossed_fingers:.

Other things I worked on

  • An innocuous question on Zulip led me down on a hunt during which I found that passing certain C/C++ build flags in the bootstrap build system has been broken for years. I fixed that in #158169, and re-enabled debuginfo compression for the little debuginfo that we ship in our distributed Rust artifacts.
    • Funnily enough, this caused backtraces in builds of the compiler with debuginfo to be much slower to print. It turns out that it can be very slow to decompress hundreds of MiBs with zlib, especially with the pure-Rust miniz_oxide implementation used by the standard library. I tried to replace the implementation with the much faster zlib-rs crate, but it turns out that it didn’t help at all here :( I even tried switching to zstd, but with the pure-Rust ruzstd crate, it was even slower than zlib. Some issues are just annoying like that.
  • I did some other random work on compiler performance in #158842 and #158931.
  • I started looking into debuginfo generation performance (#158868). There is a lot of wasted work here done by the Rust compiler, I hope we will be able to improve it.
  • I started working on integrating cargo-semver-checks into Rust’s CI, so that we can check whether the standard library hasn’t introduced a semver breaking change by accident (#159188, #159671, #160253).
  • I tried to move forward with stabilizing -Zembed-metadata=no in Cargo in #17149, #17266 and #17267. You can read more about this compiler/Cargo flag in my previous blog post.
    • Since the new build dir layout is now enabled on nightly too, we decided to postpone this to the middle of August, to avoid enabling two disruptive directory layout changes at once.
  • I implemented tooling for helping uphold our alumni policy, and started using it to move inactive Rust Project members to alumni status, to keep our member database up-to-date.
  • I implemented various improvements to our bots, such as adding historical charts for toolchain size to rustc-perf or teaching bors how to communicate with us on Zulip.
  • @Mark-Simulacrum did some experiments with using EC2 runners for some of our CI jobs, instead of using CodeBuild. It looks like it could speed up the jobs we most care about by 2x while making them cheaper, by using Zen 5 machines for them. It will also require some tooling implemented somewhere in our infra though. We decided to test this in bors; it is now ready for experimentation, after some bors implementation work (#786, #791, #792, #794, #799, #800, #802).
  • As usually, I did lots of tiny fixes and improvements to CI, infrastructure or tooling of various rust-lang repositories.
  • As usually, I participated in the Compiler performance triage. I helped onboard @JonathanBrouwer to the triage rotation, to bolster our ranks.
  • As a part of the Rust funding team, I communicated with a lot of Rust maintainers, and also potential funders, to find opportunities for funding Rust maintainers. We will have very exciting updates on this front soon (in August). I also started working on some improvements to the Rust website, to highlight funded contributors.
  • I did a bunch of reviews for the two Google Summer of Code projects that I mentor, and overall oversaw the progress of our Rust GSoC 2026 cohort. All contributors have passed their midterm evaluations, and they are doing a great job! You can follow their progress on our Zulip.
  • I ran a survey about the performance of the Rust Leadership Council.
  • I wrote a couple of blog posts on the official Rust blog. Two maintainer spotlights (with @tiif and @rami3l), the launch of the Rust Foundation Maintainers Fund and the Funding team and an appreciation post for the Josh tool, which helps us manage subtrees in the rust-lang/rust repository.
  • I had a keynote about the Rust Project infrastructure and tooling at the RustMeet conference in Poland.5
  • I participated in many discussions about AI policies. That is something that I didn’t enjoy very much.

Contribution statistics and pull requests

Below you can find some statistics and a list of PRs that I opened during June and July 2026.

  • Opened 162 pull requests in Rust-related repositories.
  • Reviewed 108 pull requests in Rust-related repositories.
  • Sent 651 comments in the rust-lang GitHub organization.
  • Sent 1725 public and 2789 private messages on the Rust Zulip.
List of opened PRs

rust-lang/rust (39 PRs)

  • #157798: Prevent approving PRs that wait for Crater or formal decisions (merged)
  • #158169: Fix debuginfo compression in bootstrap (merged)
  • #158562: Improve tracing of steps in bootstrap (merged)
  • #158609: Update sccache to 0.16.0 (open)
  • #158823: Flatten all -L search paths into a single list of files (merged)
  • #158842: Use SmallVec for return places in MIR (merged)
  • #158868: Cache some data structures for debuginfo generation (open)
  • #158912: Introduce new bootstrap config section for PGO configuration (merged)
  • #158925: [perf] Link LLVM statically on Linux x64 (closed)
  • #158931: Inline some Symbol functions (merged)
  • #158932: Do not build the compiler when invoking x perf compare (merged)
  • #159040: Print step stack trace when bootstrap panics (merged)
  • #159056: Print a loud error if the configured LLDB cannot be found (merged)
  • #159091: Use PGO for rustdoc (merged)
  • #159126: Fix PR number in bootstrap’s change tracker (merged)
  • #159149: Use PGO for Cargo (merged)
  • #159177: Explicitly materialize debuginfo tests for all debuggers (merged)
  • #159178: Print duration of BOLT instrumentation and optimization steps (merged)
  • #159188: Always generate private and hidden items in JSON docs of the stdlib (merged)
  • #159193: Port compiletest’s CLI to clap (merged)
  • #159251: Bump rustc-perf submodule (merged)
  • #159270: Only force backtraces when a panic occurs in bootstrap (merged)
  • #159378: [perf] Use a flat token stream representation when lexing (open)
  • #159451: Remove config cloning in compiletest (merged)
  • #159455: Implement opt-in debugger discovery for GDB and LLDB in bootstrap (merged)
  • #159500: Move compiletest CLI parsing to cli.rs (merged)
  • #159524: Gather PGO profiles in parallel (merged)
  • #159642: Optimize Clippy with PGO (open)
  • #159671: Add semver check test command for checking API compatibility of stdlib (merged)
  • #159710: Add rustdoc/cargo PGO profiles to reproducible artifacts (merged)
  • #159765: Avoid spurious rebuilds of JSON docs in bootstrap (merged)
  • #159832: Use RUNNER_TEMP in distcheck when running on CI (open)
  • #159992: Do not run tests in dist jobs (merged)
  • #159994: Show jobs where a given test was executed in test-dashboard (merged)
  • #159999: Fix invalidation of stdlib in bootstrap when using non-LLVM codegen backends (merged)
  • #160152: Create on-demand CI job for testing EC2 instances (merged)
  • #160200: Run mir-opt panic=abort tests on CI (open)
  • #160253: Add CI job for checking stdlib semver compatibility (open)
  • #160257: EC2 runner test (open)

rust-lang/team (31 PRs)

  • #2515: Add website entry for the Program team (merged)
  • #2537: Add Jonathan Brouwer to wg-compiler-performance (merged)
  • #2555: Configure trusted publishing for rustc-hash (merged)
  • #2556: Fix dry run (merged)
  • #2565: Change default branch of rustc-perf to main (merged)
  • #2583: Add command for finding inactive users and moving users to alumni (merged)
  • #2588: Move lukas-code to alumni (merged)
  • #2589: Allow setting labels with triagebot (merged)
  • #2590: Enable merge queue for the blog repository (merged)
  • #2591: Allow deploying the blog from the merge queue (merged)
  • #2592: Create maintainers-in-residence marker team (merged)
  • #2594: Configure trusted publishing for futures-rs (open)
  • #2595: Configure trusted publishing for jobserver-rs (merged)
  • #2596: Move edmilsonefs to alumni (merged)
  • #2597: Move joelpalmer to alumni (open)
  • #2598: Move Muirrum to alumni (open)
  • #2599: Move cdmistman to alumni (merged)
  • #2600: Move anden3 to alumni (merged)
  • #2601: Move vertexclique to alumni (merged)
  • #2602: Move JakobDegen to alumni (merged)
  • #2603: Move tranquillity-codes to alumni (open)
  • #2604: Move celaus to alumni (closed)
  • #2605: Move alibektas to alumni (merged)
  • #2606: Move KittyBorgX to alumni (merged)
  • #2607: Move manyinsects to alumni (merged)
  • #2608: Move shard77 to alumni (open)
  • #2609: Move johncsimon to alumni (open)
  • #2610: Move rbtcollins to alumni (merged)
  • #2615: Archive community-events and community-localization teams (merged)
  • #2624: Add Abi Broom to funding-advisors (merged)
  • #2636: Configure merge queue for rustfmt (merged)

rust-lang/rustc-perf (20 PRs)

  • #2483: Add 2026-06-01 triage (merged)
  • #2488: Downgrade openssl-sys (merged)
  • #2490: Update perf. triage rotation (merged)
  • #2495: Change default branch to main (merged)
  • #2496: Remove OpenSSL from Dockerfile (merged)
  • #2497: Add rustc-perf PR note when marking PRs as rollup=never (merged)
  • #2500: Fix rustdoc lookup on Windows (merged)
  • #2501: Add artifact size history chart to toolchain page (merged)
  • #2502: Properly set rustc-fake extension on Windows (merged)
  • #2503: Run benchmark smoke test for all profiles on Windows on CI (merged)
  • #2504: Fix selecting color for the bootstrap chart on the toolchain page (merged)
  • #2505: Add 30 day history link to artifact size tab on the compare page (merged)
  • #2506: Add 2026-07-21 triage (merged)
  • #2507: Add early check for missing rustdoc/clippy in a toolchain (merged)
  • #2508: Download Clippy when a Clippy profile is requested (merged)
  • #2512: Rename frontend_threads to Threads (merged)
  • #2513: Run DocJson benchmarks on CI (merged)
  • #2514: Fix compilation of regex-automata-0.4.8 with doc-json (merged)
  • #2515: Run DocJson benchmarks on production by default (merged)
  • #2516: Add doc-json filter to the compare page (merged)

rust-lang/bors (19 PRs)

  • #762: Show try build parent on a separate line (merged)
  • #766: Add “Co-authored-by” commit trailer for squashed commits (closed)
  • #767: Add “Co-authored-by” commit trailer for squashed commits (merged)
  • #770: Implement delegation to arbitrary GitHub users (merged)
  • #771: Optimize test rebuild times by specifying a default migrator (merged)
  • #774: Improve logging in mergeability check (merged)
  • #776: Update some dependencies (merged)
  • #777: Allow providing a reason for tree closure (merged)
  • #778: Allow attaching notes to PRs (merged)
  • #780: Allow setting squashed commit message to the PR body (merged)
  • #781: Mark PRs that had a significant perf. benchmark on the queue page (merged)
  • #782: Add Beaver favicon to bors (merged)
  • #784: Teach bors to post to Zulip and notify about tree closed/open events (merged)
  • #786: Add support for launching EC2 runners (merged)
  • #791: Install AWS CLI in the Dockerfile (merged)
  • #792: Assume AWS role when running aws commands (merged)
  • #793: Revert “Show expected time left for pending PRs” (merged)
  • #794: Use latest template EC2 version (merged)
  • #795: Add table with pending builds to the queue page (merged)

rust-lang/cargo (13 PRs)

  • #17103: Add funding links (merged)
  • #17149: Rename -Zno-embed-metadata to -Zembed-metadata=no (merged)
  • #17167: Avoid cloning parsed TOML manifest in ManifestErrorContext (merged)
  • #17169: Change HashMaps and HashSets in Cargo to use Fxhasher (merged)
  • #17173: Try to run tests in release mode (closed)
  • #17174: Do not pass lint rustflags when --cap-lints=allow is set (merged)
  • #17175: Make TOML manifest document non-optional (closed)
  • #17176: Avoid extra clone of parsed TOML manifest (merged)
  • #17177: Pre-allocate a few vectors (merged)
  • #17178: Remove unneeded cloning when parsing package index (merged)
  • #17180: Use a set when checking visited workspace members (merged)
  • #17266: Allow setting -Zembed-metadata value from the config (merged)
  • #17267: Enable -Zembed-metadata=no by default on nightly Cargo (open)

rust-lang/ci-mirrors (6 PRs)

  • #37: Mirror sccache 0.16.0 (merged)
  • #38: Mirror sccache 0.16.0 for x64 Windows (merged)
  • #39: Mirror sccache 0.16.0 for x64 Apple (merged)
  • #40: Mirror sccache 0.16.0 (attempt 4/N) (merged)
  • #51: Mirror gettext-1.0.tar.gz (merged)
  • #52: Mirror NetBSD 10.1 files (merged)

rust-lang/blog.rust-lang.org (4 PRs)

  • #1865: Add Maintainer spotlight interview with tiif (merged)
  • #1866: Josh appreciation blog post (merged)
  • #1878: Add Maintainer spotlight interview with rami3l (merged)
  • #1893: Use merge queue (merged)

rust-lang/josh-sync (4 PRs)

  • #51: Allow passing custom josh-proxy path (merged)
  • #52: Read Zulip bot e-mail from inputs and not secrets in CI action (merged)
  • #53: Install josh binaries into a local directory (merged)
  • #54: Add filter version config field (merged)

rust-lang/rustc_codegen_cranelift (3 PRs)

  • #1672: Rustc pull update (closed)
  • #1678: Rustc pull update (closed)
  • #1679: Rustc pull update (open)

rust-lang/rustfmt (3 PRs)

  • #6943: Add funding links (merged)
  • #6987: Merge Linux, Windows and Mac CI into one workflow (merged)
  • #6989: Use merge queue (merged)

rust-lang/calendar (2 PRs)

  • #124: Add JonathanBrouwer to perf. triage rotation (merged)
  • #126: Add periodic events to the Leadership Council calendar (open)

rust-lang/rust-log-analyzer (2 PRs)

  • #98: Make failed job doc URL more visible (merged)
  • #99: Update Zizmor and fix lint (merged)

transact-rs/sqlx (2 PRs)

  • #4320: Mention in docs that many #[sqlx::test]s can slow down rebuild time (open)
  • #4326: Add support for setting a default migrator (open)

rust-lang/futures-rs (1 PR)

  • #3027: Add release-plz to use trusted publishing (open)

rust-lang/jobserver-rs (1 PR)

  • #124: Configure trusted publishing (merged)

rust-lang/promote-release (1 PR)

  • #114: Split rustc promotion into a separate binary (merged)

rust-lang/rfcbot-rs (1 PR)

  • #354: Remove needs-fcp label when an FCP is started (merged)

rust-lang/rust-analyzer (1 PR)

  • #22588: Add funding links (merged)

rust-lang/rust-clippy (1 PR)

  • #17238: Add funding links (merged)

rust-lang/rust-forge (1 PR)

  • #1072: Fix Rust source archive reproduction instructions (merged)

rust-lang/rustc-dev-guide (1 PR)

  • #2906: Update syntax of try build delegation in bors (merged)

rust-lang/rustc-hash (1 PR)

  • #79: Configure trusted publishing via release-plz (merged)

rust-lang/rustup (1 PR)

  • #4905: Add funding links (merged)

rust-lang/simpleinfra (1 PR)

  • #1131: Configure Zulip bot for bors (merged)

rust-lang/surveys (1 PR)

  • #409: Add 2026 Leadership Council review survey (merged)

rust-lang/thanks (1 PR)

  • #105: Add CSV output mode (open)

rust-lang/www.rust-lang.org (1 PR)

  • #2323: Add dedicated Maintainer in Residence page (open)

Conclusion

Overall, these two months felt really good. Even though I was very busy in my personal life, and I wasn’t working much during the first two weeks of June due to preparing for RustMeet, I feel like I managed to do a lot of work on Rust, which always fills me with joy. As always, none of this would be possible without the help of many other people from the Rust Project, who collaborated with me, discussed various things with me, and reviewed my code. Thank you very much!

I would also like to thank the Sovereign Tech Agency for funding my open source maintenance work! I am really grateful for this opportunity.

Recently, I also enrolled into GitHub Sponsors. I did not advertise it much, because I currently have funding for my open source work through the Sovereign Tech Fellowship. However, that is for one year (and it also isn’t full-time), and it is hard to say whether I will be able to find the next source of funding after that. So it is good to have at least some backup. If you’d like to support my open source Rust work, I would really appreciate it! You can find more ways of supporting Rust Project maintainers here.

By the way, since some people keep asking me, unless otherwise noted, I usually do not use LLMs for my Rust work. In the past two months, there was one pull request where I performed a command-line argument refactoring that was very mechanical and boilerplate-y (moving from getopts to clap) with the assistance of an LLM.

If you have any questions regarding my upstream Rust work, feel free to ask on Reddit.

  1. Any merged commit in rust-lang/rust can be directly installed using rustup-toolchain-install-master. It’s a super useful tool! ↩

  2. The build system of the Rust toolchain. ↩

  3. We cannot really see the effects of Cargo performance improvements in rustc-perf. ↩

  4. The name of this environment variable, used for looking up paths for the dynamic linker, is different on other operating systems. ↩

  5. Once the recording is available, I will share it here. ↩