Rust becomes a tier-1 language at Microsoft, alongside C++, C#, and TypeScript

Microsoft has formalized what it had been signaling for years: Rust is now a tier-1 language for internal development, on the same footing as C++, C#, and TypeScript. The announcement came in a guest post on the Rust Foundation, signed by Victor Ciura, principal engineer on the Rust tooling team within the company's DevDiv/CoreAI division.

In practice, "tier-1" isn't a marketing label. According to the post, it means giving internal teams a paved path from local development to production: secure toolchain builds, productive tooling, quality workflows, deep platform integration, and compliance with the SDL (Security Development Lifecycle) requirements that all Microsoft software must meet. It's the same engineering treatment that C++ and C# have received for decades.

What came before

The bet isn't new. Azure CTO Mark Russinovich had already outlined the company's native code strategy around Rust, and Microsoft has invested millions of dollars supporting the Rust project over the past few years. What changes now is the degree of integration: Rust has stopped being a tolerated experiment and become a first-class citizen within the company's engineering systems, spanning everything from firmware and drivers, kernel and hypervisors, to microservices and apps.

rustc_codegen_utc: the core of the announcement

The central technical piece is rustc_codegen_utc, an alternative code generation backend for rustc. It lives in the same architectural family as the backends the community already knows: rustc_codegen_llvm (the default), rustc_codegen_gcc, and rustc_codegen_cranelift. The difference is that it connects the Rust compiler's shared machinery to the MSVC backend, internally nicknamed UTC.

MSVC is Windows' native compiler, and Microsoft's logic is straightforward: instead of reimplementing every Windows-specific capability for Rust from scratch, connecting rustc to the MSVC backend lets Rust inherit decades of platform investment "with perfect compatibility out of the box." What this unlocks, according to the company:

• High compatibility with the Windows tooling ecosystem and ABI
• Binary hardening and code security features
• Compliance, analysis, and post-link servicing (including Hotpatch)
• Seamless Rust/C++ interop in hybrid projects
• Inlining, optimization, and SPGO (Sample Profile Guided Optimization) across languages
• Debugging and crash-dump analysis
• Profiling, diagnostics, and coverage

The result, in the post's words, is a unified code generation platform for Rust and C++ on Windows.

Why Rust/C++ interop is the critical point

This is the detail that matters to anyone maintaining a legacy codebase. On other platforms, a hybrid Rust/C++ project that compiles its C++ with Clang can already get both languages onto the same LLVM codegen platform. rustc_codegen_utc creates that same shared-backend opportunity for native Windows C++ projects, where MSVC is the standard compiler.

The post is candid about the limits: codegen, ABI, exception handling (EH), and post-link tooling are only half the interop challenge. The other half (high-fidelity language-level interop, FFI contracts, bindings, semantic differences, and build systems) is still being worked on within Microsoft and across the industry. The company points to the Rust Foundation's Interoperability Initiative as an overview of that problem space.

This isn't vaporware

rustc_codegen_utc has been production-ready since early 2026 and has been self-hosted since Rust 1.90, meaning the compiler itself compiles with it. More than 100 Microsoft project repositories build with it today, and adoption keeps growing week by week. It's part of a broader internal Rust platform that includes secure supply-chain builds of rustc, the standard library, associated tools, and integration with production pipelines.

What this means for Brazilian developers

For those writing infrastructure, systems, and performance-critical tools in Brazil, the takeaway is one of maturity. Rust had already been gaining traction, but having the world's largest operating system vendor put the language on the same footing as C++ within its own engineering cycle changes the conversation in architecture meetings: adopting Rust for low-level greenfield work stops being an enthusiast's flag and gains the backing of a player making a heavy bet.

In practice, for the Brazilian team already working with native Windows (drivers, system tools, integrations with existing C++ components), the promise of MSVC interop reduces the friction that historically pushed this kind of project back toward C++. It's an optimistic reading, and the caveat is worth noting: for now, all of this is Microsoft's internal infrastructure.

The question the community already asked

The thread on Hacker News captured both the enthusiasm and the obvious doubt. For pjmlp, the weight of the announcement lies in market consolidation:

"This is very big news, all major OS vendors that also have a role in C and C++ language tooling, now have diversified their options in systems programming languages for greenfield development."

>

-- pjmlp

But the practical question that remains open was raised by swiftcoder: "I guess the big question is whether they are going to open up rustc_codegen_utc for use outside of Microsoft?" The post doesn't answer whether, when, or how the backend will be made available outside the company, which leaves open how much of this will actually reach the everyday developer.

Anyone who wants to follow closely can check the dedicated discussion thread Microsoft opened on the Rust project's Zulip for questions and feedback.