Rust, Real-Time Code, and What Comes Next for Software Safety 

TL;DR – What’s new in TrustInSoft Analyzer October 2025: 

• Rust support includes analysis of unsafe blocks and mixed Rust/C/C++ code, with formal guarantees of memory safety. 
• Exhaustive concurrency analysis with detection of race conditions in RTOS, bare-metal, and multi-threaded systems. 
• Modern language and workflow upgrades: support for C23, improved alarm triage, and streamlined root cause exploration. 

The October 2025 release of TrustInSoft Analyzer is here. 

If you’re building software in Rust, working on real-time systems, or trying to keep your code compliant across C/C23, there’s something in this release you’ve probably been waiting for. 

Here’s what just landed—and why it matters. 

Rust Is Safe. Except When It Isn’t. 

Rust has built a reputation around memory safety. The compiler enforces it. The community celebrates it. The tooling ecosystem reinforces it. 

But in the real world, the picture gets murkier. 

• Embedded developers use unsafe blocks to get the job done. 
• High-performance code dips into C and C++. 
• Panics and undefined behaviors still sneak in at the edges. 

These aren’t theoretical risks—they’re the kind that slip past conventional testing and trigger costly (or catastrophic) bugs in production. 

That’s where TrustInSoft Analyzer October 2025 release changes the game. 

You can now use TrustInSoft’s formal methods engine—yes, the same one that proved the absence of memory errors in ARM's mbed TLS stack—to analyze Rust code, including mixed Rust/C/C++ projects. We’re talking detection of undefined behaviors and panic paths andx near-complete support for the core standard library 

If you're in safety-critical, high-assurance, or embedded systems development—this means you can finally say: we proved the absence of runtime errors in our Rust code. 

Threads, Interrupts, and Race Conditions—Analyzed Exhaustively 

Multi-threaded software is notoriously hard to test. 

You can simulate, stress test, even fuzz your way through the obvious bugs. But concurrency issues? They’re like quantum bugs—timing-dependent, rare, and painful to catch. 

Now, they’re no longer invisible. 

With this release, TrustInSoft Analyzer supports concurrent code: 

• Bare-metal and interrupt-driven systems 
• RTOS-based applications 
• Multi-instance thread creation 
• Race condition detection across all execution paths 

Yes, really. All execution paths. 

It’s an especially big deal for developers working in automotive, IoT, or telecom—where system reliability isn’t optional, and concurrency comes baked into the architecture. 

Smarter Alarm Reviews 

We didn’t stop with Rust and threads. 

This release also includes a trio of upgrades that might not be flashy—but they’ll save your team real time: 

• C23 support is now near-complete, with additions like constexpr, _BitInt, and nullptr fully covered. 
• The Root Cause Investigator displays complex structures in a much clearer way. 
• Alarm triage got a boost—teams can now tag, comment on, and link issues directly to bug trackers. One fewer tab to manage. One more hour you can use on actual engineering. 

Why Now? 

Because modern code is harder to trust than ever. 

Rust gives you a great start. Static analysis catches what tests don’t. But when your code blends languages, threads, interrupts, or embedded constraints—it gets complicated fast. 

That’s why we built this release. 

You shouldn’t have to choose between speed and certainty. Between modern language features and proven safety. Between concurrency and peace of mind. Now you don’t have to. 

Where This Leaves Us 

With the October release, TrustInSoft Analyzer provides: 

• Formally verifies Rust, C, C++, and mixed-language code 
• Analyzes all execution paths in concurrent systems 
• Helps you prove—not assume—software safety, security, and compliance 

You write the code. We’ll prove it’s safe.