# Rust

Rust is a programming language for building reliable and efficient software.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Formally Verified Semidefinite Programming

DevFeed: [Formally Verified Semidefinite Programming](<https://devfeed.tech/articles/formally-verified-semidefinite-programming-145773.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.25174>)

Author: Perry Hart

Published: 2026-11-20T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [cs-lo](<https://devfeed.tech/tags/cs-lo.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [math-oc](<https://devfeed.tech/tags/math-oc.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software](<https://devfeed.tech/tags/software.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verus](<https://devfeed.tech/tags/verus.md>)

### AI overview

The paper presents a first-order semidefinite programming solver implemented in Rust and formally verified in Verus. The authors wrote the solver by hand, then directed Claude to generate its verification. They describe the solver's algorithm, Rust implementation, and pragmatic approach to proving it correct. The excerpt gives no further details about the algorithm or the scope of the proofs.

### Source excerpt

arXiv:2611.25174v1 Announce Type: new Abstract: We present a formally verified Rust implementation of a first-order semidefinite programming solver, a nontrivial piece of numerical software. We wrote the solver by hand and then directed Claude to generate the entire verification in Verus, an automated theorem prover for Rust programs. We discuss the algorithm underlying the solver, its implementation in Rust, and our pragmatic approach to proving it correct in Verus.

## CratesBump: A Version-Bump Dataset for the Rust Ecosystem

DevFeed: [CratesBump: A Version-Bump Dataset for the Rust Ecosystem](<https://devfeed.tech/articles/cratesbump-a-version-bump-dataset-for-the-rust-ecosystem-142191.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23664>)

Author: Muhammad Hassnain

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [versioning](<https://devfeed.tech/topics/versioning.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [cargo](<https://devfeed.tech/tags/cargo.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [pairs](<https://devfeed.tech/tags/pairs.md>), [release-cadence](<https://devfeed.tech/tags/release-cadence.md>), [repository](<https://devfeed.tech/tags/repository.md>), [rust](<https://devfeed.tech/tags/rust.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

CratesBump provides over two million consecutive release pairs from about 220,000 Rust crates, with 41 features spanning AST code diffs, dependency changes, complexity, release cadence, and GitHub activity. Each pair has two version-bump labels: the literal MAJOR.MINOR.PATCH interpretation and Cargo's rule that a 0.y bump is breaking. The accompanying semver-extract tool rebuilds the dataset using public crates.io data and the GitHub API. In held-out repository benchmarks, bump prediction was learnable but far from solved, with lower scores on later releases. The study also examines feature signals, whether declared dependency ranges shield dependents from pre-1.0 breaks, and a sample of releases where cargo-semver-checks found public API breaks in minor or patch releases. The dataset and tool are released under open licenses.

### Source excerpt

arXiv:2611.23664v1 Announce Type: new Abstract: We release CratesBump, the first public dataset for predicting version bumps in the Rust ecosystem, together with semver-extract, the tool that builds it. CratesBump is built from every crate on crates.io with at least two releases before 14 September 2026 (about 220,000 crates), giving over two million consecutive release pairs. Each pair has 41 features (code changes from AST diffs, dependency changes, complexity, release cadence, GitHub commit and issue activity), its source repository where listed, and two labels: the literal reading of MAJOR.MINOR.PATCH, and Cargo's rule, under which a 0.y bump is a breaking change. semver-extract regenerates the dataset from public crates.io data and the GitHub API. To illustrate its use we (i) benchmark bump predictors on held-out repositories, finding the task learnable but far from solved, with lower scores on later releases; (ii) measure which feature groups carry the signal; (iii) check, against declared dependency ranges, how often Cargo's rule shields dependents from pre-1.0 breaking releases; and (iv) audit a sample of releases with cargo-semver-checks, finding minor and patch releases that break the public API despite their version number. Dataset and tool are released under open licenses.

## Re-Testing LLM-Based C-to-Rust Translations Against Their Original C

DevFeed: [Re-Testing LLM-Based C-to-Rust Translations Against Their Original C](<https://devfeed.tech/articles/re-testing-llm-based-c-to-rust-translations-against-their-original-c-142198.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.23839>)

Author: Muhammad Hassnain

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Software Testing](<https://devfeed.tech/topics/software-testing.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [defects](<https://devfeed.tech/tags/defects.md>), [errors](<https://devfeed.tech/tags/errors.md>), [input](<https://devfeed.tech/tags/input.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [rust](<https://devfeed.tech/tags/rust.md>), [testing](<https://devfeed.tech/tags/testing.md>), [translations](<https://devfeed.tech/tags/translations.md>)

### AI overview

The authors re-tested 11 LLM-based C-to-Rust translators that release runnable C and Rust programs. They ran both versions on generated inputs and compared every output, counting divergences only when the C had no undefined behavior. All 11 had defective translations, with 160 defects, including 93 errors on ordinary inputs; the translators' own checks accepted 86 defective translations. In 81 cases, the released check never tested an input exposing the defect, and in three of the other five it compared only part of the output. The authors recommend testing on inputs unseen by the repair loop, comparing all outputs, checking that verifiers reach their assertions, releasing the exact code the check accepted, and reporting how the check was tested.

### Source excerpt

arXiv:2611.23839v1 Announce Type: new Abstract: Most C-to-Rust translators use large language models (LLMs), and each reports a success rate from its own correctness check. We survey 34 C-to-Rust translators that use LLMs. Only one reports testing its check, and eleven release the original C and their Rust in runnable form. We re-test all eleven. We run the C and the Rust on generated inputs, compare every output, and count a divergence only where the C has no undefined behavior. All eleven release defective translations: we find 160 defects, 93 of them outright errors on ordinary inputs. Their own checks accepted 86 defective translations. For 81 of them, the released check never compared the programs on an input that exposes the defect. For three of the other five, it ran one but compared only part of the output. A success rate is only as good as its check. Before counting a translation as a success, authors should compare every output with the C's on inputs the repair loop never saw, check that a verifier reaches its assertion, release exactly what the check accepted, and report how they tested the check.

## Discord Rewrites Desktop and Mobile Clients in Rust Using Zed's GPU-Accelerated Rendering Framework

DevFeed: [Discord Rewrites Desktop and Mobile Clients in Rust Using Zed's GPU-Accelerated Rendering Framework](<https://devfeed.tech/articles/discord-rewrites-desktop-and-mobile-clients-in-rust-using-zed-s-gpu-accelerated-rendering-framework-142018.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/discord-rust-rewrite-gpui-zed/>)

Author: Bruno Couriol

Published: 2026-11-19T03:12:00Z

Content type: article

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Discord](<https://devfeed.tech/topics/discord.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Electron](<https://devfeed.tech/topics/electron.md>), [React Native](<https://devfeed.tech/topics/react-native.md>), [mobile-app-performance](<https://devfeed.tech/topics/mobile-app-performance.md>), [GPU rendering](<https://devfeed.tech/topics/gpu-rendering.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-ml-data-engineering](<https://devfeed.tech/tags/ai-ml-data-engineering.md>), [android](<https://devfeed.tech/tags/android.md>), [desktop](<https://devfeed.tech/tags/desktop.md>), [development](<https://devfeed.tech/tags/development.md>), [discord](<https://devfeed.tech/tags/discord.md>), [discord-rust-rewrite-gpui-zed](<https://devfeed.tech/tags/discord-rust-rewrite-gpui-zed.md>), [electron](<https://devfeed.tech/tags/electron.md>), [framework](<https://devfeed.tech/tags/framework.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gpu-accelerated](<https://devfeed.tech/tags/gpu-accelerated.md>), [ml-data-engineering](<https://devfeed.tech/tags/ml-data-engineering.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [native](<https://devfeed.tech/tags/native.md>), [native-apps](<https://devfeed.tech/tags/native-apps.md>), [news](<https://devfeed.tech/tags/news.md>), [performance](<https://devfeed.tech/tags/performance.md>), [ram](<https://devfeed.tech/tags/ram.md>), [react-native](<https://devfeed.tech/tags/react-native.md>), [rendering](<https://devfeed.tech/tags/rendering.md>), [rust](<https://devfeed.tech/tags/rust.md>), [zed](<https://devfeed.tech/tags/zed.md>)

### AI overview

Discord's Phoenix rewrite replaces Electron on desktop with Zed's GPU accelerated GPUI framework and replaces React Native on mobile with native iOS and Android views. Both clients share application code through a Rust core; the browser client remains HTML with logic compiled to WebAssembly, and embedded web surfaces use the operating system's webview. Early internal builds reportedly use about 290 MB of RAM with two accounts logged in and start nearly instantly, versus 5.5 seconds for the Electron client; the mobile rewrite loads in under 2 seconds versus about 5 seconds for the legacy app. These are early results, not broad comparative benchmarks. The excerpt cites a controlled React Native study where Swift led on comparable iOS runtime metrics, while Android differences were small and mixed. GPUI trades browser features such as mature text layout, input method integration, screen-reader hooks, and right-to-left support for a custom GPU rendered interface, requiring developers to assemble some capabilities themselves.

### Source excerpt

Discord's CTO Stanislav Vishnevskiy recently announced rewriting its desktop and mobile clients in Rust, moving away from Electron and React Native. The project eliminates layers of abstraction to directly leverage the device's GPU, native mobile views, and a Rust core shared across platforms. Early results hint at a significant reduction in RAM usage and boot time for chat, voice, and streaming. By Bruno Couriol

## High-throughput Transfer Manager for Amazon S3 in Rust is now generally available

DevFeed: [High-throughput Transfer Manager for Amazon S3 in Rust is now generally available](<https://devfeed.tech/articles/high-throughput-transfer-manager-for-amazon-s3-in-rust-is-now-generally-available-144014.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/developer/high-throughput-transfer-manager-for-amazon-s3-in-rust-is-now-generally-available/>)

Author: Nitin Prakash

Published: 2026-11-18T23:48:54Z

Content type: release

Language: en

Sources: [AWS Developer Tools Blog](<https://devfeed.tech/sources/aws-developer-tools-blog.md>)

Topics: [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Tokio](<https://devfeed.tech/topics/tokio.md>), [Streaming](<https://devfeed.tech/topics/streaming.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [amazon-s3](<https://devfeed.tech/tags/amazon-s3.md>), [amazon-simple-storage-service-s3](<https://devfeed.tech/tags/amazon-simple-storage-service-s3.md>), [aws-sdk](<https://devfeed.tech/tags/aws-sdk.md>), [backpressure](<https://devfeed.tech/tags/backpressure.md>), [bandwidth](<https://devfeed.tech/tags/bandwidth.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [bounded](<https://devfeed.tech/tags/bounded.md>), [buffer-pool](<https://devfeed.tech/tags/buffer-pool.md>), [caching](<https://devfeed.tech/tags/caching.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [developer-preview](<https://devfeed.tech/tags/developer-preview.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [directory](<https://devfeed.tech/tags/directory.md>), [dns](<https://devfeed.tech/tags/dns.md>), [download](<https://devfeed.tech/tags/download.md>), [downloads](<https://devfeed.tech/tags/downloads.md>), [engine](<https://devfeed.tech/tags/engine.md>), [launch](<https://devfeed.tech/tags/launch.md>), [library](<https://devfeed.tech/tags/library.md>), [memory](<https://devfeed.tech/tags/memory.md>), [rust](<https://devfeed.tech/tags/rust.md>), [s3](<https://devfeed.tech/tags/s3.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>)

### AI overview

The Rust Transfer Manager for Amazon S3 is generally available with a redesigned engine for high-throughput transfers. By default, it starts one worker per detected core, reuses connections across transfers, and uses a fair scheduler intended to keep large transfers from starving small ones; work can be distributed across multiple network interfaces when configured. A shared buffer pool bounds memory, defaulting to up to a quarter of available memory with a 32 GiB cap. Downloads write parts directly to their final positions, while streaming delivers parts in order with backpressure. Optional runtime diagnostics expose buffer snapshots and transfer traces through environment variables. The library also supports `wasm32-wasi*` targets. Getting started requires AWS credentials with the stated S3 permissions, a Tokio-based Rust project, and a bucket. The excerpt does not include the dependency or client setup code.

### Source excerpt

High-throughput transfers to and from Amazon Simple Storage Service (Amazon S3) often require manual tuning of threads, connections, and memory. Transfer Manager for Amazon S3, a high-level transfer library for Rust, handles this work for you. It is now generally available (GA). Since the developer preview launch in March 2025, we have redesigned the library. [...]

## Four major changes coming to Rust

DevFeed: [Four major changes coming to Rust](<https://devfeed.tech/articles/four-major-changes-coming-to-rust-140726.md>)

Original publisher: [Read original article](<https://www.infoworld.com/article/4240528/four-major-changes-coming-to-rust.html>)

Author: Serdar Yegulalp

Published: 2026-11-18T09:00:00Z

Content type: article

Language: en

Sources: [InfoWorld](<https://devfeed.tech/sources/infoworld.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [rust-ai](<https://devfeed.tech/topics/rust-ai.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [generic programming](<https://devfeed.tech/topics/generic-programming.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [accelerated](<https://devfeed.tech/tags/accelerated.md>), [async](<https://devfeed.tech/tags/async.md>), [caching](<https://devfeed.tech/tags/caching.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [changes](<https://devfeed.tech/tags/changes.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [covers](<https://devfeed.tech/tags/covers.md>), [csv](<https://devfeed.tech/tags/csv.md>), [data](<https://devfeed.tech/tags/data.md>), [data-type](<https://devfeed.tech/tags/data-type.md>), [define](<https://devfeed.tech/tags/define.md>), [developers](<https://devfeed.tech/tags/developers.md>), [development](<https://devfeed.tech/tags/development.md>), [exists](<https://devfeed.tech/tags/exists.md>), [faster](<https://devfeed.tech/tags/faster.md>), [features](<https://devfeed.tech/tags/features.md>), [function](<https://devfeed.tech/tags/function.md>), [has](<https://devfeed.tech/tags/has.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [programming-languages-rust-software-development](<https://devfeed.tech/tags/programming-languages-rust-software-development.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [storytype-feature](<https://devfeed.tech/tags/storytype-feature.md>)

### AI overview

Four initiatives could broaden Rust's capabilities: a next-generation trait solver, the Polonius borrow checker, a parallel compiler front end, and higher-level machine-learning optimizations. The new solver uses caching to address self-referential-type problems and may be faster, but it still needs to cover all use cases, including async. Polonius analyzes control flow rather than lexical scopes, potentially accepting more memory-safe code; it remains experimental and needs broader analysis and performance work. Front-end parallelism could speed parsing, type checking, and borrow checking, but needs stronger consistency testing and support for features such as macro expansion. For machine learning, Rust lacks higher-level tensor and matrix optimizations and compilation to accelerators such as TPUs; proposed MLIR support could enable specialized code generation. These efforts are at different stages and are described as ongoing work, not completed capabilities.

### Source excerpt

Over its decade-and-a-half lifetime, the Rust programming language has evolved dramatically. Rust has always been about ensuring safe programming with strong typing that doesn't sacrifice speed. But how it expresses those capabilities has matured and expanded, and that movement hasn't slowed. If anything, it has accelerated. At any given time in Rust's development, you could point to dozens of different initiatives to improve the language. As of the end of 2026, four of these stand far above the rest, because of how broad their impact could be and how deeply they touch on many aspects of Rust. The next-generation trait solver Rust's type system uses "traits" to define the functionality that a given type has and can share with other types. If we described a trait named ExportToJSON, we might have a matching impl, or implementation, for a data type: impl ExportToJSON for CSV The Rust compiler tries to find matching implementations for each reference to a trait. This is highly important for generic functions, since it may not be obvious if an implementation exists for a given invocation of a function. The current version of the trait solver has problems dealing with situations like self-referential types. Those aren't common, but Rust programmers must consciously avoid constructing them to keep the trait solver from getting tied up in knots. Sometimes, because of this, it's the developer who gets ensnarled. A new version of the trait solver takes a totally different approach to the problem. It draws on ideas gleaned from an earlier attempt to rewrite the trait solver (called "Chalk"), and uses a sophisticated caching mechanism both to avoid problems with self-referential types and potentially run faster than the current solver. The current version of the new trait solver covers some use cases, but not all of them. The next step is to ensure that the solver can cover all use cases, including async features. Once that happens, Rust developers will have far more freedom i

## RustMC: Automated Verification of Real-World Concurrent Rust

DevFeed: [RustMC: Automated Verification of Real-World Concurrent Rust](<https://devfeed.tech/articles/rustmc-automated-verification-of-real-world-concurrent-rust-141437.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2502.06293>)

Author: Oliver Pearce, Julien Lange, Dan O'Keeffe

Published: 2026-11-18T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Cryptography and Security](<https://devfeed.tech/sources/arxiv-cryptography-and-security.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>), [race-condition](<https://devfeed.tech/topics/race-condition.md>)

Tags: [atomic](<https://devfeed.tech/tags/atomic.md>), [automated](<https://devfeed.tech/tags/automated.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c-c-plus-plus](<https://devfeed.tech/tags/c-c-plus-plus.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-bugs](<https://devfeed.tech/tags/concurrency-bugs.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data-structures](<https://devfeed.tech/tags/data-structures.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [ffi](<https://devfeed.tech/tags/ffi.md>), [loom](<https://devfeed.tech/tags/loom.md>), [model](<https://devfeed.tech/tags/model.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stateless](<https://devfeed.tech/tags/stateless.md>), [unmodified](<https://devfeed.tech/tags/unmodified.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

RustMC is a stateless model checker designed to verify unmodified concurrent Rust programs. It builds on GenMC's LLVM IR framework, which also lets it cover foreign-function dependencies written in C or C++. The paper identifies Rust-specific implementation challenges: intercepting threading operations, promoting memory intrinsics, and handling uninitialised accesses. Case studies adapted from real-world programs report concurrency bugs in unsafe Rust, FFI calls, and atomic operations. The evaluation uses the Loom model checker test suite and production-level Rust concurrent data structures; the supplied abstract does not report detailed results.

### Source excerpt

arXiv:2502.06293v2 Announce Type: replace-cross Abstract: RustMC is a stateless model checker that targets push-button verification of unmodified concurrent Rust programs. As both Rust and C/C++ compile to LLVM IR, RustMC builds on GenMC which provides a verification framework for LLVM IR. This allows verification of Rust code and any foreign function dependencies. In this tool paper we present key implementation challenges, use-cases, and an empirical evaluation of RustMC. The challenges include intercepting threading operations, promoting memory intrinsics, and handling uninitialised accesses, all stemming from Rust's unique compilation strategy. Case studies adapted from real-world programs show RustMC finds concurrency bugs in unsafe Rust code, FFI calls to C/C++, and atomic operations. We evaluate our tool's functionality on the Loom model checker test suite and a set of production-level Rust concurrent data structures.

## RBRD: RAM-Backed Linux Block Driver Written In Rust For Better Safety But Slower Performance

DevFeed: [RBRD: RAM-Backed Linux Block Driver Written In Rust For Better Safety But Slower Performance](<https://devfeed.tech/articles/rbrd-ram-backed-linux-block-driver-written-in-rust-for-better-safety-but-slower-performance-139467.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/RBRD-Rust-Linux-RAM-Driver>)

Author: Michael Larabel

Published: 2026-11-18T02:04:05Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [block](<https://devfeed.tech/tags/block.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [driver](<https://devfeed.tech/tags/driver.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-kernel](<https://devfeed.tech/tags/linux-kernel.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [patches](<https://devfeed.tech/tags/patches.md>), [performance](<https://devfeed.tech/tags/performance.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [ram](<https://devfeed.tech/tags/ram.md>), [rust](<https://devfeed.tech/tags/rust.md>), [safety](<https://devfeed.tech/tags/safety.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

RBRD is a proposed Rust implementation of Linux's RAM-backed BRD block driver. It prevents reads and writes from copying a page at the same time, a guarantee intended to preserve page integrity and avoid undefined behavior. The excerpt reports write performance about 19% lower with one thread and 22% lower with eight; reads are 2-10% slower. The developers say the performance gap has not been profiled, so not all of it can be attributed to the locking, and report that a single device-wide lock made eight-thread reads 20-28% slower than BRD. The patch series was posted for review.

### Source excerpt

Linux kernel patches were posted tonight for introducing RBRD, the RAM-backed block driver written in the Rust programming language...

## Announcing the General Availability of the Azure Cosmos DB SDK for Rust!

DevFeed: [Announcing the General Availability of the Azure Cosmos DB SDK for Rust!](<https://devfeed.tech/articles/announcing-the-general-availability-of-the-azure-cosmos-db-sdk-for-rust-139447.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/cosmosdb/announcing-the-general-availability-of-the-azure-cosmos-db-sdk-for-rust/>)

Author: Theo van Kraay

Published: 2026-11-17T18:45:35Z

Content type: release

Language: en

Sources: [Azure Cosmos DB Blog](<https://devfeed.tech/sources/azure-cosmos-db-blog.md>)

Topics: [SDK](<https://devfeed.tech/topics/sdk.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Azure](<https://devfeed.tech/topics/azure.md>), [Tokio](<https://devfeed.tech/topics/tokio.md>)

Tags: [azure](<https://devfeed.tech/tags/azure.md>), [azure-cosmos-db](<https://devfeed.tech/tags/azure-cosmos-db.md>), [azure-cosmos-db-for-nosql](<https://devfeed.tech/tags/azure-cosmos-db-for-nosql.md>), [client](<https://devfeed.tech/tags/client.md>), [cosmos](<https://devfeed.tech/tags/cosmos.md>), [general-availability](<https://devfeed.tech/tags/general-availability.md>), [native](<https://devfeed.tech/tags/native.md>), [native-client](<https://devfeed.tech/tags/native-client.md>), [nosql](<https://devfeed.tech/tags/nosql.md>), [preview](<https://devfeed.tech/tags/preview.md>), [production](<https://devfeed.tech/tags/production.md>), [rust](<https://devfeed.tech/tags/rust.md>), [sdk](<https://devfeed.tech/tags/sdk.md>)

### AI overview

The Azure Cosmos DB SDK for Rust is generally available as a native client for Azure Cosmos DB for NoSQL, with production-oriented defaults enabled. It uses Gateway v2 for low-latency access without direct-mode complexity, binary serialization to reduce serialization costs, RU costs, and network bytes, and per-partition automatic failover and circuit breaking to contain failures. Safe read and write operations are retried automatically, though stored procedure execution and some patch operations cannot be safely retried. The SDK was hardened using OpenAI production traffic, including high partition counts, contention, and network stress. Getting started requires a Rust environment and a Cosmos DB account or emulator; the article shows Cargo dependencies and client setup with DefaultAzureCredential and Microsoft Entra ID.

### Source excerpt

The Azure Cosmos DB SDK for Rust is now generally available. It is a native client for Azure Cosmos DB for NoSQL, built for production workloads, and it builds on the public preview we shipped earlier this year. The theme of this release is simple: the SDK comes with the right defaults for production, and [...] The post Announcing the General Availability of the Azure Cosmos DB SDK for Rust! appeared first on Azure Cosmos DB Blog.

## Alternate Rigol DHO800/DHO900 oscilloscope firmware, with a Linux 6.12 kernel, written in Rust

DevFeed: [Alternate Rigol DHO800/DHO900 oscilloscope firmware, with a Linux 6.12 kernel, written in Rust](<https://devfeed.tech/articles/alternate-rigol-dho800-dho900-oscilloscope-firmware-with-a-linux-6-12-kernel-written-in-rust-137830.md>)

Original publisher: [Read original article](<https://blog.adafruit.com/2026/11/17/alternate-rigol-dho800-dho900-oscilloscope-firmware-with-a-linux-6-12-kernel-written-in-rust/>)

Author: Anne Barela

Published: 2026-11-17T15:38:14Z

Content type: article

Language: en

Sources: [Adafruit Industries](<https://devfeed.tech/sources/adafruit-industries-makers-hackers-artists-designers-and-engineers.md>)

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Web](<https://devfeed.tech/topics/web.md>)

Tags: [acquisition](<https://devfeed.tech/tags/acquisition.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [application](<https://devfeed.tech/tags/application.md>), [computers](<https://devfeed.tech/tags/computers.md>), [ee](<https://devfeed.tech/tags/ee.md>), [eye](<https://devfeed.tech/tags/eye.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [generator](<https://devfeed.tech/tags/generator.md>), [jitter](<https://devfeed.tech/tags/jitter.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [linux](<https://devfeed.tech/tags/linux.md>), [logic-analyzer](<https://devfeed.tech/tags/logic-analyzer.md>), [math](<https://devfeed.tech/tags/math.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [oscilloscope](<https://devfeed.tech/tags/oscilloscope.md>), [power](<https://devfeed.tech/tags/power.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [rigol](<https://devfeed.tech/tags/rigol.md>), [rust](<https://devfeed.tech/tags/rust.md>), [sd-card](<https://devfeed.tech/tags/sd-card.md>), [software](<https://devfeed.tech/tags/software.md>), [stock](<https://devfeed.tech/tags/stock.md>), [test-equipment](<https://devfeed.tech/tags/test-equipment.md>)

### AI overview

OOS is independent replacement firmware for Rigol DHO800/DHO900 oscilloscopes, booted from the scope's SD card alongside the factory system; users can select the stock system at power-on. It uses Linux 6.12 and a Rust scope application developed from observations and documentation, without vendor code. Features include acquisition, triggering, measurements and math, 26 protocol decoders, plus logic-analyzer support on boards with an LA port and generator support on S models. It also offers a web screen mirror and SCPI control, and analysis pages for spectrum, eye and jitter, power, and Bode plots. The project is experimental: it has run on a DHO924S and, in one user report, a DHO804; several functions remain untested on hardware, and measurements are not calibrated to a standard. Installation begins with a full backup image of the factory card.

### Source excerpt

OOS, by dekajoule, replaces the software on a Rigol DHO800/DHO900 oscilloscope with a Linux 6.12 kernel and a new scope application written in Rust. It runs from the scope's own SD card alongside the stock system, and the stock system can be selected again at power-on. The project is independent of Rigol and has no [...]

## VeruSAGE-Bench: A Benchmark Suite for Rust System Verification

DevFeed: [VeruSAGE-Bench: A Benchmark Suite for Rust System Verification](<https://devfeed.tech/articles/verusage-bench-a-benchmark-suite-for-rust-system-verification-137918.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2512.18436>)

Author: Chenyuan Yang, Natalie Neamtu, Chris Hawblitzel, Jacob R. Lorch, Shan Lu

Published: 2026-11-17T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Automated reasoning](<https://devfeed.tech/topics/automated-reasoning.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-fl](<https://devfeed.tech/tags/cs-fl.md>), [cs-os](<https://devfeed.tech/tags/cs-os.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [gpt-5](<https://devfeed.tech/tags/gpt-5.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [operating-systems](<https://devfeed.tech/tags/operating-systems.md>), [proofs](<https://devfeed.tech/tags/proofs.md>), [qwen3-5](<https://devfeed.tech/tags/qwen3-5.md>), [rust](<https://devfeed.tech/tags/rust.md>), [storage-systems](<https://devfeed.tech/tags/storage-systems.md>), [systems](<https://devfeed.tech/tags/systems.md>), [tasks](<https://devfeed.tech/tags/tasks.md>), [verification](<https://devfeed.tech/tags/verification.md>), [verus](<https://devfeed.tech/tags/verus.md>)

### AI overview

VeruSAGE-Bench tests system-level Rust verification with 849 proof tasks drawn from eight open-source systems verified in Verus, including operating systems, storage systems, and memory allocators. Its tasks average over 20 times the formal specification length of prior benchmarks and require a broader range of verification techniques. Across six evaluated LLMs, success rates and costs vary substantially by model and agent setup. The hardest tasks can take over an hour; reported averages are 15.3 minutes and USD 13.65 per task. In the harder version without human-written helper lemmas, the best model proves 41% of tasks from the hardest project, at USD 96 per task.

### Source excerpt

arXiv:2512.18436v3 Announce Type: replace-cross Abstract: Large language models (LLMs) have shown impressive capability to understand and develop code. However, their capability to rigorously reason about and formally prove the correctness of software systems remains in question. Current benchmarks for formal proof generation focus on isolated tasks, typically algorithmic-style problems utilizing basic data structures. We curate a new benchmark suite for system-level proof generation, VeruSAGE-Bench, which consists of 849 proof tasks extracted from eight open-source Verus-verified Rust systems, covering operating systems, storage systems, memory allocators, and more. These tasks are much more complicated than those in previous benchmarks, containing on average more than 20x the formal specification (in Lines of Code) and requiring a much broader array of verification techniques. We evaluate six LLMs on VeruSAGE-Bench (o4-mini, GPT-5, Sonnet 4, Sonnet 4.5, Opus 4.5, Qwen3.5), and demonstrate that different models and agentic setups lead to vastly different success rates and costs. We also show that the best models possess impressive capability in writing correctness proofs and hence should inspire new ways of developing trustworthy software. Meanwhile, some difficult tasks in VeruSAGE-Bench stress even the best model, forcing long reasoning time (over an hour on the hardest tasks, 15.3 min per task on average), high token cost (USD 13.65 per task on average), and proof failures, which we hope will guide future improvements in models and agents. This is particularly true for a harder no-lemma version of VeruSAGE-Bench, where the helper lemmas written by human experts are removed: there, the best model proves only 41% of the tasks from the hardest project, at USD 96 per task.

## Actual curl rewrites in rust

DevFeed: [Actual curl rewrites in rust](<https://devfeed.tech/articles/actual-curl-rewrites-in-rust-136715.md>)

Original publisher: [Read original article](<https://daniel.haxx.se/blog/2026/11/17/actual-curl-rewrites-in-rust/>)

Author: Daniel Stenberg

Published: 2026-11-16T23:54:58Z

Content type: opinion

Language: en

Sources: [Daniel Stenberg](<https://devfeed.tech/sources/daniel-stenberg.md>)

Topics: [cURL](<https://devfeed.tech/topics/curl.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [abi](<https://devfeed.tech/tags/abi.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ais](<https://devfeed.tech/tags/ais.md>), [api](<https://devfeed.tech/tags/api.md>), [bugfixes](<https://devfeed.tech/tags/bugfixes.md>), [c](<https://devfeed.tech/tags/c.md>), [commits](<https://devfeed.tech/tags/commits.md>), [community](<https://devfeed.tech/tags/community.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [curl](<https://devfeed.tech/tags/curl.md>), [curl-and-libcurl](<https://devfeed.tech/tags/curl-and-libcurl.md>), [development](<https://devfeed.tech/tags/development.md>), [feature](<https://devfeed.tech/tags/feature.md>), [language](<https://devfeed.tech/tags/language.md>), [maintainers](<https://devfeed.tech/tags/maintainers.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-safe](<https://devfeed.tech/tags/memory-safe.md>), [mistakes](<https://devfeed.tech/tags/mistakes.md>), [money](<https://devfeed.tech/tags/money.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The author argues that AI-assisted Rust rewrites can reproduce curl at a point in time, aided by curl's documentation, API examples and test suite, but that writing the code once is not the main challenge. During the rewrites' little over three weeks of work, the curl project merged more than 300 commits and made over 200 bug fixes, illustrating the ongoing maintenance and community effort clones would need to match. The author says 14 of 81 curl vulnerabilities confirmed in 2026 likely involved mistakes Rust might have prevented; a Rust version would still have had the other 67. They favor continuous polishing, iteration and refactoring over rewrites, and leave open whether the projects will remain proofs of concept or keep pace with curl.

### Source excerpt

For a long time we have received repeated requests for, or questions about, a curl rewrite in rust. Often as a joke, but also seriously. In this modern world of AIs, we have only been waiting for someone to prove it possible and now it seems we don't have to wait anymore. This fall seems ... Continue reading Actual curl rewrites in rust ->

## Rust Nightly To Begin Enabling Parallel Frontend By Default

DevFeed: [Rust Nightly To Begin Enabling Parallel Frontend By Default](<https://devfeed.tech/articles/rust-nightly-to-begin-enabling-parallel-frontend-by-default-135501.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Rust-Nightly-Parallel-Frontend>)

Author: Michael Larabel

Published: 2026-11-16T14:39:24Z

Content type: news

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>)

Tags: [back-end](<https://devfeed.tech/tags/back-end.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [build](<https://devfeed.tech/tags/build.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [developers](<https://devfeed.tech/tags/developers.md>), [front-end](<https://devfeed.tech/tags/front-end.md>), [frontend](<https://devfeed.tech/tags/frontend.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [nightly](<https://devfeed.tech/tags/nightly.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [performance](<https://devfeed.tech/tags/performance.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [plan](<https://devfeed.tech/tags/plan.md>), [rust](<https://devfeed.tech/tags/rust.md>), [speed](<https://devfeed.tech/tags/speed.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>), [testing](<https://devfeed.tech/tags/testing.md>), [threads](<https://devfeed.tech/tags/threads.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Rust Nightly is beginning to enable parallel frontend compilation by default so the project can test it ahead of a possible move to stable. Frontend parallelization has been available but defaulted to one thread; using multiple threads can let frontend work use multiple CPU cores alongside the backend. The excerpt says Rust project benchmarks show speedups with 2, 4, and 8 threads but provides no figures. Developers will monitor Nightly results over the coming months and continue improving performance. The frontend thread count can be set with `--jobs-frontend=`.

### Source excerpt

While Rust's back-end has long been using multiple threads for compiling code, the Rust front-end has been executing sequentially by default. Finally, Rust Nightly is in the process of beginning to enable its parallel front-end by default to allow for more testing ahead of its eventual stabilization...

## How Mitts Makes Parallel Rust Builds Faster Than Cargo

DevFeed: [How Mitts Makes Parallel Rust Builds Faster Than Cargo](<https://devfeed.tech/articles/how-mitts-makes-parallel-rust-builds-faster-than-cargo-135516.md>)

Original publisher: [Read original article](<https://hackernoon.com/how-mitts-makes-parallel-rust-builds-faster-than-cargo?source=rss>)

Author: Alexander Panasenko

Published: 2026-11-16T05:00:02Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Cache](<https://devfeed.tech/topics/cache.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [builds](<https://devfeed.tech/topics/builds.md>), [developer-productivity](<https://devfeed.tech/topics/developer-productivity.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>), [Tool](<https://devfeed.tech/topics/tool.md>)

Tags: [ai-coding](<https://devfeed.tech/tags/ai-coding.md>), [build-systems](<https://devfeed.tech/tags/build-systems.md>), [builds](<https://devfeed.tech/tags/builds.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [cargo-alternatives](<https://devfeed.tech/tags/cargo-alternatives.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [content-addressed-caching](<https://devfeed.tech/tags/content-addressed-caching.md>), [distributed-build-caching](<https://devfeed.tech/tags/distributed-build-caching.md>), [parallel](<https://devfeed.tech/tags/parallel.md>), [reuse](<https://devfeed.tech/tags/reuse.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-build-isolation](<https://devfeed.tech/tags/rust-build-isolation.md>), [rust-worktrees](<https://devfeed.tech/tags/rust-worktrees.md>), [rustls](<https://devfeed.tech/tags/rustls.md>), [worktrees](<https://devfeed.tech/tags/worktrees.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

In a study of twelve `rustls` worktrees on Linux x86_64, Mitts completed the batch in 9.3 seconds, compared with 3 min 42 s for plain Cargo and 3 min 59 s for warm sccache; shared-cache priming was excluded. Mitts reuses eligible completed compilation results across separate worktrees using action keys based on tracked inputs, while keeping each workspace's outputs separate. The reported gains vary by workload: Cargo often wins a single cold build and can be faster for edits within a large crate, where incremental compilation helps. A shared `CARGO_TARGET_DIR` failed a correctness check involving a deliberately failing test. Mitts is pre-release, supports Linux and macOS, and does not yet support Windows, cross-compilation beyond the host target, or remote/team caches. The excerpt reports three-repeat medians and cautions that build-script staging is not an OS sandbox.

### Source excerpt

12 rustls worktrees on Linux x86_64: Cargo 3 min 42 s, Mitts 9.3 s. How shared caches reuse build work, and where Cargo still wins.

## Beyond Source Code: Evaluating Natural Language Specifications for LLM-Based C-to-Rust Translation

DevFeed: [Beyond Source Code: Evaluating Natural Language Specifications for LLM-Based C-to-Rust Translation](<https://devfeed.tech/articles/beyond-source-code-evaluating-natural-language-specifications-for-llm-based-c-to-rust-translation-136502.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.17581>)

Author: Biruk Tadesse, Lawrence Arkoh, Marcelo D'Amorim, Wesley K. G. Assun\\c{c}\\~ao

Published: 2026-11-16T05:00:00Z

Content type: comparison

Language: en

Sources: [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [LLM evaluation / benchmarking](<https://devfeed.tech/topics/llm-evaluation-benchmarking.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Code quality](<https://devfeed.tech/topics/code-quality.md>), [Transpilers](<https://devfeed.tech/topics/transpilers.md>), [lint](<https://devfeed.tech/topics/lint.md>)

Tags: [balance](<https://devfeed.tech/tags/balance.md>), [c](<https://devfeed.tech/tags/c.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [clippy](<https://devfeed.tech/tags/clippy.md>), [code-quality](<https://devfeed.tech/tags/code-quality.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [functional](<https://devfeed.tech/tags/functional.md>), [gpt-5-2](<https://devfeed.tech/tags/gpt-5-2.md>), [hypothesis](<https://devfeed.tech/tags/hypothesis.md>), [large-language-models-llms](<https://devfeed.tech/tags/large-language-models-llms.md>), [maintainability](<https://devfeed.tech/tags/maintainability.md>), [mini](<https://devfeed.tech/tags/mini.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [rust](<https://devfeed.tech/tags/rust.md>), [specifications](<https://devfeed.tech/tags/specifications.md>), [test](<https://devfeed.tech/tags/test.md>), [translation](<https://devfeed.tech/tags/translation.md>), [validation](<https://devfeed.tech/tags/validation.md>)

### AI overview

Across 300 IBM CodeNet programs evaluated with GPT-5.2 and GPT-4o-mini, code-only C-to-Rust translation had the highest test pass rate at 98.6%, but tended to preserve C implementation patterns. Specification-only translation produced more compact, idiomatic Rust, with about six times fewer unsafe blocks and 2.4 times fewer Clippy style warnings, but pass rates fell as low as 86% without validation. Iterative test-based validation and refinement raised specification-only performance to 95.3%. Combining source code and specifications achieved a 98.3% pass rate and the best balance of correctness and maintainability. The study also evaluated complexity and cost; the supplied abstract gives no specific results for those measures.

### Source excerpt

arXiv:2611.17581v1 Announce Type: new Abstract: Large language models (LLMs) have shown promising results for C-to-Rust translation, yet existing approaches primarily rely on source code as input, leaving natural-language specifications of program behavior underexplored as an alternative or complementary representation. We hypothesize that direct code translation encourages LLMs to preserve C-specific implementation choices, producing Rust that may be functionally correct but unnecessarily verbose, reliant on unsafe constructs, and less idiomatic. We investigate this hypothesis by comparing three translation settings: code-only, specification-only, and code-and-specification. Using 300 C programs from the IBM CodeNet dataset, we evaluate GPT-5.2 and GPT-4o-mini on functional correctness, maintainability, complexity, idiomaticity, unsafe construct usage, and cost. Code-only translation achieves the highest test pass rate (98.6%) but often mirrors C's implementation patterns. In contrast, specification-only translation produces the most idiomatic and compact Rust, reducing unsafe blocks by approximately 6x and Clippy style warnings by 2.4x. However, using specifications without validation yields test pass rates as low as 86% with our best performing model. Adding an iterative test-based validation and refinement step for specifications raises this to a 95.3% test pass rate. Overall, specification-based translation consistently improves code quality relative to code-only translation, while code-and-specification offers the best balance between correctness (98.3% test pass rate) and maintainability. Our study systematically compares these translation settings, highlighting the trade-offs among specification quality, translation correctness, code quality, and computational cost.

## Rust Leaves Top 10 in TIOBE Index, Making Room for Go

DevFeed: [Rust Leaves Top 10 in TIOBE Index, Making Room for Go](<https://devfeed.tech/articles/rust-leaves-top-10-in-tiobe-index-making-room-for-go-134466.md>)

Original publisher: [Read original article](<https://developers.slashdot.org/story/26/11/15/0710240/rust-leaves-top-10-in-tiobe-index-making-room-for-go>)

Author: EditorDavid

Published: 2026-11-15T15:34:00Z

Content type: news

Language: en

Sources: [Slashdot](<https://devfeed.tech/sources/slashdot.md>)

Topics: [Dart](<https://devfeed.tech/topics/dart.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Flutter](<https://devfeed.tech/topics/flutter.md>), [Visual Basic](<https://devfeed.tech/topics/visual-basic.md>), [Perl](<https://devfeed.tech/topics/perl.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-sharp](<https://devfeed.tech/tags/c-sharp.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [dart](<https://devfeed.tech/tags/dart.md>), [development](<https://devfeed.tech/tags/development.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [features](<https://devfeed.tech/tags/features.md>), [flutter](<https://devfeed.tech/tags/flutter.md>), [framework](<https://devfeed.tech/tags/framework.md>), [go](<https://devfeed.tech/tags/go.md>), [google](<https://devfeed.tech/tags/google.md>), [index](<https://devfeed.tech/tags/index.md>), [java](<https://devfeed.tech/tags/java.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [julia](<https://devfeed.tech/tags/julia.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tiobe](<https://devfeed.tech/tags/tiobe.md>), [top](<https://devfeed.tech/tags/top.md>)

### AI overview

In November's TIOBE Index, Go took the #10 spot from Rust, which fell to #11 despite its share rising from 1.44% to 1.63%; it remained above its #14 position a year earlier. Java moved back to #3 ahead of C++, though the excerpt says their difference was insignificant. Python led by a wide margin, and C ranked ahead of Java and C++. Dart entered the top 20 as Julia left; the excerpt attributes Dart's popularity mainly to Flutter and its cross-platform, single-codebase development ecosystem. R and SQL entered the top 10 as Visual Basic lost two places, while Assembly re-entered the top 20. The figures illustrate that small month-to-month share changes can shift rankings.

### Source excerpt

"In November's edition of the TIOBE Index, Rust has dropped out of Top 10," writes I-Programmer, noting that Rust ceded the #10 position to Go. "At the same time, another Google-originated language, Dart, has entered the top 20 ousting Julia after only one month." TIOBE explains Dart's popularity is mainly being driven by Flutter, Google's framework for building cross-platform mobile applications. In fact, Flutter has become one of the major technologies for cross-platform mobile app development. The Dart language itself is not particularly unique, although it incorporates many modern programming language features. Its success is largely driven by the strength of the Flutter ecosystem and the convenience of developing applications for multiple platforms using a single codebase... [In November's ranking] Visual Basic has also lost two places, making room for R and SQL in the Top 10. Further down the ranking, Assembly has re-entered the Top 20. So TIOBE ranks the top 10 languages in November as Python, C, Java, C++, C#, JavaScript, R, SQL, Visual Basic, and Go. But I-Programmer points out that "At the top of the table, Java is back in the top 3, after over three years in 4th position," pushing C++ down to #4. Are some changes more significant than others? If you think of the ratings as shares of a pie divided into 100 pieces, there is one huge slice -- Python, accounting for a over a fifth of the pie, then comes C with a slice slightly less than half of Python's. Java and C++ then have smaller slices... and C#'s share is around half of their average size. Over half the pie has now been shared between just five languages... -- Next 5 (#6-10): 10.17% (JavaScript, R, SQL, Visual Basic, Go) -- Next 10 (#11-20): 11.12% (Rust, PHP, Fortran, Scratch, Perl, MATLAB, Assembly, Swift, Delphi, Dart) -- Next 30 (#21-50): 12.81% -- Final 50 (#51-100): 12.93% [So in this month's chart...] Java has overtaken C++, but as you can see from this month's Top 10 chart they are in lock step and

## Rust 1.100.0 released

DevFeed: [Rust 1.100.0 released](<https://devfeed.tech/articles/rust-1-100-0-released-130796.md>)

Original publisher: [Read original article](<https://lwn.net/Articles/1107187/>)

Author: jzb

Published: 2026-11-12T19:09:19Z

Content type: release

Language: en

Sources: [LWN.net](<https://devfeed.tech/sources/lwn-net.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [changelog](<https://devfeed.tech/topics/changelog.md>)

Tags: [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

Rust 1.100.0 stabilizes the never type and core parts of the `Allocator` API, and adds Cargo reporting for unused dependencies. The supplied excerpt identifies these notable changes but does not detail their behavior or the other changes in the release.

### Source excerpt

Version 1.100.0 of the Rust language has been released. Notable changes include the stabilization of the never type, core parts of the Allocator API, reporting of unused dependencies in Cargo, and more.

## Rust 1.100 Released With The "Never" Type Finally Stable

DevFeed: [Rust 1.100 Released With The "Never" Type Finally Stable](<https://devfeed.tech/articles/rust-1-100-released-with-the-never-type-finally-stable-130854.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Rust-1.100-Released>)

Author: Michael Larabel

Published: 2026-11-12T18:51:12Z

Content type: release

Language: en

Sources: [Phoronix](<https://devfeed.tech/sources/phoronix.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [data type](<https://devfeed.tech/topics/data-type.md>)

Tags: [apis](<https://devfeed.tech/tags/apis.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency](<https://devfeed.tech/tags/dependency.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [feature](<https://devfeed.tech/tags/feature.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [linux-benchmarking](<https://devfeed.tech/tags/linux-benchmarking.md>), [linux-hardware-benchmarks](<https://devfeed.tech/tags/linux-hardware-benchmarks.md>), [linux-hardware-reviews](<https://devfeed.tech/tags/linux-hardware-reviews.md>), [linux-how-to](<https://devfeed.tech/tags/linux-how-to.md>), [linux-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [malicious-packages](<https://devfeed.tech/tags/malicious-packages.md>), [min](<https://devfeed.tech/tags/min.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stable](<https://devfeed.tech/tags/stable.md>), [type](<https://devfeed.tech/tags/type.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Rust 1.100 stabilizes the never type (`!`), used for computations that never produce a value, after ten years and five failed stabilization attempts. It also stabilizes core parts of the Allocator API and adds Cargo reporting for unused dependencies, work to reduce cache collisions, and a `min-publish-age` setting that can delay accepting recently published dependencies. The excerpt gives three to five days as example cooldown periods, noting that malicious packages may be detected soon after publication. It mentions other API stabilizations and improvements without describing them.

### Source excerpt

Rust 1.100 is out today as the newest version of this popular programming language...

## Announcing Rust 1.100.0

DevFeed: [Announcing Rust 1.100.0](<https://devfeed.tech/articles/announcing-rust-1-100-0-130818.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/>)

Author: The Rust Release Team

Published: 2026-11-12T00:00:00Z

Content type: release

Language: en

Sources: [Rust](<https://devfeed.tech/sources/rust-blog.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [project release](<https://devfeed.tech/topics/project-release.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [apis](<https://devfeed.tech/tags/apis.md>), [build](<https://devfeed.tech/tags/build.md>), [cache](<https://devfeed.tech/tags/cache.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [exit](<https://devfeed.tech/tags/exit.md>), [flow](<https://devfeed.tech/tags/flow.md>), [functions](<https://devfeed.tech/tags/functions.md>), [language](<https://devfeed.tech/tags/language.md>), [release](<https://devfeed.tech/tags/release.md>), [releases](<https://devfeed.tech/tags/releases.md>), [return](<https://devfeed.tech/tags/return.md>), [rust](<https://devfeed.tech/tags/rust.md>), [stabilization](<https://devfeed.tech/tags/stabilization.md>), [stable](<https://devfeed.tech/tags/stable.md>), [testing](<https://devfeed.tech/tags/testing.md>), [type](<https://devfeed.tech/tags/type.md>), [types](<https://devfeed.tech/tags/types.md>), [zero](<https://devfeed.tech/tags/zero.md>)

### AI overview

Rust 1.100.0 stabilizes the never type (`!`), allowing it to be named anywhere and making `Infallible` an alias; the change also alters never-type fallback to `!` in Rust 2015, 2018, and 2021, which may expose rare compatibility issues. The core `Allocator` API is stable for use with `Vec` and `Box`, with broader collection support still pending. New `core::mem::DropGuard` runs a closure when dropped and can roll back mutations unless dismissed, while unsafe `std::mem::conjure_zst` provides a dedicated way to create zero-sized values. Cargo now warns about unused dependencies, subject to build-target coverage limits, reorganizes build directories to apply configuration hashes consistently, and supports minimum package publish ages during dependency resolution. Publish-age filtering requires registry timestamps, does not apply to `cargo install`, and can be overridden for an individual update. Install the release with `rustup update stable`.

### Source excerpt

The Rust team is happy to announce a new version of Rust, 1.100.0. Rust is a programming language empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, you can get 1.100.0 with: $ rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.100.0. If you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across! What's in 1.100.0 stable Never type Allocator API DropGuard API Conjuring zero-sized types Reporting unused dependencies in Cargo Reducing Cargo cache collisions Cargo min-publish-age Stabilized APIs Never type After 10 years and 5 failed stabilization attempts, the never type is finally stable! This also completes the project goal for this work. The never type, spelled ! in code, is the canonical uninhabited type. It represents the type of diverging computations - computations which never resolve to any value - where any code that follows is unreachable. Expressions that terminate control flow, such as return, break, and std::process::exit, also have the type !. Since having a value of the never type is impossible, Rust permits a never-to-any coercion, allowing to turn ! into any other type (this is what distinguishes it from any other uninhabited types). This can be used, for example, to not return a value from one of the branches of a match or an if: fn mrrrow(option: Option<u32>) { let value = match option { // `x` has type `u32` Some(x) => x, // `return` has type `!`, which is then coerced to `u32`, // allowing the `match` to pass type checking. None => return, }; // ... } While the never type could already be used and observed this way, and even named in the return type of functions (-> !), this release allows naming the ne

## Angular's TypeScript 7-Powered Compiler Enters Beta with Rust-Based Preprocessor

DevFeed: [Angular's TypeScript 7-Powered Compiler Enters Beta with Rust-Based Preprocessor](<https://devfeed.tech/articles/angular-s-typescript-7-powered-compiler-enters-beta-with-rust-based-preprocessor-128002.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/angular-compiler-rust-typescript/>)

Author: Daniel Curtis

Published: 2026-11-11T07:06:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Angular](<https://devfeed.tech/topics/angular.md>), [TypeScript](<https://devfeed.tech/topics/typescript.md>), [Rust](<https://devfeed.tech/topics/rust.md>)

Tags: [22](<https://devfeed.tech/tags/22.md>), [adoption](<https://devfeed.tech/tags/adoption.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [angular](<https://devfeed.tech/tags/angular.md>), [angular-22](<https://devfeed.tech/tags/angular-22.md>), [angular-compiler](<https://devfeed.tech/tags/angular-compiler.md>), [angular-compiler-rust-typescript](<https://devfeed.tech/tags/angular-compiler-rust-typescript.md>), [angularjs](<https://devfeed.tech/tags/angularjs.md>), [api](<https://devfeed.tech/tags/api.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [beta](<https://devfeed.tech/tags/beta.md>), [builds](<https://devfeed.tech/tags/builds.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [development](<https://devfeed.tech/tags/development.md>), [news](<https://devfeed.tech/tags/news.md>), [ngc](<https://devfeed.tech/tags/ngc.md>), [oxc](<https://devfeed.tech/tags/oxc.md>), [production](<https://devfeed.tech/tags/production.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [transformer](<https://devfeed.tech/tags/transformer.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [typescript-7](<https://devfeed.tech/tags/typescript-7.md>), [typescript-7-0](<https://devfeed.tech/tags/typescript-7-0.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

Angular's ngp separates framework analysis from TypeScript's compiler APIs, which TypeScript 7.0 removed. Its Rust and Oxc frontend analyzes files in parallel, then Angular's existing template compiler emits runtime code and template type-checking files; downstream tools handle type-checking and JavaScript output. In benchmarks across three projects, beta cold builds were 2-3x faster, and memory use on the largest project fell from 2.8 GB to 1.4 GB. `tsrs` with Rolldown was fastest, while `tsgo` with esbuild was only marginally slower. A prototype Vite plugin also showed faster startup and template updates, but is pinned to a prerelease and described as a prototype. The text says `ngp` adoption is expected in an Angular 22 minor release; production builds should remain on `ngc` until then, and earlier Angular projects should first update to v20 or later.

### Source excerpt

The Angular team has introduced ngp, a compiler preprocessor that rewrites the analysis stage in Rust using Oxc. It replaces ngc's dependence on the Transformer API, which TypeScript 7.0 removed. An early benchmark showed 2x to 3x faster cold builds. Adoption is expected in an Angular 22 minor release; production builds should stay on ngc until then. By Daniel Curtis

## Microsoft's AI bug hunter finds Rust flaw that went undetected for nearly 11 years

DevFeed: [Microsoft's AI bug hunter finds Rust flaw that went undetected for nearly 11 years](<https://devfeed.tech/articles/microsoft-s-ai-bug-hunter-finds-rust-flaw-that-went-undetected-for-nearly-11-years-126609.md>)

Original publisher: [Read original article](<https://www.infoworld.com/article/4246801/microsofts-ai-bug-hunter-finds-rust-flaw-that-went-undetected-for-nearly-11-years-2.html>)

Author: Gyana Swain

Published: 2026-11-10T12:40:31Z

Content type: news

Language: en

Sources: [InfoWorld](<https://devfeed.tech/sources/infoworld.md>)

Topics: [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Agentic AI](<https://devfeed.tech/topics/what-is-agentic-ai.md>), [bug](<https://devfeed.tech/topics/bug.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-powered](<https://devfeed.tech/tags/ai-powered.md>), [api](<https://devfeed.tech/tags/api.md>), [applications](<https://devfeed.tech/tags/applications.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [blog](<https://devfeed.tech/tags/blog.md>), [blog-post](<https://devfeed.tech/tags/blog-post.md>), [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [code-security](<https://devfeed.tech/tags/code-security.md>), [code-security-programming-languages-security-software-development](<https://devfeed.tech/tags/code-security-programming-languages-security-software-development.md>), [codename](<https://devfeed.tech/tags/codename.md>), [discovery](<https://devfeed.tech/tags/discovery.md>), [exit](<https://devfeed.tech/tags/exit.md>), [exploitation](<https://devfeed.tech/tags/exploitation.md>), [forge](<https://devfeed.tech/tags/forge.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [programming-languages](<https://devfeed.tech/tags/programming-languages.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [storytype-news](<https://devfeed.tech/tags/storytype-news.md>)

### AI overview

Microsoft researchers used Hyenas, an AI-powered scanner, to help find flaws in Rust's standard library, then manually examined and reproduced the issues, assessed their impact, and reported them to Rust maintainers. One flaw in process::exit could remove the main thread's alternate signal stack when called from a child thread; a later stack overflow might then cause a segmentation fault instead of Rust's intended handling. Other findings involved panic safety in MapWindows::clone, invalid UTF-8 from a custom nightly Pattern implementation in str::replace, and CommandExt::exec modifying shared environment state under a read lock, potentially leaving a pointer to freed memory. The process::exit and CommandExt::exec issues affect stable Rust; a proposed fix for the latter was under review. Microsoft said the flaws require unusual conditions and found no reliable exploitation path for the signal-stack bug. The supplied text describes these findings and related security systems but does not include the full article.

### Source excerpt

Microsoft researchers have uncovered a memory-safety bug in Rust's standard library that had gone undetected for nearly 11 years, alongside other flaws that can trigger undefined behavior even in applications written entirely in safe Rust. Two of the findings affect stable Rust, including a separate issue that could cause applications to access freed memory. The nearly 11-year-old bug involves Rust's process::exit function. Microsoft's FORGE Lab researchers found that calling the function from a child thread could cause the runtime to remove the main thread's alternate signal stack while it was still running. If the main thread subsequently experienced a stack overflow, the operating system could be unable to deliver the signal correctly, resulting in a segmentation fault instead of Rust's intended stack-overflow handling. "The process::exit signal stack bug was in the standard library for nearly 11 years," the researchers wrote in a blog post. Microsoft said the researchers found no reliable exploitation path under the conditions they examined and assessed practical exploitation as unlikely. The research used Hyenas, FORGE Lab's AI-powered vulnerability-scanning system, to investigate unsafe code in Rust's standard library. Hyenas is the lab's research version of codename MDASH, Microsoft's agentic vulnerability-discovery system. Microsoft said some of the bugs were found with help from Hyenas. Researchers then examined the underlying code, reproduced the issues, assessed their security impact, and reported them to Rust maintainers. Microsoft said the practical risk is limited. Each flaw requires unusual conditions to trigger, and a bug in the standard library becomes "a serious vulnerability only if a real program reaches the API in that way," the researchers wrote. Unsafe code challenges Rust's safety guarantees Rust's ownership model and type system are designed to prevent memory-safety problems commonly associated with languages such as C and C++. However, its

## Debugging Rust in 2026

DevFeed: [Debugging Rust in 2026](<https://devfeed.tech/articles/debugging-rust-in-2026-127492.md>)

Original publisher: [Read original article](<https://blog.jetbrains.com/rust/2026/11/10/debugging-rust/>)

Author: Orhun Parmaksiz

Published: 2026-11-10T10:57:58Z

Content type: article

Language: en

Sources: [JetBrains](<https://devfeed.tech/sources/the-jetbrains-blog.md>)

Topics: [debug tools](<https://devfeed.tech/topics/debug-tools.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [rustrover](<https://devfeed.tech/topics/rustrover.md>), [gdb](<https://devfeed.tech/topics/gdb.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [ide](<https://devfeed.tech/topics/ide.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-assisted-debugging](<https://devfeed.tech/tags/ai-assisted-debugging.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [async](<https://devfeed.tech/tags/async.md>), [berlin](<https://devfeed.tech/tags/berlin.md>), [breakpoint](<https://devfeed.tech/tags/breakpoint.md>), [bug](<https://devfeed.tech/tags/bug.md>), [cargo](<https://devfeed.tech/tags/cargo.md>), [claude](<https://devfeed.tech/tags/claude.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [cmp](<https://devfeed.tech/tags/cmp.md>), [code](<https://devfeed.tech/tags/code.md>), [codex](<https://devfeed.tech/tags/codex.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

The Graham scan example shows the same Rust bug--points sharing a polar angle were sorted farthest-first--debugged four ways. `println!`, `dbg!` or `tracing` can expose intermediate ordering and work well for small programs, but require repeated recompilation and test runs. `rust-gdb` and `rust-lldb` let developers set breakpoints and inspect runtime values without changing source, though the workflow requires choosing breakpoints and debugger commands. RustRover offers a graphical GDB/LLDB interface for debugging tests, with breakpoints, stepping, watches and expression evaluation; the article says it lowers Rust expressions to MIR for evaluation in a paused process. As a bonus, RustRover 2026.3's MCP server can expose debugging actions to agents, which can run sessions, inspect variables and suggest or apply fixes. The author presents AI as a debugging aid, not a debugger replacement. The excerpt also reports survey figures: 53.2% do not use a debugger, while debugger use rose from 36% in 2021 to 46.8% in 2026.

### Source excerpt

Rust is a great language for many reasons: safety, performance and tooling. However, debugging is maybe one of the weakest points still. Interestingly enough, the Rust debugging survey 2026 results show that the majority (53.2%) of Rust users don't use a debugger at all. Many Rust developers (81.3%) say that prints are simply easier/faster. The [...]

## CRUSTPairs: A Cross-Language Dataset of Paired C and Rust Solutions

DevFeed: [CRUSTPairs: A Cross-Language Dataset of Paired C and Rust Solutions](<https://devfeed.tech/articles/crustpairs-a-cross-language-dataset-of-paired-c-and-rust-solutions-125437.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.11711>)

Author: Vojtech Hejlek, Leonardo Jesus Almeida, Alneu de Andrade Lopes

Published: 2026-11-10T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>), [arXiv: Software Engineering](<https://devfeed.tech/sources/arxiv-software-engineering.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [dpo](<https://devfeed.tech/topics/dpo.md>), [cosine similarity search](<https://devfeed.tech/topics/cosine-similarity-search.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [embedding](<https://devfeed.tech/tags/embedding.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [migration](<https://devfeed.tech/tags/migration.md>), [model](<https://devfeed.tech/tags/model.md>), [mrr](<https://devfeed.tech/tags/mrr.md>), [pairs](<https://devfeed.tech/tags/pairs.md>), [retrieval](<https://devfeed.tech/tags/retrieval.md>), [rust](<https://devfeed.tech/tags/rust.md>), [similarity](<https://devfeed.tech/tags/similarity.md>), [tf](<https://devfeed.tech/tags/tf.md>)

### AI overview

CRUSTPairs provides 1,857 paired C and Rust solutions to shared programming problems, drawn from competitive programming archives and normalized, deduplicated, tiered by zero-shot embedding similarity, and accompanied by provenance and licensing. In cross-language retrieval, TF-IDF over shared identifiers achieves MRR 0.21, slightly above a pretrained code model's 0.19; that model performs at 1.7 times chance on the hardest quarter. Fine-tuning reaches 0.79 overall and improves hardest-quarter performance to 10 times chance. When user identifiers are renamed, fine-tuned models retain 96-97% of their accuracy, compared with 66% for the pretrained model. On structurally divergent pairs, fine-tuned models do better without identifiers than with them.

### Source excerpt

arXiv:2611.11711v1 Announce Type: cross Abstract: C-to-Rust migration is an active agenda, but no dataset pairs the two languages at the level of whole solutions to a shared problem. We present CRUSTPairs, 1857 C/Rust implementation pairs drawn from competitive programming archives, normalised, deduplicated, and stratified into difficulty tiers by zero-shot cross-language embedding similarity, with perrecord provenance and licensing. Cross-language retrieval is hard on this data, and harder than a single baseline would suggest: TF-IDF over shared identifiers reaches MRR 0.21 and so beats a pretrained code model at 0.19, which on the hardest quarter of the data scores 1.7x chance. Finetuning reaches 0.79, and lifts that hardest quarter 10x. Renaming every user identifier settles what is being learned: the finetuned models keep 96-97% of their accuracy without them, while the pretrained model keeps 66\% - less than the lexical baseline does - and on structurally divergent pairs the finetuned models are better without identifiers than with them.

## Announcing beam-init - a Rust init process for agents

DevFeed: [Announcing beam-init - a Rust init process for agents](<https://devfeed.tech/articles/announcing-beam-init-a-rust-init-process-for-agents-126529.md>)

Original publisher: [Read original article](<https://goteleport.com/blog/announcing-beam-init/>)

Author: carson.anderson@goteleport.com (Carson Anderson)

Published: 2026-11-10T00:00:00Z

Content type: release

Language: en

Sources: [Teleport](<https://devfeed.tech/sources/teleport.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [agentic workflows](<https://devfeed.tech/topics/agentic-workflows.md>), [audit](<https://devfeed.tech/topics/audit.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-ai](<https://devfeed.tech/tags/agentic-ai.md>), [agentic-workflows](<https://devfeed.tech/tags/agentic-workflows.md>), [agents](<https://devfeed.tech/tags/agents.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [beam](<https://devfeed.tech/tags/beam.md>), [containers](<https://devfeed.tech/tags/containers.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [init](<https://devfeed.tech/tags/init.md>), [lightweight](<https://devfeed.tech/tags/lightweight.md>), [manager](<https://devfeed.tech/tags/manager.md>), [process](<https://devfeed.tech/tags/process.md>), [rust](<https://devfeed.tech/tags/rust.md>), [service](<https://devfeed.tech/tags/service.md>)

### AI overview

beam-init is a lightweight Rust init process and service manager for containers, microVMs, and agent workflows. It reaps child processes and exposes an API for inspecting service state and recent logs, stopping processes, freezing execution, and thawing services. It can allocate a pseudoterminal for a service's lifetime so interactive applications can be reconnected to after a network disconnection. The authors say systemd was unsuitable for their Kubernetes deployment because it required a privileged security context and CAP_SYS_ADMIN; s6-overlay's service-definition and command-line focus did not fit their needs. They designed beam-init for a small footprint, API-based management, and memory safety, with minimal dependencies. A Doyensec audit rated findings medium severity or lower, mostly denial-of-service issues, with some related to insufficiently sanitized input.

### Source excerpt

Introducing beam-init, a lightweight Rust init process and service manager for containers, microVMs, and agentic workflows.

[Next page](<https://devfeed.tech/topics/rust.md?cursor=WyIyMDI2LTExLTEwVDAwOjAwOjAwKzAwOjAwIiwgIjg5YzY5YjUzLTc3ZGYtNDZmYy1hMDBjLWEzNjcxM2NiZDk4NCJd>)