# Memory Safety

Published articles for Memory Safety.

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

## Ubuntu 26.10 Moves cp, mv & rm Over To Rust Coreutils For 100% Transition

DevFeed: [Ubuntu 26.10 Moves cp, mv & rm Over To Rust Coreutils For 100% Transition](<https://devfeed.tech/articles/ubuntu-26-10-moves-cp-mv-rm-over-to-rust-coreutils-for-100-transition-31412.md>)

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

Author: Michael Larabel

Published: 2026-09-16T12:26:49Z

Content type: news

Language: en

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

Topics: [Ubuntu](<https://devfeed.tech/topics/ubuntu.md>), [Bevy](<https://devfeed.tech/topics/bevy.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>)

Tags: [commands](<https://devfeed.tech/tags/commands.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.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-performance](<https://devfeed.tech/tags/linux-performance.md>), [linux-server-benchmarks](<https://devfeed.tech/tags/linux-server-benchmarks.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.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>), [ubuntu](<https://devfeed.tech/tags/ubuntu.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Ubuntu 26.10 completes its transition from GNU Coreutils to Rust Coreutils, with the cp, mv, and rm commands now provided by the Rust-based project. Earlier Ubuntu releases had delayed this change because of compatibility issues.

### Source excerpt

While Ubuntu Linux has been making use of the Rust Coreutils project over the past year since Ubuntu 25.10 as an alternative to GNU Coreutils and part of their effort to get more system components implemented in the memory-safety-focused Rust programming language, Ubuntu 26.10 finally completes the transition with the cp, mv, and rm commands now coming from Rust Coreutils...

## Swift 6.4 Released

DevFeed: [Swift 6.4 Released](<https://devfeed.tech/articles/swift-6-4-released-26971.md>)

Original publisher: [Read original article](<https://swift.org/blog/swift-6.4-released/>)

Author: Holly Borla

Published: 2026-09-15T07:30:00Z

Content type: release

Language: en

Sources: [Swift.org](<https://devfeed.tech/sources/swift-org.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>), [browser](<https://devfeed.tech/topics/browser.md>), [Microcontroller](<https://devfeed.tech/topics/microcontroller.md>)

Tags: [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [errors](<https://devfeed.tech/tags/errors.md>), [libraries](<https://devfeed.tech/tags/libraries.md>), [linux](<https://devfeed.tech/tags/linux.md>), [macos](<https://devfeed.tech/tags/macos.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [programming](<https://devfeed.tech/tags/programming.md>), [swift](<https://devfeed.tech/tags/swift.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

Swift 6.4 is now available with Swift Build as the default in Swift Package Manager, a stable cross-platform Subprocess API, expanded C++20 and Java interoperability, faster WebAssembly support, broader embedded Swift capabilities, and performance improvements that maintain memory safety.

### Source excerpt

Swift 6.4 is now available. Swift aims to be a great choice across the stack, from apps and servers to systems code, embedded devices, and the browser. This release deepens that support, and makes everyday code easier to write. Highlights include: Swift Build is now the default in Swift Package Manager, so your projects build the same way on Linux, macOS, and Windows. Subprocess reaches 1.0, a stable, cross-platform way to run and interact with other programs from Swift, from command-line tools to streaming processes. Interoperability reaches further, with Swift's Span now bridging directly with C++20's std::span, and Swift/Java interop extending its async and callback support. Swift runs faster in the browser, with WebAssembly bridging through JavaScriptKit up to 40 times faster, and the Wasm SDK available directly from Swift.org. Embedded Swift grows more capable, with support for existential types and richer error handling for microcontroller-class targets. Performance improves while maintaining memory safety, with new array types that hold non-copyable elements without copy-on-write overhead, and the new Iterable protocol for iterating without copies. There's so much more. Read on for a detailed guide to the new changes, or see the Swift Evolution dashboard for the full list of proposals in Swift 6.4. Simpler and clearer code Swift 6.4 streamlines your day-to-day programming to make your code simpler and clearer. More natural optional some and any types. When writing an optional some or any type, you no longer have to wrap the type in parentheses. Instead of (some Rocket)?, you can simply write some Rocket? (SE-0521). Source-level control over compiler warnings. When you need to control the behavior of warnings in your project, such as suppressing warnings or promoting them to errors, you can now define the warning behavior directly in your code using the new @diagnose attribute (SE-0522). Clarify which API to use when multiple libraries conflict. When multiple

## One Decade of Rustls: Evolution, Benchmarks, and Future Roadmap

DevFeed: [One Decade of Rustls: Evolution, Benchmarks, and Future Roadmap](<https://devfeed.tech/articles/one-decade-of-rustls-evolution-benchmarks-and-future-roadmap-8458.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/09/rustls-one-decade/>)

Author: Olimpiu Pop

Published: 2026-09-12T07:07:00Z

Content type: news

Language: en

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

Topics: [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Security, Privacy and Abuse Prevention](<https://devfeed.tech/topics/security-privacy-and-abuse-prevention.md>), [interoperability](<https://devfeed.tech/topics/interoperability.md>), [Refactoring](<https://devfeed.tech/topics/refactoring.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [development](<https://devfeed.tech/tags/development.md>), [memory-leaks](<https://devfeed.tech/tags/memory-leaks.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [release](<https://devfeed.tech/tags/release.md>), [retrospective](<https://devfeed.tech/tags/retrospective.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rustls-one-decade](<https://devfeed.tech/tags/rustls-one-decade.md>), [security](<https://devfeed.tech/tags/security.md>), [tls](<https://devfeed.tech/tags/tls.md>)

### AI overview

Rustls marks its tenth anniversary with a retrospective on its growth, funding, security work, and performance. The article compares Rustls 0.23.37 with OpenSSL and BoringSSL and notes architectural changes planned for version 0.24.

### Source excerpt

Rustls, a Rust TLS library, marks its decade-long progression from a grassroots project to a funded open-source initiative. Key contributions from organisations boosted development, resulting in features like post-quantum cryptography and robust performance. The upcoming 0.24 release aims to enhance architecture and flexibility, including new input buffering and improved session handling By Olimpiu Pop

## A "proof" of Fermat's Last Theorem that fits the margin

DevFeed: [A "proof" of Fermat's Last Theorem that fits the margin](<https://devfeed.tech/articles/a-proof-of-fermat-s-last-theorem-that-fits-the-margin-7665.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/09/09/a-proof-of-fermats-last-theorem-that-fits-the-margin/>)

Author: "Marc Ilunga"

Published: 2026-09-09T11:00:00Z

Content type: article

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Lean](<https://devfeed.tech/topics/lean.md>), [bug](<https://devfeed.tech/topics/bug.md>), [Memory safety verification](<https://devfeed.tech/topics/memory-safety-verification.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [exploits](<https://devfeed.tech/tags/exploits.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [vulnerability-disclosure](<https://devfeed.tech/tags/vulnerability-disclosure.md>)

### AI overview

A Lean string-slicing bug caused its logical evaluator and compiled native code to disagree, allowing a contradiction that could make an invalid proof appear checked. The issue was fixed after disclosure.

### Source excerpt

Fermat famously claimed to have a "truly marvelous proof" of his Last Theorem, but he never wrote it down, insisting the margin of his page was too narrow to contain it. A few centuries later, Anthropic announced a complete formalization of Fermat's Last Theorem using 13 million lines of Lean code (clearly not what Fermat intended). Luckily, we found a wonderfully cursed Lean bug, shown below, that suggests the proof may have fit the margin after all. The issue affects all stable versions of Lean up to 4.33.1, and the patch is incorporated in v4.34.0-rc1. A "checked" proof of Fermat's Last Theorem using Lean 4.33.1 The blue checkmarks in the screenshot above would suggest that Lean considers this proof correct. This seems odd given the amount of work Sir Andrew Wiles put into this problem and the vast size of Claude's proof. So what is going on? The "proof" clearly doesn't make any sense and exploits an issue in Lean. We found the issue while using GPT-5.6 to experiment with a new skill for code review. We want to clarify up front that the issue is not a kernel soundness issue, but it happens to nicely fit any discussion of strings, lengths, and substrings. The issue affects String.Pos.Raw.extract, Lean's low-level string-slicing function. When asked to extract a one-byte slice at an astronomically large position, Lean's logical definition returns the empty string. But the compiled native code returns the entire original string. That disagreement is enough to manufacture a contradiction. Lean's ordinary evaluator "proves" that the tiny slice was empty, while native evaluation "proves" that the very same slice contained "a truly marvelous proof." Put those together, and Lean concludes that the empty string equals a non-empty string. And once you have a contradiction, you can prove anything, including Fermat's Last Theorem. On the bright side, the Lean team was considerably faster than mathematical history. About 90 minutes after we reported the issue, hargoniX opened

## Verifying Rust cryptography in SymCrypt, from standards to code

DevFeed: [Verifying Rust cryptography in SymCrypt, from standards to code](<https://devfeed.tech/articles/verifying-rust-cryptography-in-symcrypt-from-standards-to-code-6810.md>)

Original publisher: [Read original article](<https://www.microsoft.com/en-us/research/blog/verifying-rust-cryptography-in-symcrypt-from-standards-to-code/>)

Author: Son Ho, Cédric Fournet, Antoine Delignat-Lavaud, Samuel Lee, Jason Fisher, Jessica Krynitsky

Published: 2026-07-13T16:00:00Z

Content type: article

Language: en

Sources: [Microsoft Research](<https://devfeed.tech/sources/microsoft-research.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Rust formal verification](<https://devfeed.tech/topics/rust-formal-verification.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Formal verification](<https://devfeed.tech/topics/formal-verification.md>), [Post-quantum cryptography](<https://devfeed.tech/topics/post-quantum-cryptography.md>), [Lean](<https://devfeed.tech/topics/lean.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [Microsoft](<https://devfeed.tech/topics/microsoft.md>)

Tags: [cryptography](<https://devfeed.tech/tags/cryptography.md>), [formal-verification](<https://devfeed.tech/tags/formal-verification.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [post-quantum](<https://devfeed.tech/tags/post-quantum.md>), [research](<https://devfeed.tech/tags/research.md>), [research-blog](<https://devfeed.tech/tags/research-blog.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

Microsoft Research describes how SymCrypt uses safe Rust, Lean, and the Aeneas toolchain to formally verify production cryptographic implementations. The approach combines Rust's memory-safety guarantees with machine-checked proofs of functional correctness, with initial verified code for SHA-3 and ML-KEM and support from independently verifiable proof-writing agents.

### Source excerpt

Cryptographic code supports vital protections in modern computing systems. Learn how a new method helps verify code as developers write it while preserving speed and adaptability as it gets implemented and evolves. The post Verifying Rust cryptography in SymCrypt, from standards to code appeared first on Microsoft Research.

## Rust-proof your code with our new Testing Handbook chapter

DevFeed: [Rust-proof your code with our new Testing Handbook chapter](<https://devfeed.tech/articles/rust-proof-your-code-with-our-new-testing-handbook-chapter-7658.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/07/13/rust-proof-your-code-with-our-new-testing-handbook-chapter/>)

Author: "Paweł Płatek"

Published: 2026-07-13T11:00:00Z

Content type: tutorial

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Security](<https://devfeed.tech/topics/security.md>), [mutation-testing](<https://devfeed.tech/topics/mutation-testing.md>), [Tooling](<https://devfeed.tech/topics/tooling.md>), [Test coverage](<https://devfeed.tech/topics/coverage.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust formal verification](<https://devfeed.tech/topics/rust-formal-verification.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [Claude](<https://devfeed.tech/topics/claude.md>)

Tags: [application-security](<https://devfeed.tech/tags/application-security.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mutation-testing](<https://devfeed.tech/tags/mutation-testing.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [testing](<https://devfeed.tech/tags/testing.md>), [testing-handbook](<https://devfeed.tech/tags/testing-handbook.md>), [tooling](<https://devfeed.tech/tags/tooling.md>)

### AI overview

A new Testing Handbook chapter presents techniques for security testing Rust programs and systems. It covers Rust security limitations, dynamic and static analysis, undefined-behavior detection with Miri, property testing, coverage and mutation testing, Clippy, manual code review, memory zeroization, model checking with Kani, and dependency supply-chain vetting. The article also announces rust-review, a Claude Code plugin for automated Rust security reviews.

### Source excerpt

We've added a new chapter to our Testing Handbook: a comprehensive guide to security testing Rust programs. This chapter covers the tools and techniques we use at Trail of Bits to validate the security of Rust programs and systems. fn main() {(|f:&dyn Fn(u128)->Box< dyn Iterator<Item= char>+'static>|f(*[&( 0x7B736D70683F73u128<<64| 0x7A6A6D7C3F7A667D),&(0x7B736Du128 <<64|0x70683F7073737A77)][((std::hint:: black_box(0.0f64)/0.0).to_bits()>>63)as usize]) .for_each(|c|print!("{c}")))(Box::leak(Box::new(|n: u128|Box::new(std::iter::successors(Some(n),|&n|Some(n>>8) ).take_while(|&n|n>0).map(|n|((n as u8)^0x1F)as char))as _)))} What's in the chapter The chapter starts with a security overview of what Rust's guarantees do and don't cover, including underappreciated issues like unwind safety, nondeterminism, and arithmetic errors. This leads into an overview of dynamic analysis, which covers a range of boosters for unit tests, how to use Miri to detect undefined behavior, property testing with proptest, coverage measurement, and mutation testing. The static analysis section then covers Clippy in depth, including a list of our favorite lints. Beyond tooling, the chapter also covers what we've learned from auditing Rust codebases directly. Our gotchas and footguns checklist is a great reference for manual code reviews, and will help you find subtle issues like a & b == c having different operator precedence than in C. The memory zeroization section offers three solutions to the tricky problem of guaranteeing that secrets are erased from memory. Finally, the specialized testing sections cover tools like Kani (a model checker), and the supply chain section covers the full toolchain for vetting dependencies. Still oxidizing We've also released rust-review, a Claude Code plugin for automated Rust security reviews. Co-built with Aptos Labs, it targets over a dozen bug classes, from memory safety and concurrency hazards to FFI pitfalls and async cancellation issues. It's a fast wa

## May in Servo: user scripts, mp4 compat, blackboxing in DevTools, and more!

DevFeed: [May in Servo: user scripts, mp4 compat, blackboxing in DevTools, and more!](<https://devfeed.tech/articles/may-in-servo-user-scripts-mp4-compat-blackboxing-in-devtools-and-more-3545.md>)

Original publisher: [Read original article](<https://servo.org/blog/2026/06/30/may-in-servo/>)

Author: The Servo Project Developers

Published: 2026-06-30T00:00:00Z

Content type: release

Language: en

Sources: [Servo Blog](<https://devfeed.tech/sources/servo-blog.md>)

Topics: [servo](<https://devfeed.tech/topics/servo.md>), [Web platform](<https://devfeed.tech/topics/web-platform.md>), [Document Object Model (DOM)](<https://devfeed.tech/topics/dom.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [API](<https://devfeed.tech/topics/api.md>), [Security](<https://devfeed.tech/topics/security.md>), [Forms](<https://devfeed.tech/topics/forms.md>), [Accessibility](<https://devfeed.tech/topics/accessibility.md>), [Nix](<https://devfeed.tech/topics/nix.md>), [webgpu](<https://devfeed.tech/topics/webgpu.md>)

Tags: [developers](<https://devfeed.tech/tags/developers.md>), [forms](<https://devfeed.tech/tags/forms.md>), [html](<https://devfeed.tech/tags/html.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [servo](<https://devfeed.tech/tags/servo.md>), [servo-engine](<https://devfeed.tech/tags/servo-engine.md>), [servo-rendering-engine](<https://devfeed.tech/tags/servo-rendering-engine.md>), [web-browser](<https://devfeed.tech/tags/web-browser.md>), [web-browser-engine](<https://devfeed.tech/tags/web-browser-engine.md>), [web-engine](<https://devfeed.tech/tags/web-engine.md>), [web-platform](<https://devfeed.tech/tags/web-platform.md>), [web-rendering-engine](<https://devfeed.tech/tags/web-rendering-engine.md>), [webgpu](<https://devfeed.tech/tags/webgpu.md>), [windows](<https://devfeed.tech/tags/windows.md>)

### AI overview

Servo 0.3.0 summarizes 391 commits made in May, adding web platform and DOM API support, improving forms and media compatibility, and fixing build issues on Windows, FreeBSD, and Nix environments. The release also includes memory safety fixes through a SpiderMonkey update, experimental Sanitizer improvements, IndexedDB changes, DevTools work, and ongoing WebGPU, accessibility, and performance development.

### Source excerpt

Servo 0.3.0 contains all of the changes we landed in May, which came out to 391 commits (April: 534). For security fixes, see § Security. We've shipped several new web platform features: 'font-kerning: none' (@simonwuelker, #44634) 'font-variant-east-asian' (@simonwuelker, #44989) 'font-variant-ligatures' (@simonwuelker, #44903) 'font-variant-numeric' (@simonwuelker, #44950) 'font-variant-position' (@simonwuelker, #45142) mp4 files without fast start in <video> (@calvaris, #45084) <form enctype="multipart/form-data"> (@yezhizhen, #45028) <form enctype="text/plain"> (@yezhizhen, #45111) <![CDATA[]]> layout (@mrobinson, #44791) Plus a bunch of new DOM APIs: onslotchange property on ShadowRoot (@jdm, #44688) screenLeft and screenTop on Window (@TG199, #45128) new Blob() with {endings: "native"} (@yezhizhen, #44803) new PerformanceMark() (@shubhamg13, #44702) parseHTML() on Document (@kkoyung, #44952) readAsBinaryString() on FileReader (@yezhizhen, #44858, #44921) performance.measure() with mark values 'redirectStart', 'redirectEnd', 'secureConnectionStart', and 'responseEnd' (@shubhamg13, #44673, #44624, #44850, #44739) We've also fixed some build issues on Windows (@mukilan, #45079), FreeBSD (@delan, @mrobinson, @mukilan, #44600), and for anyone building Servo on NixOS or with Nix (@freyacodes, #45051, #45135). This is another big update, so here's an outline: Security - memory safety fixes Work in progress - execCommand(), Sanitizer, IndexedDB, accessibility, workers Embedding API - MSRV, cookies, preferences, diagnostics For users and developers - --host-file, --userscripts, DevTools Debugger More on the web platform - focus, forms, navigation, SubtleCrypto, WebGPU Performance - about:memory, threads, layout, DOM, build times Stability - crashes, hangs, static analysis Security Servo's JS runtime, SpiderMonkey 140.10.0, had several memory safety bugs that have been fixed in Servo 0.3.0 with the update to SpiderMonkey 140.10.1 (@jschwe, #44755). For mor

## Swift at Apple: Migrating the TrueType Hinting Interpreter

DevFeed: [Swift at Apple: Migrating the TrueType Hinting Interpreter](<https://devfeed.tech/articles/swift-at-apple-migrating-the-truetype-hinting-interpreter-2932.md>)

Original publisher: [Read original article](<https://swift.org/blog/migrating-truetype-hinting-to-swift/>)

Author: Scott Perry

Published: 2026-06-12T10:00:00Z

Content type: article

Language: en

Sources: [Swift.org](<https://devfeed.tech/sources/swift-org.md>)

Topics: [Swift](<https://devfeed.tech/topics/swift.md>), [Font](<https://devfeed.tech/topics/font.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [Memory safety verification](<https://devfeed.tech/topics/memory-safety-verification.md>), [Web](<https://devfeed.tech/topics/web.md>), [pdf](<https://devfeed.tech/topics/pdf.md>)

Tags: [apple](<https://devfeed.tech/tags/apple.md>), [applications](<https://devfeed.tech/tags/applications.md>), [code](<https://devfeed.tech/tags/code.md>), [fonts](<https://devfeed.tech/tags/fonts.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [performance](<https://devfeed.tech/tags/performance.md>), [security](<https://devfeed.tech/tags/security.md>), [swift](<https://devfeed.tech/tags/swift.md>), [web](<https://devfeed.tech/tags/web.md>)

### AI overview

Apple describes rewriting its TrueType hinting interpreter from C to memory-safe Swift for Fall 2025 releases. The rewrite addresses the security risks of processing untrusted fonts and reportedly improves performance by 13% on average.

### Source excerpt

TrueType is a widely used vector font standard for rendering text in web pages, PDFs, operating systems, and applications. Familiar fonts like Helvetica, Garamond, and Monaco are all built on TrueType outlines. The format specifies a hinting interpreter intended to help outlines rasterize faithfully on low-resolution displays. Modern high-resolution displays enable beautiful typography from outlines alone, but TrueType fonts that need hinting to render legibly remain in use and we continue to support them. Font parsers process data from untrusted sources, making the TrueType hinting interpreter a security-critical attack surface. To make the format more resilient on Apple platforms, we rewrote its hinting interpreter from C to memory-safe Swift for the Fall 2025 releases. In addition to memory safety, we also improved performance: on average, our Swift interpreter runs 13% faster than the C interpreter it replaced. To accompany this post, we've also published the source code of the Swift TrueType hinting interpreter. We hope sharing our experience helps others doing similar work in Swift. TrueType and the hinting engine Apple developed TrueType in the late 1980s and released it with the launch of System 7 in 1991. TrueType was a major breakthrough for the time: it gave font developers enormous control over how glyphs are displayed, with an advanced grid-fitting algorithm and a sophisticated hinting engine built around a special-purpose bytecode interpreter. TrueType did all this on computers that were vastly less powerful than today's, so it had to be extremely well-tuned for performance. Then the internet revolutionized how fonts were used. TrueType became embeddable in PDF files in 1994 and in web pages in 2008, and it remains as relevant as ever. However, these new use cases brought additional risk: TrueType could now be exposed to untrusted fonts from anywhere on the internet. TrueType fonts may contain programs the hinting engine runs through a bytecode interpr

## We beat Google's zero-knowledge proof of quantum cryptanalysis

DevFeed: [We beat Google's zero-knowledge proof of quantum cryptanalysis](<https://devfeed.tech/articles/we-beat-google-s-zero-knowledge-proof-of-quantum-cryptanalysis-7646.md>)

Original publisher: [Read original article](<https://blog.trailofbits.com/2026/04/17/we-beat-googles-zero-knowledge-proof-of-quantum-cryptanalysis/>)

Author: "Keegan Ryan"

Published: 2026-04-17T11:00:00Z

Content type: article

Language: en

Sources: [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog.md>), [The Trail of Bits Blog](<https://devfeed.tech/sources/the-trail-of-bits-blog-2.md>)

Topics: [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Google](<https://devfeed.tech/topics/google.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Code](<https://devfeed.tech/topics/code.md>), [Ethereum](<https://devfeed.tech/topics/ethereum.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [google](<https://devfeed.tech/tags/google.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [quantum](<https://devfeed.tech/tags/quantum.md>), [rust](<https://devfeed.tech/tags/rust.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

Trail of Bits presents a zero-knowledge proof that improves on Google's reported resource bounds for quantum circuits. The article attributes the result to memory-safety and logic vulnerabilities in Google's Rust prover code, explains the zkVM-based proof setup, and describes the released proof-forging code.

### Source excerpt

Two weeks ago, Google's Quantum AI group published a zero-knowledge proof of a quantum circuit so optimized, they concluded that first-generation quantum computers will break elliptic curve cryptography keys in as little as 9 minutes. Today, Trail of Bits is publishing our own zero-knowledge proof that significantly improves Google's on all metrics. Our result is not due to some quantum breakthrough, but rather the exploitation of multiple subtle memory safety and logic vulnerabilities in Google's Rust prover code. Google has patched their proof, and their scientific claims are unaffected, but this story reflects the unique attack surface that systems introduce when they use zero-knowledge proofs. Google's proof uses a zero-knowledge virtual machine (zkVM) to calculate the cost of a quantum circuit on three key metrics. The total number of operations and Toffoli gate count represent the running time of the circuit, and the number of qubits represents the memory requirements. Google, along with their coauthors from UC Berkeley, the Ethereum Foundation, and Stanford, published proofs for two circuits; one minimizes the number of gates, and the other minimizes qubits. Our proof improves on both. Resource Type Google's Low-Gate Google's Low-Qubit Our Proof Total Operations 17,000,000 17,000,000 8,300,000 Number of Qubits 1,425 1,175 1,164 Toffoli Count 2,100,000 2,700,000 0 Table 1: Resource upper bounds reported in different proofs for circuits computing the correct output across 9,024 randomly sampled inputs Our proof fully verifies when using Google's unpatched verification code. It has the same verification key as their original proofs and is cryptographically indistinguishable from a zero-knowledge proof resulting from actual algorithmic improvements to the quantum circuit. We are releasing the code we developed to forge the proof, and a summary of our proof follows. Circuit SHA-256 hash: 0x7efe1f62bb14a978322ab9ed41d670fc0fe0f211331032615c910df5a540e999 Groth16 pr

## Bringing Rust to the Pixel Baseband

DevFeed: [Bringing Rust to the Pixel Baseband](<https://devfeed.tech/articles/bringing-rust-to-the-pixel-baseband-19818.md>)

Original publisher: [Read original article](<http://security.googleblog.com/2026/04/bringing-rust-to-pixel-baseband.html>)

Author: Edward Fernandez (noreply@blogger.com)

Published: 2026-04-10T15:12:00Z

Content type: article

Language: en

Sources: [Google Online Security](<https://devfeed.tech/sources/google-online-security.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [Parsing](<https://devfeed.tech/topics/parsing.md>), [Google](<https://devfeed.tech/topics/google.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-security](<https://devfeed.tech/tags/android-security.md>), [dns](<https://devfeed.tech/tags/dns.md>), [google](<https://devfeed.tech/tags/google.md>), [internet](<https://devfeed.tech/tags/internet.md>), [library](<https://devfeed.tech/tags/library.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [none](<https://devfeed.tech/tags/none.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [parsing](<https://devfeed.tech/tags/parsing.md>), [pixel](<https://devfeed.tech/tags/pixel.md>), [remote-code-execution](<https://devfeed.tech/tags/remote-code-execution.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Google describes integrating a memory-safe Rust DNS parser into Pixel modem firmware. The post explains the security motivation, the modem's remote attack surface, and the evaluation of open-source Rust DNS libraries, identifying hickory-proto as the best candidate based on maintenance, test coverage, and adoption.

### Source excerpt

Posted by Jiacheng Lu, Software Engineer, Google Pixel Team Google is continuously advancing the security of Pixel devices. We have been focusing on hardening the cellular baseband modem against exploitation. Recognizing the risks associated within the complex modem firmware, Pixel 9 shipped with mitigations against a range of memory-safety vulnerabilities. For Pixel 10, Google is advancing its proactive security measures further. Following our previous discussion on "Deploying Rust in Existing Firmware Codebases", this post shares a concrete application: integrating a memory-safe Rust DNS(Domain Name System) parser into the modem firmware. The new Rust-based DNS parser significantly reduces our security risk by mitigating an entire class of vulnerabilities in a risky area, while also laying the foundation for broader adoption of memory-safe code in other areas. Here we share our experience of working on it, and hope it can inspire the use of more memory safe languages in low-level environments. Why Modem Memory Safety Can't Wait In recent years, we have seen increasing interest in the cellular modem from attackers and security researchers. For example, Google's Project Zero gained remote code execution on Pixel modems over the Internet. Pixel modem has tens of Megabytes of executable code. Given the complexity and remote attack surface of the modem, other critical memory safety vulnerabilities may remain in the predominantly memory-unsafe firmware code. Why DNS? The DNS protocol is most commonly known in the context of browsers finding websites. With the evolution of cellular technology, modern cellular communications have migrated to digital data networks; consequently, even basic operations such as call forwarding rely on DNS services. DNS is a complex protocol and requires parsing of untrusted data, which can lead to vulnerabilities, particularly when implemented in a memory-unsafe language (example: CVE-2024-27227). Implementing the DNS parser in Rust offers va

## Bringing Rust to the Pixel Baseband

DevFeed: [Bringing Rust to the Pixel Baseband](<https://devfeed.tech/articles/bringing-rust-to-the-pixel-baseband-7622.md>)

Original publisher: [Read original article](<https://blog.google/security/bringing-rust-to-the-pixel-baseband/>)

Author: Jiacheng Lu

Published: 2026-04-10T09:56:00Z

Content type: article

Language: en

Sources: [Security](<https://devfeed.tech/sources/security.md>)

Topics: [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>)

Tags: [android-security](<https://devfeed.tech/tags/android-security.md>), [devices](<https://devfeed.tech/tags/devices.md>), [dns](<https://devfeed.tech/tags/dns.md>), [google](<https://devfeed.tech/tags/google.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [none](<https://devfeed.tech/tags/none.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [test-coverage](<https://devfeed.tech/tags/test-coverage.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Google describes integrating a memory-safe Rust DNS parser into Pixel 10 modem firmware to reduce risks from memory-safety vulnerabilities.

### Source excerpt

Google is continuously advancing the security of Pixel devices.

## Python 3.12.13, 3.11.15 and 3.10.20 are now available!

DevFeed: [Python 3.12.13, 3.11.15 and 3.10.20 are now available!](<https://devfeed.tech/articles/python-3-12-13-3-11-15-and-3-10-20-are-now-available-2393.md>)

Original publisher: [Read original article](<https://blog.python.org/2026/03/python-31213-31115-31020/>)

Author: Thomas Wouters

Published: 2026-03-03T00:00:00Z

Content type: release

Language: en

Sources: [Python Insider](<https://devfeed.tech/sources/python-insider.md>)

Topics: [Python](<https://devfeed.tech/topics/python.md>), [releases](<https://devfeed.tech/topics/releases.md>), [Security](<https://devfeed.tech/topics/security.md>), [Python 3.10](<https://devfeed.tech/topics/python-3-10.md>), [XML](<https://devfeed.tech/topics/xml.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [HTML](<https://devfeed.tech/topics/html.md>), [SSL](<https://devfeed.tech/topics/ssl.md>)

Tags: [html](<https://devfeed.tech/tags/html.md>), [http](<https://devfeed.tech/tags/http.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [python](<https://devfeed.tech/tags/python.md>), [python-3-10](<https://devfeed.tech/tags/python-3-10.md>), [releases](<https://devfeed.tech/tags/releases.md>), [security](<https://devfeed.tech/tags/security.md>), [ssl](<https://devfeed.tech/tags/ssl.md>)

### AI overview

Python 3.12.13, 3.11.15, and 3.10.20 are security-only source releases addressing vulnerabilities and hardening email, HTTP, XML, HTML, denial-of-service, and SSL handling.

### Source excerpt

[Python Releases For Your Security!](https://discuss.python.org/t/python-3-12-13-3-11-15-and-3-10-20-are-now-available/106363) New security releases for 3.10, 3.11 and 3.12 are now available.

## Using Java's Foreign Function & Memory API to simplify Pi4J native interactions

DevFeed: [Using Java's Foreign Function & Memory API to simplify Pi4J native interactions](<https://devfeed.tech/articles/the-ffm-api-how-openjdk-changed-the-game-for-native-interactions-and-made-pi4j-better-23017.md>)

Original publisher: [Read original article](<https://www.javaadvent.com/2025/12/ffm-api-for-java-on-raspberry-pi.html>)

Author: Frank Delporte

Published: 2025-12-16T03:03:39Z

Content type: article

Language: en

Sources: [Java Advent Calendar](<https://devfeed.tech/sources/java-advent-calendar.md>)

Topics: [Raspberry Pi](<https://devfeed.tech/topics/raspberry-pi.md>), [openjdk](<https://devfeed.tech/topics/openjdk.md>), [Java](<https://devfeed.tech/topics/java.md>), [Library](<https://devfeed.tech/topics/library.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [code](<https://devfeed.tech/tags/code.md>), [java](<https://devfeed.tech/tags/java.md>), [library](<https://devfeed.tech/tags/library.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [openjdk](<https://devfeed.tech/tags/openjdk.md>), [raspberry-pi](<https://devfeed.tech/tags/raspberry-pi.md>)

### AI overview

The article explains how Java's Foreign Function & Memory API, finalized in Java 22, can simplify Pi4J's interaction with native libraries and memory on Raspberry Pi. It contrasts the API with Pi4J's earlier JNI and Java Native Access approach, focusing on memory safety, easier native-library access, and maintainability.

### Source excerpt

The Pi4J project is a Java library that allows you to control the GPIO pins and electronic components connected to a Raspberry Pi with pure Java code. It removes the complexity of using native libraries and the Java Native Interface (JNI), allowing you to focus on your application logic. In the Java Advent of 2020, I published "Light up [...] The post The FFM API: How OpenJDK Changed the Game for Native Interactions (And Made Pi4J Better!) appeared first on JVM Advent.

## Rust in Android: move fast and fix things

DevFeed: [Rust in Android: move fast and fix things](<https://devfeed.tech/articles/rust-in-android-move-fast-and-fix-things-19806.md>)

Original publisher: [Read original article](<http://security.googleblog.com/2025/11/rust-in-android-move-fast-fix-things.html>)

Author: Edward Fernandez (noreply@blogger.com)

Published: 2025-11-13T16:59:00Z

Content type: article

Language: en

Sources: [Google Online Security](<https://devfeed.tech/sources/google-online-security.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Vulnerabilities](<https://devfeed.tech/topics/vulnerabilities.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-security](<https://devfeed.tech/tags/android-security.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [linux](<https://devfeed.tech/tags/linux.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [none](<https://devfeed.tech/tags/none.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [software](<https://devfeed.tech/tags/software.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>)

### AI overview

Google describes how Rust adoption in Android is associated with fewer memory safety vulnerabilities and faster software delivery. The article reports that memory safety vulnerabilities fell below 20% of total vulnerabilities in 2025, while Rust changes had lower rollback rates and spent less time in code review than comparable changes.

### Source excerpt

Posted by Jeff Vander Stoep, Android Last year, we wrote about why a memory safety strategy that focuses on vulnerability prevention in new code quickly yields durable and compounding gains. This year we look at how this approach isn't just fixing things, but helping us move faster. The 2025 data continues to validate the approach, with memory safety vulnerabilities falling below 20% of total vulnerabilities for the first time. Updated data for 2025. This data covers first-party and third-party (open source) code changes to the Android platform across C, C++, Java, Kotlin, and Rust. This post is published a couple of months before the end of 2025, but Android's industry-standard 90-day patch window means that these results are very likely close to final. We can and will accelerate patching when necessary. We adopted Rust for its security and are seeing a 1000x reduction in memory safety vulnerability density compared to Android's C and C++ code. But the biggest surprise was Rust's impact on software delivery. With Rust changes having a 4x lower rollback rate and spending 25% less time in code review, the safer path is now also the faster one. In this post, we dig into the data behind this shift and also cover: How we're expanding our reach: We're pushing to make secure code the default across our entire software stack. We have updates on Rust adoption in first-party apps, the Linux kernel, and firmware. Our first rust memory safety vulnerability...almost: We'll analyze a near-miss memory safety bug in unsafe Rust: how it happened, how it was mitigated, and steps we're taking to prevent recurrence. It's also a good chance to answer the question "if Rust can have memory safety issues, why bother at all?" Building Better Software, Faster Developing an operating system requires the low-level control and predictability of systems programming languages like C, C++, and Rust. While Java and Kotlin are important for Android platform development, their role is complementary

## exploits.club Weekly Newsletter 89 - iOS GPU Driver Bugs, Kernel Stack UAFs, Hardware Wallet Auth Bypasses, and More

DevFeed: [exploits.club Weekly Newsletter 89 - iOS GPU Driver Bugs, Kernel Stack UAFs, Hardware Wallet Auth Bypasses, and More](<https://devfeed.tech/articles/exploits-club-weekly-newsletter-89-ios-gpu-driver-bugs-kernel-stack-uafs-hardware-wallet-auth-bypasses-and-more-32646.md>)

Original publisher: [Read original article](<https://blog.exploits.club/exploits-club-weekly-newsletter-89-ios-gpu-driver-bugs-kernel-stack-uafs-hardware-wallet-auth-bypasses-and-more/>)

Author: exploits.club

Published: 2025-10-16T15:00:32Z

Content type: article

Language: en

Sources: [exploits.club](<https://devfeed.tech/sources/exploits-club.md>)

Topics: [iOS](<https://devfeed.tech/topics/ios.md>), [Security](<https://devfeed.tech/topics/security.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [vulnerability](<https://devfeed.tech/topics/vulnerability.md>), [Hacking](<https://devfeed.tech/topics/hacking.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [UEFI](<https://devfeed.tech/topics/uefi.md>)

Tags: [firmware](<https://devfeed.tech/tags/firmware.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hacking](<https://devfeed.tech/tags/hacking.md>), [ios](<https://devfeed.tech/tags/ios.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

This weekly newsletter rounds up security research and announcements, including an iOS GPU kernel driver vulnerability whose patched underflow could enable out-of-bounds read/write, though modern allocator hardening may prevent a practical exploit. It also covers x86 memory-safety instructions, Apple security bounty changes, and a Nokia Beacon 1 router teardown involving UART access, command injection, and password generation.

### Source excerpt

Our NBA Finals game 7 prediction didn't go too well earlier this year, but mark these words now: Piastri and Lando are taking each other out at USGP this week. Annnnnnyways 👇 In Case You Missed It... Save the Date for OffensiveCon26 - May 15th and 16th of next

## Trip report: Node.js collaboration summit (2025 Paris)

DevFeed: [Trip report: Node.js collaboration summit (2025 Paris)](<https://devfeed.tech/articles/trip-report-node-js-collaboration-summit-2025-paris-2438.md>)

Original publisher: [Read original article](<https://nodejs.org/en/blog/events/collab-summit-2025-paris>)

Published: 2025-05-22T00:00:00Z

Content type: article

Language: en

Sources: [Node.js Blog](<https://devfeed.tech/sources/node-js-blog.md>)

Topics: [Node.js](<https://devfeed.tech/topics/node-js.md>), [ci](<https://devfeed.tech/topics/ci.md>), [Deadlock](<https://devfeed.tech/topics/deadlock.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [wasm](<https://devfeed.tech/topics/wasm.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [browsers](<https://devfeed.tech/topics/browsers.md>)

Tags: [browsers](<https://devfeed.tech/tags/browsers.md>), [ci](<https://devfeed.tech/tags/ci.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [deadlock](<https://devfeed.tech/tags/deadlock.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [wasm](<https://devfeed.tech/tags/wasm.md>)

### AI overview

A trip report on the 2025 Node.js collaboration summit in Paris, covering CI infrastructure reliability, experimental WASM modules, browser coordination, V8 Oilpan integration, memory safety, garbage collection, mentorship, and contributor experience.

### Source excerpt

Node.js® is a free, open-source, cross-platform JavaScript runtime environment that lets developers create servers, web apps, command line tools and scripts.

## Eliminating Array Bounds Checks

DevFeed: [Eliminating Array Bounds Checks](<https://devfeed.tech/articles/eliminating-array-bounds-checks-25610.md>)

Original publisher: [Read original article](<https://www.romainguy.dev/posts/2025/eliminating-array-bounds-checks/>)

Author: Romain Guy

Published: 2025-05-13T00:00:00Z

Content type: tutorial

Language: en

Sources: [Posts on Romain Guy](<https://devfeed.tech/sources/posts-on-romain-guy.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Exception](<https://devfeed.tech/topics/exception.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [inlining](<https://devfeed.tech/topics/inlining.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developer](<https://devfeed.tech/tags/developer.md>), [exception](<https://devfeed.tech/tags/exception.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [inlining](<https://devfeed.tech/tags/inlining.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [performance](<https://devfeed.tech/tags/performance.md>), [toolchain](<https://devfeed.tech/tags/toolchain.md>)

### AI overview

This tutorial explains how Android Runtime array bounds checks protect memory safety but can add unnecessary instructions. It shows how a simple explicit check can help the compiler eliminate those checks in a fixed-size array, reducing the example from 136 to 60 arm64 instructions.

### Source excerpt

The Android Runtime (ART) offers a nice memory safety feature when accessing the content of an array. The indices you use are automatically checked against the bounds of the array to prevent unsafe memory accesses. To achieve this, ART generates extra machine instructions to throw an ArrayIndexOutOfBoundsException when the index is invalid. Here is a simple Kotlin example: 1fun scaleZ(values: FloatArray, scale: Float) = values[2] * scale After translation to arm64 assembly, we obtain the following result:

## No-Panic Rust: A Nice Technique for Systems Programming

DevFeed: [No-Panic Rust: A Nice Technique for Systems Programming](<https://devfeed.tech/articles/no-panic-rust-a-nice-technique-for-systems-programming-21139.md>)

Original publisher: [Read original article](<https://blog.reverberate.org/2025/02/03/no-panic-rust.html>)

Author: Haberman

Published: 2025-02-03T00:00:00Z

Content type: article

Language: en

Sources: [Josh Haberman](<https://devfeed.tech/sources/josh-haberman.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [systems](<https://devfeed.tech/topics/systems.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [code](<https://devfeed.tech/tags/code.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

This article examines "No-Panic Rust," a technique for using Rust in low-level systems programming while avoiding panics as a response to errors. The author argues that the approach could make porting the upb C library to Rust more practical while preserving performance and code-size goals.

### Source excerpt

Can Rust replace C? This is a question that has been on my mind for many years, as I created and now am tech lead for upb, a C library for Protocol Buffers. There is an understandable push to bring memory safety to all parts of the software stack, and this would suggest a port of upb to Rust. While I love the premise of Rust, I have long been skeptical that a port of upb to Rust could preserve the performance and code size characteristics that I and others have fought so hard to optimize. In fact, this blog entry was originally going to be an argument for why Rust cannot match C for upb's use case. But I recently discovered a technique that shifted my thinking a lot. I call it "No-Panic Rust", and while the technique is clearly not new1, I was not able to find any in-depth discussion of how it works or what problems it solves. This article is my attempt to fill that gap. I believe that No-Panic Rust is the key to making Rust a compelling option for low-level systems programming. I now am optimistic about the possibility of porting upb to Rust. What are Panics? Panics are Rust's mechanism for unrecoverable errors. Anytime our program encounters an error, we have three basic options for how to handle it: Handle the error immediately (eg. retry the operation or fall back to plan B). Propagate the error to the caller, who can decide how to handle it. Immediately abort execution. In Rust, we use Result for (2) and panic!() for (3). When we use Result, it is considered a "recoverable error", because the caller can test for the error and decide how to respond. With recoverable errors, the potential for error is reflected in the function signature; a function that returns Result is fallible from the perspective of the caller. Panics on the other hand present the illusion of infallibility from an API perspective, but then proceed to handle errors by simply aborting. There is a lot of standard guidance for when to use panic!() vs Result (for example, here and here), which lar

## Using Compiler Flags to Secure Your Code

DevFeed: [Using Compiler Flags to Secure Your Code](<https://devfeed.tech/articles/using-compiler-flags-to-secure-your-code-13310.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/using-compiler-flags-to-secure-your-code>)

Published: 2025-01-22T00:00:00Z

Content type: tutorial

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code](<https://devfeed.tech/topics/code.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Security](<https://devfeed.tech/topics/security.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [gcc](<https://devfeed.tech/topics/gcc.md>), [Dockerfile](<https://devfeed.tech/topics/dockerfile.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [chainguard-images](<https://devfeed.tech/tags/chainguard-images.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-flags](<https://devfeed.tech/tags/compiler-flags.md>), [container](<https://devfeed.tech/tags/container.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [open-ssf](<https://devfeed.tech/tags/open-ssf.md>), [security](<https://devfeed.tech/tags/security.md>)

### AI overview

This tutorial examines OpenSSF-recommended compiler flags for C and C++ code, focusing on how hardened standard-library calls and related protections affect memory safety and buffer-overflow behavior. It demonstrates the examples using a Docker-based development environment.

### Source excerpt

Open SSF's recommended compiler flags are a great way to improve memory safety and security. Check out what effect using these flags can have.

## Introducing multi-backends (TRT-LLM, vLLM) support for Text Generation Inference

DevFeed: [Introducing multi-backends (TRT-LLM, vLLM) support for Text Generation Inference](<https://devfeed.tech/articles/introducing-multi-backends-trt-llm-vllm-support-for-text-generation-inference-7501.md>)

Original publisher: [Read original article](<https://huggingface.co/blog/tgi-multi-backend>)

Author: Morgan Funtowicz; Hugo Larcher

Published: 2025-01-16T00:00:00Z

Content type: article

Language: en

Sources: [Hugging Face - Blog](<https://devfeed.tech/sources/hugging-face-blog.md>)

Topics: [tgi](<https://devfeed.tech/topics/tgi.md>), [model-deployment](<https://devfeed.tech/topics/model-deployment.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [TensorRT-LLM](<https://devfeed.tech/topics/tensorrt-llm.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [servers](<https://devfeed.tech/topics/servers.md>), [llama.cpp](<https://devfeed.tech/topics/llama-cpp.md>), [sglang](<https://devfeed.tech/topics/sglang.md>), [Python](<https://devfeed.tech/topics/python.md>), [Code](<https://devfeed.tech/topics/code.md>)

Tags: [backend](<https://devfeed.tech/tags/backend.md>), [backends](<https://devfeed.tech/tags/backends.md>), [community](<https://devfeed.tech/tags/community.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [http](<https://devfeed.tech/tags/http.md>), [inference](<https://devfeed.tech/tags/inference.md>), [jetstream](<https://devfeed.tech/tags/jetstream.md>), [llama-cpp](<https://devfeed.tech/tags/llama-cpp.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [neuron](<https://devfeed.tech/tags/neuron.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [production](<https://devfeed.tech/tags/production.md>), [python](<https://devfeed.tech/tags/python.md>), [rust](<https://devfeed.tech/tags/rust.md>), [sglang](<https://devfeed.tech/tags/sglang.md>), [tensorrt-llm](<https://devfeed.tech/tags/tensorrt-llm.md>), [tgi](<https://devfeed.tech/tags/tgi.md>), [vllm](<https://devfeed.tech/tags/vllm.md>)

### AI overview

Hugging Face introduces TGI Backends, a unified frontend architecture for integrating inference solutions such as vLLM, SGLang, llama.cpp, and TensorRT-LLM. The approach lets users switch backends based on model, hardware, and performance requirements while supporting production deployment across diverse accelerators. The article also describes TGI's Rust and Python components, including Rust-based HTTP and scheduling layers designed for memory safety and concurrency.

### Source excerpt

We're on a journey to advance and democratize artificial intelligence through open source and open science.

## Introducing Uniffi for React Native: Rust-Powered Turbo Modules

DevFeed: [Introducing Uniffi for React Native: Rust-Powered Turbo Modules](<https://devfeed.tech/articles/introducing-uniffi-for-react-native-rust-powered-turbo-modules-4140.md>)

Original publisher: [Read original article](<https://hacks.mozilla.org/2024/12/introducing-uniffi-for-react-native-rust-powered-turbo-modules/>)

Author: Mark Mayo

Published: 2024-12-04T19:38:01Z

Content type: article

Language: en

Sources: [Mozilla Hacks - the Web developer blog](<https://devfeed.tech/sources/mozilla-hacks-the-web-developer-blog.md>)

Topics: [React Native](<https://devfeed.tech/topics/react-native.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [Mozilla](<https://devfeed.tech/topics/mozilla.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [JavaScript](<https://devfeed.tech/topics/javascript.md>), [Process](<https://devfeed.tech/topics/process.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [developer-tools](<https://devfeed.tech/tags/developer-tools.md>), [featured-article](<https://devfeed.tech/tags/featured-article.md>), [firefox](<https://devfeed.tech/tags/firefox.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mozilla](<https://devfeed.tech/tags/mozilla.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [react](<https://devfeed.tech/tags/react.md>), [react-native](<https://devfeed.tech/tags/react-native.md>), [rust](<https://devfeed.tech/tags/rust.md>)

### AI overview

Mozilla and Filament introduce Uniffi for React Native, an open-source tool for building React Native Turbo Modules in Rust. It generates bindings that let developers use Rust for shared core logic across iOS and Android, helping address JavaScript-thread performance limits while avoiding duplicated platform code or more difficult C++ integration.

### Source excerpt

Mozilla and Filament have introduced Uniffi for React Native, a tool that allows developers to leverage the safety and performance benefits of Rust in cross-platform React Native apps. The post Introducing Uniffi for React Native: Rust-Powered Turbo Modules appeared first on Mozilla Hacks - the Web developer blog.

## Enhanced Compiler Flags for Building Chainguard's Guarded Images

DevFeed: [Enhanced Compiler Flags for Building Chainguard's Guarded Images](<https://devfeed.tech/articles/enhanced-compiler-flags-for-building-chainguard-s-guarded-images-13030.md>)

Original publisher: [Read original article](<https://www.chainguard.dev/unchained/enhanced-compiler-flags-for-building-chainguards-guarded-images>)

Published: 2024-11-19T00:00:00Z

Content type: article

Language: en

Sources: [Chainguard: Unchained](<https://devfeed.tech/sources/chainguard-unchained.md>)

Topics: [chainguard images](<https://devfeed.tech/topics/chainguard-images.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [Security](<https://devfeed.tech/topics/security.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Exploit](<https://devfeed.tech/topics/exploit.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [chainguard-images](<https://devfeed.tech/tags/chainguard-images.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-flags](<https://devfeed.tech/tags/compiler-flags.md>), [compiler-hardening](<https://devfeed.tech/tags/compiler-hardening.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [openssf](<https://devfeed.tech/tags/openssf.md>), [secure-by-default](<https://devfeed.tech/tags/secure-by-default.md>), [security](<https://devfeed.tech/tags/security.md>), [vulnerabilities](<https://devfeed.tech/tags/vulnerabilities.md>), [vulnerability](<https://devfeed.tech/tags/vulnerability.md>)

### AI overview

Chainguard Images now use enhanced compiler flags for C/C++ projects. The OpenSSF-recommended hardening is implemented through clang configuration files and gcc spec files in Wolfi, helping mitigate memory-safety vulnerabilities such as stack-based buffer overflows and unsafe memory usage.

### Source excerpt

Chainguard Images are now built using enhanced compiler flags for C/C++ projects. See how this strengthens the security posture of Chainguard's build systems.

## Fearless Concurrency Ep.5: Ensuring Memory Safety with Mutexes and RwLocks in Rust

DevFeed: [Fearless Concurrency Ep.5: Ensuring Memory Safety with Mutexes and RwLocks in Rust](<https://devfeed.tech/articles/fearless-concurrency-ep-5-ensuring-memory-safety-with-mutexes-and-rwlocks-in-rust-22269.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/11/fearless-concurrency-ep5-ensuring-memory-safety-with-mutexes-and-rwlocks-in-rust.html>)

Published: 2024-11-08T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Concurrent Programming](<https://devfeed.tech/topics/concurrent-programming.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [advanced-concurrency-rust](<https://devfeed.tech/tags/advanced-concurrency-rust.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [concurrency-in-rust](<https://devfeed.tech/tags/concurrency-in-rust.md>), [concurrency-patterns-rust](<https://devfeed.tech/tags/concurrency-patterns-rust.md>), [concurrent-read-write-access-rust](<https://devfeed.tech/tags/concurrent-read-write-access-rust.md>), [data-sharing-in-multithreading](<https://devfeed.tech/tags/data-sharing-in-multithreading.md>), [deadlock-avoidance-rust](<https://devfeed.tech/tags/deadlock-avoidance-rust.md>), [embedding-mutex-in-structs](<https://devfeed.tech/tags/embedding-mutex-in-structs.md>), [fearless-concurrency-rust](<https://devfeed.tech/tags/fearless-concurrency-rust.md>), [interior-mutability-rust](<https://devfeed.tech/tags/interior-mutability-rust.md>), [managing-shared-data-rust](<https://devfeed.tech/tags/managing-shared-data-rust.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [mutex](<https://devfeed.tech/tags/mutex.md>), [mutexes-in-rust](<https://devfeed.tech/tags/mutexes-in-rust.md>), [optimizing-performance-rust-multithreading](<https://devfeed.tech/tags/optimizing-performance-rust-multithreading.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-concurrency-best-practices](<https://devfeed.tech/tags/rust-concurrency-best-practices.md>), [rust-concurrency-tools](<https://devfeed.tech/tags/rust-concurrency-tools.md>), [rust-data-synchronization](<https://devfeed.tech/tags/rust-data-synchronization.md>), [rust-interior-mutability-examples](<https://devfeed.tech/tags/rust-interior-mutability-examples.md>), [rust-multithreading-performance](<https://devfeed.tech/tags/rust-multithreading-performance.md>), [rust-mutex-integration](<https://devfeed.tech/tags/rust-mutex-integration.md>), [rust-mutex-vs-rwlock](<https://devfeed.tech/tags/rust-mutex-vs-rwlock.md>), [rust-read-write-locks](<https://devfeed.tech/tags/rust-read-write-locks.md>), [rust-thread-management](<https://devfeed.tech/tags/rust-thread-management.md>), [rust-thread-safety](<https://devfeed.tech/tags/rust-thread-safety.md>), [rust-thread-safety-techniques](<https://devfeed.tech/tags/rust-thread-safety-techniques.md>), [rwlock-in-rust](<https://devfeed.tech/tags/rwlock-in-rust.md>), [rwlock-vs-mutex-rust](<https://devfeed.tech/tags/rwlock-vs-mutex-rust.md>), [sync-trait-in-rust](<https://devfeed.tech/tags/sync-trait-in-rust.md>), [sync-trait-rust](<https://devfeed.tech/tags/sync-trait-rust.md>), [synchronization](<https://devfeed.tech/tags/synchronization.md>), [thread](<https://devfeed.tech/tags/thread.md>), [thread-safe-structs-rust](<https://devfeed.tech/tags/thread-safe-structs-rust.md>)

### AI overview

Episode 5 of a Rust concurrency series explains RwLock for coordinating simultaneous reads and writes, along with interior mutability for embedding mutexes in structs. It advises limiting RwLock use to read-heavy cases, starting with mutexes to learn synchronization fundamentals, and avoiding deadlocks. The examples show how struct-level synchronization can simplify multithreaded code and reduce unnecessary serialization.

### Source excerpt

Introduction: Welcome to Episode 5 of Fearless Concurrency in Rust! In this episode, Herbert Wolverson dives into advanced concurrency tools, focusing on RwLock for managing simultaneous reads and writes and the powerful concept of interior mutability. These tools provide developers with greater control over data sharing in multithreaded environments, enabling them to optimize for both performance and code simplicity in Rust. Read-Write Locks (RwLock): Manage concurrent read and write access efficiently.

## Transitioning from C and C++ to Rust: A Beginner's Guide

DevFeed: [Transitioning from C and C++ to Rust: A Beginner's Guide](<https://devfeed.tech/articles/transitioning-from-c-and-c-to-rust-a-beginner-s-guide-22268.md>)

Original publisher: [Read original article](<https://www.ardanlabs.com/blog/2024/10/transitioning-from-c-and-c++-to-rust.html>)

Published: 2024-10-29T00:00:00Z

Content type: tutorial

Language: en

Sources: [William Kennedy](<https://devfeed.tech/sources/william-kennedy.md>)

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [C](<https://devfeed.tech/topics/c.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Programming](<https://devfeed.tech/topics/programming.md>)

Tags: [beginner](<https://devfeed.tech/tags/beginner.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [c-plus-plus-to-rust](<https://devfeed.tech/tags/c-plus-plus-to-rust.md>), [c-to-rust](<https://devfeed.tech/tags/c-to-rust.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [enums](<https://devfeed.tech/tags/enums.md>), [generics](<https://devfeed.tech/tags/generics.md>), [guide](<https://devfeed.tech/tags/guide.md>), [memory-management](<https://devfeed.tech/tags/memory-management.md>), [memory-safety](<https://devfeed.tech/tags/memory-safety.md>), [migrating-from-c-plus-plus-to-rust](<https://devfeed.tech/tags/migrating-from-c-plus-plus-to-rust.md>), [pattern-matching](<https://devfeed.tech/tags/pattern-matching.md>), [pointers](<https://devfeed.tech/tags/pointers.md>), [runtime-errors](<https://devfeed.tech/tags/runtime-errors.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-for-c-developers](<https://devfeed.tech/tags/rust-for-c-developers.md>), [rust-for-c-plus-plus-programmers](<https://devfeed.tech/tags/rust-for-c-plus-plus-programmers.md>), [rust-programming](<https://devfeed.tech/tags/rust-programming.md>), [transitioning-from-c-and-c-plus-plus-to-rust-guide](<https://devfeed.tech/tags/transitioning-from-c-and-c-plus-plus-to-rust-guide.md>), [transitioning-from-c-and-c-plus-plus-to-rust-tutorial](<https://devfeed.tech/tags/transitioning-from-c-and-c-plus-plus-to-rust-tutorial.md>), [transitioning-to-rust](<https://devfeed.tech/tags/transitioning-to-rust.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

A beginner's guide to transitioning from C and C++ to Rust, focusing on Rust's ownership and borrowing model, compile-time memory-safety checks, and type-system features such as enums, pattern matching, and generics.

### Source excerpt

Introduction: As you embark on the journey from C or C++ to Rust, you'll discover a world of exciting possibilities. Rust's emphasis on safety, concurrency, and performance can significantly enhance your programming toolkit. This beginner's guide on transitioning from C and C++ to Rust will provide a structured approach to making that transition, addressing essential concepts and practical applications. Let's dive in! Step 1: Understanding Rust's Ownership Model Concept Overview: Rust's ownership model is its most distinctive feature. Unlike C and C++, where you have pointers and manual memory management, Rust uses a system of ownership with rules that the compiler checks at compile time.

[Next page](<https://devfeed.tech/tags/memory-safety.md?cursor=WyIyMDI0LTEwLTI5VDAwOjAwOjAwKzAwOjAwIiwgIjg5YWIyOGM4LWQ5NDQtNDUxYy04ZDQyLWEyYzY3ZDI3M2M4YSJd>)