Rust has been the language of choice for early adopters for years. This week the evidence suggests it is becoming the language of choice for pragmatists too.
In this issue: Ubuntu naming Rust the language for new foundational system software, a production post-mortem that achieved a 78× speedup by redesigning data layout, and SurrealDB 3.0 shipping as a purpose-built store for AI agent memory.
Let's dive in.
Ubuntu Names Rust Its Language for New Foundational Work
Niko Matsakis wrote a post-Rust Nation UK reflection framing what it means that Ubuntu is now using Rust. His framing is worth taking seriously because he uses it to make a point about what mainstream adoption actually requires, and where Rust still has work to do.
The concrete Ubuntu details: Canonical sponsors the Trifecta Tech Foundation's development of sudo-rs and ntpd-rs, and supports the uutils coreutils project. Ubuntu has named Rust, alongside Python, C/C++, and Go, as a primary language for new development, and specifically as the language of choice for new foundational efforts replacing C and C++.
Niko frames this through Geoffrey Moore's technology adoption lifecycle. Rust has crossed the chasm in some domains, most visibly in data plane infrastructure within companies like Amazon, but it remains nascent in others, including safety-critical software. Ubuntu represents a mainstream adopter, a pragmatic organization choosing Rust not because it is exciting but because it is the best available option for the problem. That is a different and more durable kind of adoption than enthusiast-driven use.
The harder point he makes: "we need to make Rust the best option not just in terms of what it could be but in terms of what it actually is." Pragmatists do not bet on potential. They need tooling, documentation, hiring pools, and library coverage that works today. That is a challenge the Rust community still needs to meet deliberately.
The Ubuntu signal matters because Canonical is a risk-averse organization with a long institutional memory. When they standardize on a language for system-level infrastructure, they expect to live with that choice for a decade. Rust is now that choice for new work.
Takeaways:
- Ubuntu replacing C and C++ with Rust for new foundational tooling, including sudo-rs, ntpd-rs, and uutils coreutils, is mainstream adoption in the most literal sense
- Niko's "crossing the chasm" framing is useful: Rust has crossed in some domains but not others, and treating it as universally adopted or universally nascent both miss the picture
- Mainstream pragmatists need Rust to be excellent today, not eventually; the community's response to that pressure will determine how far adoption continues to spread
78× Faster: What the Matrix SDK Taught Us About Lock Contention
The Matrix Rust SDK's room list was freezing. Not briefly, up to five minutes to render a list of rooms. The team at mnt.io wrote a detailed post-mortem that is one of the better performance debugging write-ups I have read this year.
The root causes turned out to be two things working together. First, memory pressure: the sorting algorithm was cloning LatestEventValue objects, each 144 bytes, repeatedly during comparisons. Second, lock contention: the sort called into protected data structures 322,042 times, acquiring a lock on each call. The profiler showed 743MB of total allocations and the same number of lock acquisitions just to sort a list.
The fix was data-oriented design, applied specifically. The team introduced a RoomListItem struct at 64 bytes that caches all the fields the sorters actually need, populated once before the sort runs. Instead of reaching through a lock 322,000 times, the sort operates entirely on a flat array of small structs that fits in L1 cache. The sort no longer needed to acquire any locks: the RoomListItem struct carried everything needed, so the protected data was never touched during the sort itself.
The numbers: 53ms down to 0.676ms. Throughput from 18,800 elements per second to 1.4 million. That is a 78× improvement from two structural changes: eliminating clones during comparison and moving lock access out of the hot path.
What makes this write-up worth reading beyond the benchmarks is the diagnosis process. The authors used profiling to identify that the bottleneck was not the algorithm but the data layout, then applied a well-understood technique from game development, data-oriented design, to a Rust application context. The pattern is not specific to the Matrix SDK. Any Rust code that reads from protected data inside a loop is a candidate for this approach.
Takeaways:
- Lock acquisitions inside sort comparisons compound badly: 322K acquisitions for a single sort pass is a design problem, not a tuning problem, and no amount of lock optimization fixes it
- Data-oriented design in Rust means precomputing a cache-friendly struct before the hot path runs, not restructuring your entire domain model; a 64-byte struct that lives in L1 cache is often enough
- The 78× speedup came from two changes, fewer allocations and zero locks in the hot path; profiling told them which to fix first
SurrealDB 3.0: A Database Built for AI Agent Memory
SurrealDB 3.0, released February 17, is the most substantial release the project has shipped. The headline positioning is "AI agent memory," and the features behind it are worth examining rather than dismissing as marketing.
The architecture changes in 3.0 are real improvements. Separation of values from expressions eliminates redundant computation. ID-based storage reduced catalog keys from 80 to 42 bytes. Synced writes are now the default for durability. Over 150 bug fixes shipped. These are the kinds of changes that make a database trustworthy for production, not just interesting in demos.
The AI-specific features center on a few additions. File support via buckets and file pointers lets you store images, audio, and documents alongside structured data, which matters for multimodal agents. Enhanced vector search with compound indexes, prefix and range scans, and concurrent index builds improves retrieval quality for agent memory lookups. The most interesting addition is Surrealism: a WebAssembly extension system that lets you define custom business logic and integrate AI models, including local LLMs and remote APIs, directly in the database layer.
The DEFINE API statement is also notable. It lets you define custom endpoints in SurrealQL, effectively embedding middleware and rate limiting logic in the database without an external service. For agent-first architectures where you want the data and the logic close together, this reduces the number of moving parts.
SurrealDB is written in Rust, which is not the headline of this story but is the reason it can ship a WebAssembly extension system without a separate runtime. The same binary handles query execution, WASM evaluation, and vector search. That kind of integration is hard to achieve in languages that lean on managed runtimes.
Takeaways:
- The AI agent memory framing is real: file storage, vector search with concurrent indexes, and WASM-based custom logic cover the three things agent memory needs, retrieval, storage, and computation
DEFINE APIis an interesting pattern, embedding endpoint logic in the database reduces the surface area of agent architectures that would otherwise require an API layer between the DB and the agent- 150+ bug fixes and architectural durability improvements make this a serious production release, not just a feature drop
Snippets
Rust debugging survey 2026 The compiler team wants to know how you debug Rust, submissions open until March 13, and if debugging Rust frustrates you this is your chance to say so with data.
FOSDEM 2026: Rust Devroom in Review A recap of the talks and community projects presented at the Rust devroom at FOSDEM 2026.
crates.io malicious crate policy update The crates.io team updated how it communicates malicious crate removals: individual blog posts per removal are being replaced by RustSec advisories, keeping the registry transparent without the noise.
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!