Rust rewards people and projects willing to play the long game. This fortnight Bevy's retrospective shows six years of unglamorous engineering compounding into a real game engine, a Reddit essay explains how Rust rewired one developer's relationship with sloppy code, and Niko Matsakis opens a compiler team investigation into a problem that has resisted resolution for years: cyclic trait implementations.

Bevy Turns Six: From Toy Renderer to Millions of Entities at 60fps

Bevy's sixth birthday retrospective is a rare thing in game engine land: a year-over-year growth report with real numbers attached, not just a highlight reel. GitHub stars grew to 47,529, up 6,629 on the year. Contributors reached 1,527 unique people, up 236. crates.io downloads hit 6.66 million total, up 3.9 million. Discord grew to 23,359 members, and the project merged 12,501 of 16,415 open pull requests, 3,487 more PRs than last year.

Three releases shipped this cycle. Bevy 0.17 brought Solari raytraced lighting, reworked observers and events, the first behavior-only core UI widgets under the Bevy Feathers banner, and Rust hotpatching. Bevy 0.18 added atmosphere occlusion, better PBR shading, and automatic directional navigation. Bevy 0.19 introduced BSN, a templated, composable scene system that one developer says saved 7,364 lines of code when porting spawning logic.

The technical headline is scale. GPU-driven rendering now handles millions of entities at playable framerates, and the bevy_city example renders 55,000 procedurally generated entities at 60fps using standard rendering APIs. That is the kind of number that used to require a proprietary engine. Community momentum backs it up: Bevy Jam #7 drew 310 participants and 64 submissions, and Steam titles built on Bevy, including Simulo, Court Wizard, and Gob Johnson's Downhill Marmalade, are shipping now.

Takeaways:

• Every adoption metric, stars, contributors, downloads, Discord members, grew double digits this year, evidence of compounding growth rather than a single viral moment
• GPU-driven rendering handling 55,000 entities at 60fps in a standard example closes a real gap with commercial engines
• Shipped Steam titles mean Bevy has moved from an engine people are excited about to an engine people ship games with

One Developer on Why Rust Ruined Casual Coding for Him

In a widely discussed r/rust post, a developer with a C and C++ background lays out why the language changed how he thinks about writing code at all. He describes learning to distrust dynamic typing early, which pushed him toward programming "the right way" instead of "the easy way", talking to the compiler far more often than he would in Python, but catching entire classes of silent failure before they ever reach production.

The framing that resonated with the thread is not a technical argument so much as a psychological one. Once you get used to a compiler that refuses to let a whole category of bugs exist, going back feels like giving up a safety net you did not know you needed. That is a familiar story inside the Rust community, but rarely told this plainly, and it is a useful reminder that the borrow checker's real product is not memory safety alone, it is a changed relationship with uncertainty in your own code.

Takeaways:

• The post frames Rust's value less as a feature list and more as a change in the author's default expectations for correctness
• Comparing "talking to the compiler" against Python's late failures is a concrete, relatable way to explain why the friction is worth it
• This is the kind of accessible, personal account that spreads Rust's reputation past people who already read RFCs

Niko Matsakis Opens a Multi-Post Investigation Into Cyclic Trait Solving

Niko Matsakis is kicking off a blog series on one of Rust's oldest unresolved type system questions: when should the compiler accept a trait implementation that depends on itself? Right now, most trait implementations must be non-cyclic. That restriction is what blocks perfect derive, a long-standing goal where a derived Clone impl only requires the bounds a type's fields actually need, instead of the blanket bounds the derive macro currently generates.

The post walks through why some cyclic reasoning is legitimate, using a List<T> type whose Dump implementation needs to reference itself through Rc and Option, and why naive cycle acceptance is dangerous, using a Magic: Copy supertrait example that would let any type falsely prove it implements Copy. Matsakis's working definition of soundness: the trait system is sound if it never accepts a program where some function believes a trait holds for a type but no valid implementation actually exists.

This is scene-setting for a series that Matsakis says will cover coinduction, modal logic, and how the answer might also help with specialization, a long-requested but unresolved Rust feature. It is unglamorous compiler theory work, but it sits directly upstream of ergonomics improvements every Rust user would feel.

Takeaways:

• Perfect derive, tighter bounds on derived trait impls, is blocked on getting cyclic trait reasoning right, not on writing the macro
• The Magic: Copy example is a clean illustration of why simply allowing cycles is not a safe answer
• This is the first of several posts, worth following if you care about where Rust's trait system is headed next

Snippets

• canora, a native and compact Spotify client A screenshot of a small, native Rust desktop client for Spotify, built for people who want playback control without an Electron-sized footprint.

• A homemade Minecraft launcher, seven years in the making One developer shared the Minecraft launcher they set out to build when they first started programming seven years ago, now finally shipped in Rust.

• Rust SIMD on the GPU Vectorware maps core::simd's portable Simd<T, N> vectors directly onto GPU warp lanes, letting the same Rust SIMD code target CPU and GPU without modification.

• Which libraries actively make your code better? A thread on crates that upgrade code quality by default, anyhow and thiserror come up repeatedly for making the professional error-handling path the easy one.

• cynosura: a satellite orienting itself using only star positions A simulation showing a satellite determining its own attitude in space purely from observed star positions, no GPS or ground link required.

• Call for testing: restricting trait implementability and field mutability RFC 3323 lands on nightly with impl(crate) and mut(crate) syntax, letting you seal traits or restrict field mutation without the boilerplate Sealed trait pattern.

• Impressively Capable, Impressively Foolish A field report on the current state of LLM-based coding tools, useful as a grounded counterpoint to the hype cycle.

• Learning-Rust.Github.io A free, community-maintained set of Rust tutorials aimed at complete beginners, a solid link to keep in your back pocket for onboarding new hires.

We are thrilled to have you as part of our growing community of Rust enthusiasts! If you found value in this newsletter, don't keep it to yourself — share it with your network and let's grow the Rust community together.

👉 Take Action Now:

• Share: Forward this email to share this newsletter with your colleagues and friends.

• Engage: Have thoughts or questions? Reply to this email.

• Subscribe: Not a subscriber yet? Click here to never miss an update from Rust Trends.
  
  

Cheers,
Bob Peters

Want to sponsor Rust Trends? We reach thousands of Rust developers biweekly. Get in touch!