# LLVM

LLVM is a collection of modular and reusable compiler and toolchain technologies, including optimizer, code-generation, compiler, debugger, linker, and compiler-infrastructure projects.

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

## Beyls: Wrapping up LLVM's relicensing effort

DevFeed: [Beyls: Wrapping up LLVM's relicensing effort](<https://devfeed.tech/articles/beyls-wrapping-up-llvm-s-relicensing-effort-146551.md>)

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

Author: jzb

Published: 2026-11-20T14:35:24Z

Content type: news

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [spdx](<https://devfeed.tech/topics/spdx.md>)

Tags: [apache-2-0](<https://devfeed.tech/tags/apache-2-0.md>), [code](<https://devfeed.tech/tags/code.md>), [contributors](<https://devfeed.tech/tags/contributors.md>), [effort](<https://devfeed.tech/tags/effort.md>), [license](<https://devfeed.tech/tags/license.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [relicensing](<https://devfeed.tech/tags/relicensing.md>), [spdx](<https://devfeed.tech/tags/spdx.md>)

### AI overview

LLVM is closing its eight-year relicensing effort after determining that more than 99.5% of contributed lines are covered by Apache-2.0 WITH LLVM-exception, too small for copyright to apply, or no longer in the repository. New contributions have used that license since January 19, 2019; moving earlier code from UIUC/NCSA and, for some runtime libraries, MIT required author permission. Contributors with pre-cutoff code who have not signed an agreement and object to relicensing can contact LLVM to ensure the code has the appropriate SPDX license identifier.

### Source excerpt

Kristof Beyls has published a summary to the LLVM discussion forum to announce that the project is declaring success and bringing its relicensing effort to a close after eight years. We've been asking past contributors to relicense their work since 2018. New contributions have come in under Apache-2.0 WITH LLVM-exception since January 19, 2019. Code contributed before that date was under LLVM's earlier licenses (UIUC/NCSA, plus MIT for some runtime libraries), so we needed permission from its authors to move it over. [...] Today, more than 99.5% of all lines of code ever contributed to LLVM are either covered by the new license, too small for copyright to apply, or no longer in the repository. Rather than trying to "chase the last tiny fraction forever" LLVM is winding up the effort. Any contributors with code contributed before January 19, 2019 who have not signed a relicensing agreement and do not want their contributions made available under Apache-2.0 with the LLVM-exception can still reach out to the project to ensure their code has the appropriate SPDX license identifier.

## LLVM Effectively Completes Its Relicensing After Nearly A Decade Of Work

DevFeed: [LLVM Effectively Completes Its Relicensing After Nearly A Decade Of Work](<https://devfeed.tech/articles/llvm-effectively-completes-its-relicensing-after-nearly-a-decade-of-work-144328.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/LLVM-Re-Licensing-Complete>)

Author: Michael Larabel

Published: 2026-11-19T21:02:56Z

Content type: news

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [software composition analysis](<https://devfeed.tech/topics/software-composition-analysis.md>)

Tags: [apache-2-0](<https://devfeed.tech/tags/apache-2-0.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-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>), [llvm](<https://devfeed.tech/tags/llvm.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>), [relicensing](<https://devfeed.tech/tags/relicensing.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

LLVM's relicensing effort is considered effectively complete: more than 99.5% of all code ever contributed is now under the Apache-2.0 WITH LLVM-exception license, has left the codebase, or is too small to be covered by copyright. Since 2018, more than 1,300 contributors and around 100 organizations agreed to relicense historic contributions. Contributions since January 19, 2019 have used the new license; earlier work required author permission because it was under LLVM's prior licenses, including UIUC/NCSA and MIT for some runtime libraries. LLVM 25, planned for 2027, is expected to update LICENSE files and related documentation to point to the unified license.

### Source excerpt

Back around 2017 an effort began to work on re-licensing all of the LLVM code under the Apache 2.0 license with exceptions, moving away from their prior 3-clause BSD-like "LLVM license". Prior updates on the topic included LLVM Developers Are Still Working On Their Massive Relicensing Effort (2018) and then LLVM Is Still Working On Relicensing, Needs Help Locating Some Past Contributors (2021)... Now finally as we approach the end of 2026, this re-licensing effort has been deemed effectively complete...

## MetaphIR: Corpus-Scale Applicability Analysis for LLVM Peephole Optimizations

DevFeed: [MetaphIR: Corpus-Scale Applicability Analysis for LLVM Peephole Optimizations](<https://devfeed.tech/articles/metaphir-corpus-scale-applicability-analysis-for-llvm-peephole-optimizations-142187.md>)

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

Author: Hongxu Xu, Xintong Zhou, Chunhao Liao, Chengnian Sun

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

Content type: article

Language: en

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

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [domain-specific-language](<https://devfeed.tech/tags/domain-specific-language.md>), [filter](<https://devfeed.tech/tags/filter.md>), [interactive](<https://devfeed.tech/tags/interactive.md>), [ir](<https://devfeed.tech/tags/ir.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [median](<https://devfeed.tech/tags/median.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [pattern](<https://devfeed.tech/tags/pattern.md>), [precision](<https://devfeed.tech/tags/precision.md>), [queries](<https://devfeed.tech/tags/queries.md>), [rewrite](<https://devfeed.tech/tags/rewrite.md>), [scale](<https://devfeed.tech/tags/scale.md>), [search-engine](<https://devfeed.tech/tags/search-engine.md>)

### AI overview

MetaphIR estimates how often LLVM peephole rewrites apply across large IR corpora before developers implement them. Unlike structural search, which overcounts by ignoring rewrite preconditions, MetaphIR expresses patterns with holes and Boolean constraints, then uses indexed per-function summaries and abstract interpretation to filter impossible matches. This avoids the engineering cost and median 47-minute runtime of recompiling the corpus. Across 20 recent InstCombine rewrites, it reported exact applicability sets in isolation (100% precision and recall); queries took a median 1.27 seconds, 22x faster than a full corpus scan.

### Source excerpt

arXiv:2611.23555v1 Announce Type: cross Abstract: Peephole optimizations replace short source instruction sequences with more efficient equivalents, typically guarded by preconditions such as requiring a constant operand to be a power of two. Since every new rewrite adds maintenance burden and compile-time cost, compiler developers need to know how often real-world programs both match the source pattern and satisfy its preconditions before committing to an implementation. Existing workflows fall short: structural search over an intermediate representation (IR) corpus of 4.8 million functions ignores preconditions and therefore overcounts, whereas implementing the rewrite and recompiling the corpus yields exact counts only after paying the engineering cost, with each run of the corpus's on-demand recompilation pipeline taking a median of 47 minutes. This delay is especially limiting when generalizing a rewrite, as developers often iterate over multiple variants to trade off coverage against complexity. We introduce MetaphIR, a system pairing a domain-specific language for expressing LLVM peephole optimizations with an indexed search engine over large IR corpora. Using a syntax modeled on LLVM's C++ matchers, MetaphIR patterns augment LLVM IR with holes and Boolean preconditions over matched values. To answer queries at interactive speed, MetaphIR builds compact per-function summaries ahead of time and uses abstract interpretation over those summaries to soundly filter out functions that cannot satisfy a query's constraints. Across twenty recent peephole optimizations from LLVM's InstCombine pass, MetaphIR recovers the exact set of functions where each rewrite applies in isolation, achieving 100% precision and recall. Queries complete in a median of 1.27 seconds---a 22x speedup over a full corpus scan---enabling developers to quickly gauge an optimization's reach and generality prior to implementation.

## LLVM's Old AMD R600 Compiler Backend Slated For Removal

DevFeed: [LLVM's Old AMD R600 Compiler Backend Slated For Removal](<https://devfeed.tech/articles/llvm-s-old-amd-r600-compiler-backend-slated-for-removal-135358.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/LLVM-R600-Backend-To-Retire>)

Author: Michael Larabel

Published: 2026-11-16T13:04:01Z

Content type: news

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [deprecated](<https://devfeed.tech/topics/deprecated.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [backend](<https://devfeed.tech/tags/backend.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [legacy](<https://devfeed.tech/tags/legacy.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>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mesa](<https://devfeed.tech/tags/mesa.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [radeon](<https://devfeed.tech/tags/radeon.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

AMD has proposed removing LLVM's R600 back-end, which supports Radeon HD 2000-6000 GPUs. Its former Mesa R600 Gallium3D and Clover OpenCL uses have ended: Mesa's R600g driver moved to NIR, and Clover was replaced by Rusticl. With no known users or maintainers, the legacy code and lit tests add upkeep and complicate changes to the modern AMDGPU back-end. The RFC covers R600/TeraScale hardware only; GCN and newer GPUs using AMDGPU are unaffected. The excerpt says no concerns had been raised at the time.

### Source excerpt

The old ATI/AMD Radeon R600 back-end within the LLVM compiler codebase will likely be removed given it's become a legacy burden and doesn't have any current use by the modern Mesa driver stack...

## VellSSLH: Sound Type-Guided Selective Speculative Load Hardening for LLVM IR

DevFeed: [VellSSLH: Sound Type-Guided Selective Speculative Load Hardening for LLVM IR](<https://devfeed.tech/articles/vellsslh-sound-type-guided-selective-speculative-load-hardening-for-llvm-ir-136054.md>)

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

Author: Swarn Priya

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

Content type: article

Language: en

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

Topics: [side channel](<https://devfeed.tech/topics/side-channel.md>), [compiler hardening](<https://devfeed.tech/topics/compiler-hardening.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [data type](<https://devfeed.tech/topics/data-type.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [cryptographic](<https://devfeed.tech/tags/cryptographic.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [hardening](<https://devfeed.tech/tags/hardening.md>), [ir](<https://devfeed.tech/tags/ir.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-ir](<https://devfeed.tech/tags/llvm-ir.md>), [load](<https://devfeed.tech/tags/load.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [secret](<https://devfeed.tech/tags/secret.md>), [security](<https://devfeed.tech/tags/security.md>), [semantics](<https://devfeed.tech/tags/semantics.md>), [ssa](<https://devfeed.tech/tags/ssa.md>), [transformation](<https://devfeed.tech/tags/transformation.md>), [type](<https://devfeed.tech/tags/type.md>), [type-system](<https://devfeed.tech/tags/type-system.md>), [x25519](<https://devfeed.tech/tags/x25519.md>)

### AI overview

VellSSLH selectively inserts speculative load hardening in LLVM IR, using annotated Public and Secret inputs to infer which values may become secret during speculation and protect them where needed. Its extracted checker validates the IR; Rocq proofs establish speculative constant-time security for accepted programs and architectural behavior preservation for a reference transformation. Evaluated optimized variants are rechecked for security but are outside that preservation proof, and binary security still depends on backend and hardware assumptions. On 24 cryptographic entries tested on a bare-metal Intel processor, VellSSLH had 4.03% lower geometric-mean runtime than LLVM SLH (13 comparisons favored VellSSLH, eight favored LLVM SLH, and three were inconclusive). For X25519, it was 22.69% faster than LLVM SLH with 1.86% overhead over unprotected code; it also had 19.65% lower runtime than Ultimate SLH.

### Source excerpt

arXiv:2611.18463v1 Announce Type: new Abstract: Constant-time cryptographic programs written in C can still leak secrets during speculative execution. Mispredicted branches may allow instructions to access secret data and expose it through observable behavior. Speculative load hardening (SLH) addresses these leaks, but protecting values unnecessarily can introduce significant runtime overhead. We present VellSSLH, which selectively inserts speculative load hardening at LLVM IR. Programmers specify Public and Secret inputs in annotated C programs, and our analysis infers which values may become secret during speculation. The transformation then inserts misspeculation-flag operations and protections only where needed. VellSCT, our extracted checker, validates the resulting LLVM IR. We formalize speculative constant-time (SCT) security by extending Vellvm's LLVM semantics with speculative execution, attacker directives, and leakage observations. Our security type system reasons about SSA joins, symbolic values, poison, pointer provenance, and observable faults, and supports declared declassifications and trusted external services. In Rocq, we prove that programs accepted by the checker satisfy SCT, and that a reference hardening transformation preserves architectural behavior. Evaluated optimized variants are rechecked for SCT but are not covered by this preservation proof. Our mechanized guarantees apply at LLVM IR; security of the generated binary additionally depends on backend and hardware assumptions. We evaluate VellSSLH on 24 cryptographic entries on a bare-metal Intel processor. VellSSLH achieves 4.03% lower geometric-mean runtime than LLVM SLH, with 13 comparisons favoring VellSSLH, eight favoring LLVM SLH, and three inconclusive. For X25519, VellSSLH improves runtime by 22.69% over LLVM SLH with only 1.86% overhead over unprotected code. Compared with Ultimate SLH, VellSSLH achieves 19.65% lower runtime.

## Meta Build Systems as Logic Programs

DevFeed: [Meta Build Systems as Logic Programs](<https://devfeed.tech/articles/meta-build-systems-as-logic-programs-136505.md>)

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

Author: Alex Reinking

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

Content type: article

Language: en

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

Topics: [Build tool](<https://devfeed.tech/topics/build-tool.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [CMake](<https://devfeed.tech/topics/cmake.md>), [bazel](<https://devfeed.tech/topics/bazel.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Qt](<https://devfeed.tech/topics/qt.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [account](<https://devfeed.tech/tags/account.md>), [android](<https://devfeed.tech/tags/android.md>), [annotations](<https://devfeed.tech/tags/annotations.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [bazel](<https://devfeed.tech/tags/bazel.md>), [build](<https://devfeed.tech/tags/build.md>), [build-system](<https://devfeed.tech/tags/build-system.md>), [build-systems](<https://devfeed.tech/tags/build-systems.md>), [builds](<https://devfeed.tech/tags/builds.md>), [can](<https://devfeed.tech/tags/can.md>), [case](<https://devfeed.tech/tags/case.md>), [case-studies](<https://devfeed.tech/tags/case-studies.md>), [cases](<https://devfeed.tech/tags/cases.md>), [central](<https://devfeed.tech/tags/central.md>), [choice](<https://devfeed.tech/tags/choice.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [logic](<https://devfeed.tech/tags/logic.md>), [meta](<https://devfeed.tech/tags/meta.md>), [systems](<https://devfeed.tech/tags/systems.md>)

### AI overview

buildlog models build configuration as relational inference: project objects, flags, libraries, and language standards are derived from sources, dependencies, and requirements, while impure machine probes are isolated to fact discovery. It rejects ambiguous toolchain or package selection, tracks provenance, and keeps author constraints separate from user preferences. Libraries can provide consumer rules, and compiled build tools can have their build-machine configuration inferred. In a Halide case study, buildlog derives build-machine and target configurations in one graph for generators that emit WebAssembly or Android code, where CMake requires nested builds. Evaluation covers eleven case studies across ten projects, with execution and artifact checks; the abstract also reports remaining flag differences and platform limits. Formal guarantees depend on stated finiteness and probe obligations.

### Source excerpt

arXiv:2611.17672v1 Announce Type: cross Abstract: Meta build systems such as CMake, Meson and Bazel derive command graphs from project descriptions, user choices and machine facts. Imperative scripts, search paths and special cases make routine decisions interact poorly: search order can choose compatible packages without an explicit project choice, packagers must patch author flag preferences, and cross-builds need annotations or nested build trees for tools run during the build. Our central insight is to express configuration as relational inference: objects follow from sources, flags and libraries from dependencies, and language standards from transitive requirements. We introduce buildlog, a meta build system whose stratified logical core isolates build derivation from impure environmental probes. It rejects ambiguity in toolchain or package selection and explains derived facts through provenance. Author constraints and user preferences use distinct, statically checked input relations. Libraries can ship consumer rules, including Qt's moc/rcc rules, using the same facts for installed and built code. Using a compiled program in a build rule lets buildlog infer its build-machine configuration. We evaluate buildlog on eleven case studies of ten projects, validating configurations through execution and artifact checks while reporting remaining flag differences and platform limits. In Halide, generators link an LLVM-based compiler and run during the build to emit WebAssembly or Android code; where CMake requires nested builds, buildlog derives build-machine and target-platform configurations in one graph. A supporting formal account establishes termination, within-round probe-order independence, and agreement between fresh and validated cached runs under explicit finiteness and probe obligations. The results show that confining impurity to fact discovery yields a small, uniform and explainable configuration semantics.

## AMD AOCC 6.0 Brings Zen 6 Optimizations, New "aof" Fortran Compiler, aoc / aoc++ Branding

DevFeed: [AMD AOCC 6.0 Brings Zen 6 Optimizations, New "aof" Fortran Compiler, aoc / aoc++ Branding](<https://devfeed.tech/articles/amd-aocc-6-0-brings-zen-6-optimizations-new-aof-fortran-compiler-aoc-aoc-branding-128043.md>)

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

Author: Michael Larabel

Published: 2026-11-11T10:54:19Z

Content type: release

Language: en

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

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [clang](<https://devfeed.tech/topics/clang.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Fortran](<https://devfeed.tech/topics/fortran.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [aoc](<https://devfeed.tech/tags/aoc.md>), [branding](<https://devfeed.tech/tags/branding.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [fortran](<https://devfeed.tech/tags/fortran.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>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [zen-6](<https://devfeed.tech/tags/zen-6.md>)

### AI overview

AMD AOCC 6.0 adds initial Zen 6 optimizations for EPYC 9006 processors, including Zen 6 tuning in AOCL-LibM 6.0. It introduces aof as AMD's new Fortran compiler, described as on par with upstream LLVM Flang and offering improved conformance to current Fortran and OpenMP standards; the modified Flang compiler remains in the release. The C and C++ compiler binaries are now branded aoc and aoc++, with clang and clang++ symlinked to them. AOCC 6.0 is based on LLVM 21.1.8, rather than the newer LLVM 22 or 23 series. The excerpt says benchmarks against upstream LLVM/Clang and GCC were planned, but provides no results.

### Source excerpt

With yesterday's launch availability of the AMD EPYC 9006 "Venice" SP7 processors headlined by the incredibly fast EPYC 9996 and EPYC 9686F processors, AMD also launched AOCC 6.0 as the newest version of their in-house LLVM/Clang-based compiler stack...

## Proving the Wrong Program: Miscompilations as a Threat to zkVM Guarantees

DevFeed: [Proving the Wrong Program: Miscompilations as a Threat to zkVM Guarantees](<https://devfeed.tech/articles/proving-the-wrong-program-miscompilations-as-a-threat-to-zkvm-guarantees-116157.md>)

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

Author: Hui Xuan Tan, Stefanos Chaliasos, Alastair F. Donaldson

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

Content type: article

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Zero-knowledge proof](<https://devfeed.tech/topics/zkp.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>), [rust](<https://devfeed.tech/tags/rust.md>), [virtual-machine](<https://devfeed.tech/tags/virtual-machine.md>), [zero-knowledge](<https://devfeed.tech/tags/zero-knowledge.md>)

### AI overview

The study finds that compiler miscompilations can undermine zkVM guarantees even when the zkVM and guest source are correct. Among 88 known rustc and LLVM bugs tested, 48 caused wrong outputs on SP1 and 46 on Jolt; many others did not reproduce because their faulty code was unreachable on the target. Accidental effects on existing guests appeared uncommon: across 552 buildable guest-bug pairs from 13 guests in 10 SP1 projects, 447 produced byte-identical binaries, while the rest had the same code or agreed on tested inputs. By contrast, an LLM agent found source-preserving, optimization-like patches that exposed bugs in 12 of 366 project-bug pairs across 11 of 20 projects. Four led to wrong outputs, including an Ethereum client rejecting a valid block; eight caused failures on valid inputs. The authors recommend treating the compiler as part of the trusted base and tracking known toolchain bugs.

### Source excerpt

arXiv:2611.04701v1 Announce Type: cross Abstract: A zero-knowledge virtual machine (zkVM) lets an untrusted prover convince a verifier that a program, typically Rust compiled to RISC-V, ran correctly. The proof covers the compiled binary, so a miscompilation can make a correct zkVM produce a valid proof of a computation that differs from the developer's source. We present the first empirical study of miscompilation as a threat to zkVM guarantees, on the production zkVMs SP1 and Jolt. We assemble 88 known rustc and LLVM miscompilations with Rust reproducers, using an LLM agent to recover Rust triggers for 60 of 124 LLVM bugs reported only as LLVM IR. Many of the bugs carry over to zkVMs: 48 of the 88 make a guest commit a wrong output on SP1 and 46 on Jolt, including the same 15 rustc bugs on both. Most bugs that do not reproduce never reach the faulty code on the zkVM's target, e.g. because they need an instruction-set extension. Existing guest programs are rarely affected by accident. Across 13 guests of 10 popular SP1 projects, the buggy and the fixed compiler produce byte-identical binaries in 447 of the 552 guest-bug pairs that build, and the other 105 have the same code or agree on every input we ran. An attacker who contributes code to a guest, however, can trigger these bugs on purpose. For about $40 per project, an LLM agent found patches that look like ordinary optimisations, preserve the behaviour of the guest's source, and expose a known bug in 12 of 366 project-bug pairs, across 11 of 20 projects. In four cases the guest commits a wrong output, including an Ethereum client that rejects a valid block, and in the other eight it fails on a valid input. Reviewing or formally verifying the zkVM or the guest's source cannot catch such a patch, because both are correct. zkVM projects should treat their compiler as part of their trusted base and track the known bugs of their toolchain.

## APG: Agentic Static-Analysis Infrastructure on LLVM-IR Graph Databases

DevFeed: [APG: Agentic Static-Analysis Infrastructure on LLVM-IR Graph Databases](<https://devfeed.tech/articles/apg-agentic-static-analysis-infrastructure-on-llvm-ir-graph-databases-113524.md>)

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

Author: Zexin Zhong, Yanjun Zhang, Yulei Sui, Xiao Cheng

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

Content type: article

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>)

Tags: [agentic](<https://devfeed.tech/tags/agentic.md>), [apg](<https://devfeed.tech/tags/apg.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [graph-databases](<https://devfeed.tech/tags/graph-databases.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llm-agents](<https://devfeed.tech/tags/llm-agents.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-ir](<https://devfeed.tech/tags/llvm-ir.md>), [program-analysis](<https://devfeed.tech/tags/program-analysis.md>), [provenance](<https://devfeed.tech/tags/provenance.md>), [query](<https://devfeed.tech/tags/query.md>), [repair](<https://devfeed.tech/tags/repair.md>), [static-analysis](<https://devfeed.tech/tags/static-analysis.md>), [token-consumption](<https://devfeed.tech/tags/token-consumption.md>)

### AI overview

APG helps LLM coding agents investigate programs through semantics-grounded static analysis. Built on SVF and LLVM, it exposes 38 atomic capabilities that agents can select and combine for cross-graph queries; safeguards and evidence traces make results and provenance inspectable. In benchmark repair runs, 35 capabilities had first-attempt query-generation success above 50%, including 13 at 100%. Across 812 C/C++ defects, APG outperformed the evaluated baselines. Compared with Passive Graph Push, it raised first-iteration repair success by 17.6 and 18.0 percentage points on two benchmark collections and cut average LLM input-token use by 90.8%. These results are limited to the reported benchmarks and comparison.

### Source excerpt

arXiv:2611.02349v1 Announce Type: new Abstract: LLM-based coding agents increasingly rely on external program knowledge, yet access to static-analysis graphs alone does not ensure appropriate operation selection or evidence interpretation. We present APG, an infrastructure for semantics-grounded static program analysis. Built on SVF and LLVM, it decomposes compiler-derived program analyses into atomic capabilities that LLM agents can select, compose, and orchestrate for goal-directed, cross-graph investigation, with query safeguards and evidence traces preserving inspectable results and provenance. APG provides 38 atomic capabilities. On analysis requests arising during benchmark repair runs, 35 achieve first-attempt query-generation success rates above 50%, including 13 at 100%. Evaluation on 812 C/C++ defects shows higher repair success than the evaluated baselines. Compared with Passive Graph Push, APG improves first-iteration repair success by 17.6 and 18.0 percentage points on the two benchmark collections and reduces average LLM input-token consumption by 90.8%. Our tool is available at https://github.com/JasonZhongZexin/APG-ICSE-Demo and its demonstration video at https://youtu.be/vkuExZUjGnw

## GSoC 2026: Enable float80/float128 on Unsupported Targets for LLVM libc

DevFeed: [GSoC 2026: Enable float80/float128 on Unsupported Targets for LLVM libc](<https://devfeed.tech/articles/gsoc-2026-enable-float80-float128-on-unsupported-targets-for-llvm-libc-122899.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-22-gsoc-float80-and-float128-in-llvm-libc/>)

Author: Sukumar Sawant

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

Content type: news

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [floating-point](<https://devfeed.tech/topics/floating-point.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [clang](<https://devfeed.tech/topics/clang.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [64-bit](<https://devfeed.tech/tags/64-bit.md>), [clang](<https://devfeed.tech/tags/clang.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [computer-science](<https://devfeed.tech/tags/computer-science.md>), [emulation](<https://devfeed.tech/tags/emulation.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [google](<https://devfeed.tech/tags/google.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [ieee](<https://devfeed.tech/tags/ieee.md>), [india](<https://devfeed.tech/tags/india.md>), [libc](<https://devfeed.tech/tags/libc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>), [msvc](<https://devfeed.tech/tags/msvc.md>), [mumbai](<https://devfeed.tech/tags/mumbai.md>), [software](<https://devfeed.tech/tags/software.md>), [windows](<https://devfeed.tech/tags/windows.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

LLVM libc added software-emulated `Float128` and `Float80` so high-precision math code can build and be tested on targets lacking the corresponding native formats. The work added emulation types, operators and conversions, integrated them into floating-point support, and migrated `float128` math functions incrementally. A Windows build failure traced to `BigInt`'s zero-initialized member making it non-trivially constructible; moving initialization into constructors made `bit_cast` accept it. Testing also exposed ABI differences between native and emulated types, so migrated functions use emulation internally while retaining native `float128` parameters and returns when available. The article reports support for building and testing the types without native support and enabling `float128` functions on Windows with MSVC, macOS and GPU targets. Remaining work includes migrating more functions, adding explicit `float80` entrypoints and comparing performance.

### Source excerpt

Introduction Hello LLVM Community! I am Sukumar Sawant, Computer Science student at Mumbai University (VIT Mumbai), India. I had the pleasure of working on the project on introducing float80 and float128 (emulated) in LLVM libc as part of Google Summer of Code 2026 along with my mentors Tue Ly, Nicolas Celik and Krishna Pandey. "Why"? float80 and float128 are the two extended-precision floating-point formats LLVM libc supports. float80 is the 80-bit x87 extended precision format, with 1 sign bit, 15 exponent bits, and a 64-bit significand carrying an explicit integer bit. float128 is the IEEE 754 binary128 ("quad precision") format, with 1 sign bit, 15 exponent bits, and 112 stored mantissa bits. Both formats are already natively supported on several platforms, but not on all of them. For example: MSVC on Windows treats long double as a 64-bit double and has no native __float128 type. AArch64 targets typically use a 128-bit long double, but lack the 80-bit extended precision format entirely. Clang on certain non-x86 targets may not enable __float128 by default. This matters because LLVM libc needs to build and test its high-precision math routines consistently across every target it supports, not just the ones where these types happen to exist natively. Where the compiler provides no native type, the templated implementations cannot be compiled at all. The goal of this project was to lift that restriction by emulating both formats in software, so that the same templated implementations build and run everywhere, producing identical results whether the underlying type is native or emulated. The exact goals of this project were to: Add software emulation classes for the float80 and float128 formats. Provide the operator overloads and conversions needed for these classes to be used in place of the native types. Integrate the emulated types into the existing floating-point support infrastructure. Modify the existing float128 math functions to work correctly with the emul

## Maintainer spotlight: Anthony Bolden (@Walnut356)

DevFeed: [Maintainer spotlight: Anthony Bolden (@Walnut356)](<https://devfeed.tech/articles/maintainer-spotlight-anthony-bolden-walnut356-113396.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/inside-rust/2026/11/02/maintainer-spotlight-anthony-bolden-walnut356/>)

Author: Jakub Beránek

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

Content type: article

Language: en

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

Topics: [Tool](<https://devfeed.tech/topics/tool.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [Programming language](<https://devfeed.tech/topics/programming-language.md>), [Maintainers](<https://devfeed.tech/topics/maintainers.md>), [Python](<https://devfeed.tech/topics/python.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [google-summer-of-code](<https://devfeed.tech/tags/google-summer-of-code.md>), [programming](<https://devfeed.tech/tags/programming.md>), [rust](<https://devfeed.tech/tags/rust.md>), [spotlight](<https://devfeed.tech/tags/spotlight.md>)

### AI overview

Anthony Bolden's work has focused on making Rust debugging more usable on Windows, especially for programs built with MSVC. After Rust toolchains did not distribute debuginfo visualizers on Windows and compiler debuginfo tests did not work there, he contributed fixes and worked to improve the tests. He says the Rust build command worked on his first attempt, while trying to work with LLVM on Windows had been frustrating. His Google Summer of Code project improved compiler debuginfo testing; afterward, he joined the Rust compiler team. His planned work includes better visualizers for `Vec` and wide pointers, hashmap indexing, and performance improvements. He says proposed LLDB plugin interface changes might enable native Rust debugging integration, improved expression parsing, and possible miri integration. He also suggests shipping visualizers written in Rust. Bolden advises new Rust programmers to experiment and investigate compiler errors rather than focusing too early on best practices.

### Source excerpt

There are hundreds of people who maintain the Rust toolchain, often on a volunteer basis on top of another job. The Rust Content team is working on a series of blog posts highlighting some of these prolific contributors to recognize the awesome work that they are doing in order to make Rust better for everyone. You can find the previous post here. Consider donating to the Rust Foundation Maintainers Fund if you'd like to support Rust Project maintainers. In this post, we would like to introduce Anthony Bolden (@Walnut356). Anthony is a self-taught programmer who went on a mission to improve the Rust debugger experience. This year, he participated as a contributor in the Google Summer of Code program, and recently he joined the Rust compiler team. We interviewed Anthony to find out what brought him to programming and how he became an expert on debuggers. Read more below! Can you briefly introduce yourself and tell us how you started with programming? Hello, my name is Anthony Bolden, also known as @Walnut356, and I live in Wisconsin. I do not have any formal computer science education and I've never had a job in the tech industry, so my journey to programming was a bit different. I work overnight shifts in a hotel, where I often have a lot of time to spare, and I needed something to occupy my mind. For I while, I used to solve puzzles or read books, but eventually I got tired of that. I wanted to find a long-term project, so I tried programming. It took me a couple of tries until it "clicked", but when that happened, I instantly fell in love with it. It is so much fun! How did you discover Rust? I bought a couple of C++ books when I was learning how to program, so that was my entrypoint. But I was very dissatisfied with the development experience there. I wanted to make a simple game, because I've always found game design fascinating, but adding a dependency like SDL to my project turned out to be very difficult. I spent SO MUCH time trying to get it to work, and it

## Beating the compiler at signed 32-bit division

DevFeed: [Beating the compiler at signed 32-bit division](<https://devfeed.tech/articles/beating-the-compiler-at-signed-32-bit-division-110587.md>)

Original publisher: [Read original article](<https://lemire.me/blog/2026/10/31/beating-the-compiler-at-signed-32-bit-division/>)

Author: Daniel Lemire

Published: 2026-10-31T13:05:35Z

Content type: article

Language: en

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

Topics: [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [clang](<https://devfeed.tech/topics/clang.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [32-bit](<https://devfeed.tech/tags/32-bit.md>), [64-bit](<https://devfeed.tech/tags/64-bit.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [apple](<https://devfeed.tech/tags/apple.md>), [arm](<https://devfeed.tech/tags/arm.md>), [arrow](<https://devfeed.tech/tags/arrow.md>), [autovectorization](<https://devfeed.tech/tags/autovectorization.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [branch](<https://devfeed.tech/tags/branch.md>), [c](<https://devfeed.tech/tags/c.md>), [clang](<https://devfeed.tech/tags/clang.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cycles](<https://devfeed.tech/tags/cycles.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [latency](<https://devfeed.tech/tags/latency.md>), [performance](<https://devfeed.tech/tags/performance.md>), [processor](<https://devfeed.tech/tags/processor.md>), [zen-5](<https://devfeed.tech/tags/zen-5.md>)

### AI overview

A signed 32-bit division optimization can use an unsigned 33-bit reciprocal multiplier on 64-bit processors, avoiding the compiler's correction step when that multiplier does not fit a signed 32-bit value. The article gives a `div32` implementation for positive, non-power-of-two constant divisors and reports lower dependency-chain latency for divisors 7, 60, and 365; throughput gains vary by compiler and processor. For divisor 1000, where the compiler's multiplier fits signed 32 bits, the new method is slightly slower on Apple M4, so the author recommends using it only when correction is needed. For runtime divisors, a revised `fastmod` signed multiplication removes a sign-dependent branch: in the reported random-sign test it is over twice as fast as hardware division on Intel and enables partial loop vectorization on M4 when autovectorization is allowed.

### Source excerpt

Dividing integers is slow on our processors. A 32-bit division costs: processor latency throughput Emerald Rapids about 12 cycles one every 6 cycles Zen 4 9 to 12 cycles one every 6 cycles Zen 5 10 to 13 cycles one every 6 cycles Arrow Lake performance core 12 cycles one every 6 cycles Apple M4 ... Continue reading Beating the compiler at signed 32-bit division

## A Multi-Dimensional, Per-Pass Empirical Study of the LLVM Optimization Pipeline

DevFeed: [A Multi-Dimensional, Per-Pass Empirical Study of the LLVM Optimization Pipeline](<https://devfeed.tech/articles/a-multi-dimensional-per-pass-empirical-study-of-the-llvm-optimization-pipeline-96623.md>)

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

Author: Federico Bruzzone, Walter Cazzola

Published: 2026-10-23T04:00:00Z

Content type: article

Language: en

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

Topics: [Programming Languages / Compilers](<https://devfeed.tech/topics/programming-languages-compilers.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [performance-optimization](<https://devfeed.tech/topics/performance-optimization.md>)

Tags: [analysis](<https://devfeed.tech/tags/analysis.md>), [cs-pf](<https://devfeed.tech/tags/cs-pf.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [energy](<https://devfeed.tech/tags/energy.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [measurement](<https://devfeed.tech/tags/measurement.md>), [measurements](<https://devfeed.tech/tags/measurements.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [model-calibration](<https://devfeed.tech/tags/model-calibration.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pass](<https://devfeed.tech/tags/pass.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [rust](<https://devfeed.tech/tags/rust.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

The LLVM -O3 pipeline is non-monotone on the 30 compute-bound PolyBench/C kernels studied: 36% of runtime-changing transitions that were significant were regressions, appearing in 28 kernels. The study measures 113 cumulative per-pass prefixes across runtime, compile time, binary size, hardware counters, and RAPL energy, using byte-identical binary transitions to calibrate significance. Speedups tend to arrive late and cluster in a small group of passes; the median kernel requires 84.8% of the pipeline to reach 80% of its speedup. IR instruction count poorly predicts runtime, while runtime-targeted passes also reduce energy by 30-60% in this study. The authors bound speedup lost to non-monotonicity at 46.35%, attributing 9.7 points to measurement noise, 15.3 to dips repaired within three passes, and 21.3 to effects persisting at pipeline end.

### Source excerpt

arXiv:2606.31238v2 Announce Type: replace Abstract: Quantifying the marginal impact of individual optimization passes underpins phase ordering, pass selection, optimization design, and analysis of pass/hardware interactions. In LLVM, the standard backend for C/C++, Rust, and ML stacks via MLIR, interactions among passes, measurement noise, and pipeline scale make this difficult. We present a systematic empirical study of the LLVM -O3 pipeline. We decompose it into 113 cumulative per-pass prefixes and measure execution time, compile time, binary size, hardware counters, and RAPL energy on 30 PolyBench/C kernels (84,750 measurements). Transitions whose binary is byte-identical to their predecessor give us a built-in null distribution, which we use to calibrate every significance claim. On these compute-bound affine kernels, the pipeline is non-monotone: 36% of the transitions that significantly change runtime are regressions, found in 28 of 30 kernels. Gains are back-loaded (the median kernel needs 84.8% of the pipeline for 80% of its speedup) and concentrated in a small core of passes, a result that holds under both absolute and scale-free impact measures. IR instruction count is an unreliable runtime predictor, and runtime-targeted passes are de facto energy-targeted (30-60% savings). Finally, we bound the speedup lost to non-monotone behavior from above by 46.35% and decompose it: 9.7 points are measurement noise, 15.3 points are transient dips repaired within three passes, and only 21.3 points persist to the end of the pipeline. These findings inform pass pruning, cost-model calibration, and autotuning.

## ATLAS: A Multi-Agent Framework for Lifting Binary to Canonical Compiler IR

DevFeed: [ATLAS: A Multi-Agent Framework for Lifting Binary to Canonical Compiler IR](<https://devfeed.tech/articles/atlas-a-multi-agent-framework-for-lifting-binary-to-canonical-compiler-ir-96654.md>)

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

Author: Xiaoao Zhu, Ni Zhang, Jie Ren, Zhiqiang Li, Jie Zheng, Zhanyong Tang, Zheng Wang

Published: 2026-10-23T04:00:00Z

Content type: article

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Multi Agent Systems](<https://devfeed.tech/topics/multi-agent-systems.md>), [Cross-Compilation](<https://devfeed.tech/topics/cross-compilation.md>)

Tags: [agent-framework](<https://devfeed.tech/tags/agent-framework.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [arm](<https://devfeed.tech/tags/arm.md>), [atlas](<https://devfeed.tech/tags/atlas.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [c](<https://devfeed.tech/tags/c.md>), [canonical](<https://devfeed.tech/tags/canonical.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [control](<https://devfeed.tech/tags/control.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [data](<https://devfeed.tech/tags/data.md>), [diagnostics](<https://devfeed.tech/tags/diagnostics.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [flow](<https://devfeed.tech/tags/flow.md>), [generation](<https://devfeed.tech/tags/generation.md>), [humaneval](<https://devfeed.tech/tags/humaneval.md>), [instructions](<https://devfeed.tech/tags/instructions.md>), [intermediate](<https://devfeed.tech/tags/intermediate.md>), [ir](<https://devfeed.tech/tags/ir.md>), [multi-agent](<https://devfeed.tech/tags/multi-agent.md>)

### AI overview

ATLAS reconstructs canonical, pre-optimization LLVM IR from stripped, optimized binaries through structure-aware retrieval and an iterative three-agent repair loop. A Lift agent drafts IR using retrieved exemplars; an Advisor interprets verifier, compiler, and static-check diagnostics to suggest localized fixes; and a Validation agent applies changes and reruns verification and, when available, runtime checks. Iteration ends when the IR is verifier-clean and behaviorally consistent or a budget limit is reached. On HumanEval-Decompile and MBPP across ARM, x86-64, and RISC-V, the authors report 91.8% re-executability and 89.4% CFG similarity, outperforming seven baselines. They also report greater pointer-flow precision and downstream analyzability than Binary-to-C-to-IR pipelines.

### Source excerpt

arXiv:2610.30877v1 Announce Type: new Abstract: Lifting stripped, heavily optimized binaries to a canonical, pre-optimization LLVM intermediate representation (IR) is essential for downstream security analysis and legacy software migration when source code is unavailable. However, aggressive compiler optimizations rewrite control and data flow, remove structural metadata, and introduce type-erased low-level idioms, causing current lifters to produce malformed or semantically divergent IR. We present ATLAS, a multi-agent framework designed to reconstruct formally valid and canonical LLVM IR from optimized disassembly.ATLAS combines (i) Structure-aware, region-level retrieval, which utilizes pseudo-probe attribution to align optimized instructions with canonical IR exemplars, and (ii) a collaborative refinement loop that closes the gap between probabilistic generation and deterministic compiler constraints. Concretely, a Lift agent generates an initial IR draft conditioned on retrieved exemplars, an Advisor agent interprets LLVM verifier/compilation diagnostics and static checks to propose localized repair actions, and a Validation agent applies the edits, re-runs toolchain verification and (when available) runtime checks, and feeds the resulting diagnostics back to the Advisor. The agents iterate until the IR is verifier-clean and behaviorally consistent, or a budget limit is reached. On HumanEval-Decompile and MBPP, ATLAS outperforms seven baselines on lifting LLVM IR, achieving 91.8% re-executability and 89.4% CFG similarity across ARM, x86-64, and RISC-V binaries. Moreover, our evaluation demonstrates that ATLAS also outperforms the Binary to C to IR pipelines in pointer-flow precision and downstream analyzability. By recovering a well-formed, machine-centric representation, ATLAS enables practical cross-ISA recompilation and verifiable binary-only migration workflows.

## Announcing Rust 1.99.1

DevFeed: [Announcing Rust 1.99.1](<https://devfeed.tech/articles/announcing-rust-1-99-1-88066.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/10/15/Rust-1.99.1/>)

Author: The Rust Release Team

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

Content type: release

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [D](<https://devfeed.tech/topics/d.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [ffi](<https://devfeed.tech/tags/ffi.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [macos](<https://devfeed.tech/tags/macos.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [rust](<https://devfeed.tech/tags/rust.md>), [rust-1-99](<https://devfeed.tech/tags/rust-1-99.md>), [uefi](<https://devfeed.tech/tags/uefi.md>)

### AI overview

Rust 1.99.1 is a point release that fixes regressions involving missing `wcslen` symbols, x86_64 FFI `bool` return values, and rust-lld's ability to load libLLVM on macOS. The announcement also suggests testing future releases on the beta and nightly channels.

### Source excerpt

The Rust team has published a new point release of Rust, 1.99.1. Rust is a programming language that is empowering everyone to build reliable and efficient software. If you have a previous version of Rust installed via rustup, getting Rust 1.99.1 is as easy as: rustup update stable If you don't have it already, you can get rustup from the appropriate page on our website. What's in 1.99.1 Rust 1.99.1 fixes the following regressions from prior releases: Missing symbol wcslen: Some Rust targets were getting link errors for missing wcslen, and that function is now present in Rust's compiler-builtins library as a fallback. The LLVM loop-idiom-wcslen pass may introduce calls to wcslen as an optimization, and some Rust targets did not have that function readily available in libc or elsewhere. The UEFI targets in particular were broken for any project using std, as some of these calls were introduced in the precompiled standard library, but the issue was also reproducible for similar user code patterns. Miscompilation of FFI bool return values on x86_64: Rust functions returning bool through FFI could leave bits 1-7 of the return register unspecified, causing callers to observe raw values other than 0 or 1. This return type is now marked for zero-extension again, as required by the ABI. rust-lld failed to load libLLVM on macOS: This linker could fail to run if the compiler was invoked without the rustup proxy, as there was no direct setting for the appropriate library search path. Now rust-lld is built with an rpath entry for the directory containing libLLVM.dylib. If you'd like to help us out by testing future releases, you might consider using the beta (rustup default beta) and nightly (rustup default nightly) channels locally and in your CI. Please report any bugs you might come across! Contributors to 1.99.1 Many people came together to create Rust 1.99.1. We couldn't have done it without all of you. Thanks!

## Apple Contributes SSAF Driver To LLVM Clang For Source Code Transformations

DevFeed: [Apple Contributes SSAF Driver To LLVM Clang For Source Code Transformations](<https://devfeed.tech/articles/apple-contributes-ssaf-driver-to-llvm-clang-for-source-code-transformations-87061.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Apple-Clang-SSAF-Driver>)

Author: Michael Larabel

Published: 2026-10-14T18:45:29Z

Content type: news

Language: en

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

Topics: [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-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>), [llvm](<https://devfeed.tech/tags/llvm.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>), [program-analysis](<https://devfeed.tech/tags/program-analysis.md>), [pull-request](<https://devfeed.tech/tags/pull-request.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Apple contributed clang-ssaf-driver to LLVM/Clang for running source transformations across projects during builds. The driver can generate patches and reports, and its first transformation rewrites C++ raw pointers and arrays to bounded_ptr and bounded_array.

### Source excerpt

Apple compiler engineers have contributed to upstream LLVM/Clang today a Scalable Static Analysis Framework (SSAF) driver for whole-program based analysis and source-to-source code transformations...

## AMD ROCm 10.1 Targets Storage Bottlenecks with hipFILE Fast-Path, NUMA Memory Allocation, and LLVM 24

DevFeed: [AMD ROCm 10.1 Targets Storage Bottlenecks with hipFILE Fast-Path, NUMA Memory Allocation, and LLVM 24](<https://devfeed.tech/articles/amd-rocm-10-1-targets-storage-bottlenecks-with-hipfile-fast-path-numa-memory-allocation-and-llvm-24-66838.md>)

Original publisher: [Read original article](<https://www.storagereview.com/news/amd-rocm-10-1-hipfile-fast-path-numa-memory-llvm-24>)

Author: Harold Fritts

Published: 2026-10-07T15:46:34Z

Content type: release

Language: en

Sources: [StorageReview.com](<https://devfeed.tech/sources/storagereview-com.md>)

Topics: [rocm](<https://devfeed.tech/topics/rocm.md>), [NUMA](<https://devfeed.tech/topics/numa.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [restic](<https://devfeed.tech/topics/restic.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [amd](<https://devfeed.tech/tags/amd.md>), [bottlenecks](<https://devfeed.tech/tags/bottlenecks.md>), [enterprise](<https://devfeed.tech/tags/enterprise.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [numa](<https://devfeed.tech/tags/numa.md>), [release](<https://devfeed.tech/tags/release.md>), [rocm](<https://devfeed.tech/tags/rocm.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

AMD ROCm 10.1 expands Infinity Storage with asynchronous hipFILE reads and writes, batched I/O, and NUMA-aware host memory placement to improve storage-to-GPU data movement. The release also updates ROCm CLI and profiling tools, moves the toolchain to LLVM 24, and adds compiler, library, and platform changes.

### Source excerpt

AMD ROCm 10.1, released October 5, puts its weight on the path between storage and the GPU. Checkpoint files, key-value caches, and model weights now routinely outgrow accelerator memory, and when they do, the time spent moving data starts to govern iteration time more than the math does. The release builds out AMD Infinity Storage, The post AMD ROCm 10.1 Targets Storage Bottlenecks with hipFILE Fast-Path, NUMA Memory Allocation, and LLVM 24 appeared first on StorageReview.com.

## Intel Compiler Engineer Shares Latest Project Gains For APX

DevFeed: [Intel Compiler Engineer Shares Latest Project Gains For APX](<https://devfeed.tech/articles/intel-compiler-engineer-shares-latest-project-gains-for-apx-65665.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Intel-APX-Projected-Gains>)

Author: Michael Larabel

Published: 2026-10-06T09:54:17Z

Content type: news

Language: en

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

Topics: [gcc](<https://devfeed.tech/topics/gcc.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [intel](<https://devfeed.tech/topics/intel.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [QCon San Francisco 2025](<https://devfeed.tech/topics/qcon-san-francisco-2025.md>)

Tags: [binutils](<https://devfeed.tech/tags/binutils.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [conference](<https://devfeed.tech/tags/conference.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [intel](<https://devfeed.tech/tags/intel.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>), [llvm](<https://devfeed.tech/tags/llvm.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>), [processors](<https://devfeed.tech/tags/processors.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

At the GNU Tools Cauldron 2026, Intel presented projected performance gains from Advanced Performance Extensions (APX), based on SPEC CPU 2017 simulations: more than 10% fewer loads, more than 20% fewer stores, and more than 10% fewer instructions. The article also describes GCC and LLVM support status and AMD's work on AI Compute Extensions.

### Source excerpt

Last week at the GNU Tools Cauldron 2026 conference in Prague there was an x86 BOF with presentations both by AMD and Intel compiler engineers. There are a few interesting nuggets out of that with both Advanced Performance Extensions (APX) and AI Compute Extensions (ACE) talked about as part of their ongoing enablement in the GCC compiler...

## GSOC26: Sharing LLVM-libc's floating-point routines with compiler-rt

DevFeed: [GSOC26: Sharing LLVM-libc's floating-point routines with compiler-rt](<https://devfeed.tech/articles/gsoc26-sharing-llvm-libc-s-floating-point-routines-with-compiler-rt-64734.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-24-gsoc-sharing-libc-with-compiler-rt/>)

Author: Mohamed Emad

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

Content type: article

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [floating-point](<https://devfeed.tech/topics/floating-point.md>)

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [build](<https://devfeed.tech/tags/build.md>), [builtins](<https://devfeed.tech/tags/builtins.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-rt](<https://devfeed.tech/tags/compiler-rt.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [headers](<https://devfeed.tech/tags/headers.md>), [libc](<https://devfeed.tech/tags/libc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>)

### AI overview

The LLVM project describes sharing LLVM-libc floating-point math routines with compiler-rt, replacing duplicated soft-float implementations with thin wrappers that forward to shared routines. The approach is opt-in through a CMake macro, and the article covers implementation challenges involving recursive builtin calls, 16-bit formats, x87 extended precision, symbol conflicts, and generating wrappers, build entries, and tests. Benchmarking and optimization are planned, while some comparison and conversion work remains under review.

### Source excerpt

Introduction Hello LLVM community! I am Mohamed Emad, CSE student at Zagazig University, Egypt. This summer I worked on the next step of the Hand-in-Hand project, an effort that began in 2024 with #91651 to make LLVM-libc a shared foundation that the rest of LLVM can build on. My part was to share LLVM-libc's floating-point math routines with compiler-rt. It replaces compiler-rt's existing builtins, which were written from scratch in C and assembly with a separate implementation per architecture, with LLVM-libc's code, which is well-tested and well-maintained. Overview When a program targets hardware without a floating-point unit, the compilercannot emit an fadd or fcvt instruction. Instead it emits a call to a helperroutine: __adddf3 to add two doubles, __fixdfsi to convert a double to anint, __letf2 to compare two float128s. compiler-rt's builtins libraryships these routines, and it has carried its own soft-float implementations ofthem for years. LLVM-libc implements the same math independently, with correctly-rounded resultsand a large test suite behind it. So the project starts from an awkward fact:LLVM keeps two separate soft-float implementations of the same operations. Twocopies drift apart, each needs its own review and testing, and a bug fixed inone rarely reaches the other. compiler-rt's versions are also older and lessrigorously verified than libc's. This project gives compiler-rt one source of truth. LLVM-libc exposes itsroutines as freestanding headers under LIBC_NAMESPACE::shared::, and eachcompiler-rt builtin becomes a thin wrapper that forwards to the matching libcroutine. A single .c file such as truncdfsf2.c is swapped for atruncdfsf2.cpp that calls shared::truncdfsf2. The swap happens through aCMake macro, use_libc_builtin(), gated on COMPILER_RT_USE_LIBC_MATH, sodistributors who want the libc-backed path opt in and everyone else keeps theexisting behavior. Figure 1: Two soft-float implementations of the same operation become one shared LLVM-libc

## Remembering Johannes Doerfert

DevFeed: [Remembering Johannes Doerfert](<https://devfeed.tech/articles/remembering-johannes-doerfert-59724.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-09-24-rememberingjohannesdoerfert/>)

Author: Tanya Lattner

Published: 2026-09-24T00:00:00Z

Content type: news

Language: en

Sources: [LLVM Project](<https://devfeed.tech/sources/the-llvm-project-blog.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [community](<https://devfeed.tech/tags/community.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-research](<https://devfeed.tech/tags/compiler-research.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [high-performance-computing](<https://devfeed.tech/tags/high-performance-computing.md>), [in-memoriam](<https://devfeed.tech/tags/in-memoriam.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [openmp](<https://devfeed.tech/tags/openmp.md>)

### AI overview

An LLVM post remembers Johannes Doerfert, a major contributor to compiler research and high-performance computing, highlighting his work on the Attributor framework, OpenMP GPU offloading, Polly, and polyhedral optimization.

### Source excerpt

It is with great sadness that we share the news of the passing of Johannes Doerfert, on September 17, 2026, at the age of 36, after a battle with cancer. Johannes was one of the most prolific and respected contributors to the LLVM compiler project, and his loss will be deeply felt. Johannes was born on November 5, 1989. He earned his Ph.D. in computer science from Saarland University in Saarbrücken, Germany, in 2018, where his research focused on applying polyhedral compiler technologies to low-level code. He had been an active LLVM contributor since 2014, working in the compiler design lab of Prof. Sebastian Hack, and became a core developer on the Polly polyhedral-optimization project as early as 2012. Over the following decade, Johannes built a career at the intersection of compiler research and high-performance computing, most recently as a researcher focused on OpenMP, LLVM, and parallel program optimization. Contributions to LLVM Johannes's worked on many parts of the LLVM Project, and these are just a few of his contributions: The Attributor framework. Johannes designed and championed the Attributor, LLVM's versatile inter-procedural fixpoint iteration framework for deducing and propagating function and argument attributes across a program. He introduced it to the community at the 2019 LLVM Developers' Meeting, and it has since become an important piece of LLVM's interprocedural optimization infrastructure. OpenMP and GPU offloading. Johannes became LLVM's code owner for OpenMP target offloading in 2021, leading the compiler and runtime support that lets OpenMP programs run efficiently on GPUs across NVIDIA, AMD, and Intel hardware. His work spanned the OpenMP runtime, just-in-time compilation and link-time optimization for target offloading, and techniques for near-zero-overhead GPU execution. Polly and polyhedral optimization. Early in his career, Johannes was a core developer of Polly, LLVM's polyhedral loop optimization infrastructure, and published resea

## AMD Upstreams AVX10\_V2\_AUX Support Into LLVM Clang 24

DevFeed: [AMD Upstreams AVX10\_V2\_AUX Support Into LLVM Clang 24](<https://devfeed.tech/articles/amd-upstreams-avx10-v2-aux-support-into-llvm-clang-24-58787.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/LLVM-Clang-AVX10_V2_AUX>)

Author: Michael Larabel

Published: 2026-09-23T10:25:58Z

Content type: news

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [x86](<https://devfeed.tech/topics/x86.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [data-processing](<https://devfeed.tech/topics/data-processing.md>), [ast-matchers](<https://devfeed.tech/topics/ast-matchers.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [clang](<https://devfeed.tech/tags/clang.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-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>), [llvm](<https://devfeed.tech/tags/llvm.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>), [release](<https://devfeed.tech/tags/release.md>), [software](<https://devfeed.tech/tags/software.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [x86](<https://devfeed.tech/tags/x86.md>)

### AI overview

AMD upstreamed AVX10_V2_AUX instruction-set support into LLVM 24 and exposed it through Clang with the -mavx10v2aux compiler flag. The extension supports data-type conversion, compressed formats, additional microscaling formats, and rounding modes intended to accelerate AI workloads.

### Source excerpt

In addition to AMD working on AVX10_V2_AUX support for the GCC compiler, this summer they also posted AVX10_V2_AUX support for the LLVM/Clang compiler. As of yesterday that enablement was merged for LLVM 24 for that important step toward AI Compute Extensions (ACE)...

## Igalia Celebrates 25 Years Of Advancing Linux & Open-Source

DevFeed: [Igalia Celebrates 25 Years Of Advancing Linux & Open-Source](<https://devfeed.tech/articles/igalia-celebrates-25-years-of-advancing-linux-open-source-57469.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Igalia-Turns-25>)

Author: Michael Larabel

Published: 2026-09-21T10:07:11Z

Content type: news

Language: en

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

Topics: [Linux](<https://devfeed.tech/topics/linux.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [WebKit](<https://devfeed.tech/topics/webkit.md>), [Chromium](<https://devfeed.tech/topics/chromium.md>), [servo](<https://devfeed.tech/topics/servo.md>), [Linux Kernel](<https://devfeed.tech/topics/linux-kernel.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Raspberry Pi](<https://devfeed.tech/topics/raspberry-pi.md>), [Wayland](<https://devfeed.tech/topics/wayland.md>), [Adreno](<https://devfeed.tech/topics/adreno.md>)

Tags: [adreno](<https://devfeed.tech/tags/adreno.md>), [chromium](<https://devfeed.tech/tags/chromium.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [igalia](<https://devfeed.tech/tags/igalia.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>), [llvm](<https://devfeed.tech/tags/llvm.md>), [open-source](<https://devfeed.tech/tags/open-source.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>), [qualcomm](<https://devfeed.tech/tags/qualcomm.md>), [raspberry-pi](<https://devfeed.tech/tags/raspberry-pi.md>), [servo](<https://devfeed.tech/tags/servo.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [upstream](<https://devfeed.tech/tags/upstream.md>), [wayland](<https://devfeed.tech/tags/wayland.md>), [webkit](<https://devfeed.tech/tags/webkit.md>)

### AI overview

Igalia, a worker-owned Linux and open-source consulting firm founded in 2001, is celebrating 25 years of contributions to projects including the Linux kernel, WebKit, Chromium, Servo, Mesa, GStreamer, and LLVM. The article also highlights its work on Wayland, graphics drivers, GPU scheduling, and the FEX emulator.

### Source excerpt

The Igalia Linux/open-source consulting firm based out of A Coruña, Spain is celebrating twenty five years of contributions to upstream open-soure projects...

## Intel Compute Stack Enables LEO For Nova Lake, Introduces Intel Portable ISA "PISA"

DevFeed: [Intel Compute Stack Enables LEO For Nova Lake, Introduces Intel Portable ISA "PISA"](<https://devfeed.tech/articles/intel-compute-stack-enables-leo-for-nova-lake-introduces-intel-portable-isa-pisa-41401.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Intel-Compute-Runtime-26.35.397>)

Author: Michael Larabel

Published: 2026-09-17T13:05:07Z

Content type: release

Language: en

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

Topics: [intel](<https://devfeed.tech/topics/intel.md>), [Nova](<https://devfeed.tech/topics/nova.md>), [OpenCL](<https://devfeed.tech/topics/opencl.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Linux](<https://devfeed.tech/topics/linux.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Parallelism](<https://devfeed.tech/topics/parallelism.md>)

Tags: [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [intel](<https://devfeed.tech/tags/intel.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>), [llvm](<https://devfeed.tech/tags/llvm.md>), [nova](<https://devfeed.tech/tags/nova.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [phoronix](<https://devfeed.tech/tags/phoronix.md>), [phoronix-test-suite](<https://devfeed.tech/tags/phoronix-test-suite.md>), [release](<https://devfeed.tech/tags/release.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [update](<https://devfeed.tech/tags/update.md>)

### AI overview

Intel Compute Runtime 26.35.39758.10 adds several GPU compute features and enables the OpenCL LEO driver by default for upcoming Nova Lake S processors on Linux. The release also introduces initial support for Intel's Portable ISA (PISA) format.

### Source excerpt

Released today was the Intel Compute Runtime 26.35.39758.10 update for Windows and Linux systems. With this updated OpenCL and Level Zero GPU compute driver stack comes some exciting updates for this monthly feature update...

## AlmaLinux 9.9 Beta Now Available!

DevFeed: [AlmaLinux 9.9 Beta Now Available!](<https://devfeed.tech/articles/almalinux-9-9-beta-now-available-53472.md>)

Original publisher: [Read original article](<https://almalinux.org/blog/2026-09-17-announcing-99-beta/>)

Author: Eduard Abdullin The Release; Automation Engineer

Published: 2026-09-17T00:00:00Z

Content type: release

Language: en

Sources: [AlmaLinux](<https://devfeed.tech/sources/blog-on-almalinux.md>)

Topics: [releases](<https://devfeed.tech/topics/releases.md>), [Security](<https://devfeed.tech/topics/security.md>), [virtualization](<https://devfeed.tech/topics/virtualization.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [gcc](<https://devfeed.tech/topics/gcc.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [Rust](<https://devfeed.tech/topics/rust.md>), [Node.js](<https://devfeed.tech/topics/node-js.md>), [PHP](<https://devfeed.tech/topics/php.md>), [qemu](<https://devfeed.tech/topics/qemu.md>), [SELinux](<https://devfeed.tech/topics/selinux.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [beta](<https://devfeed.tech/tags/beta.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [intel](<https://devfeed.tech/tags/intel.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [node-js](<https://devfeed.tech/tags/node-js.md>), [php](<https://devfeed.tech/tags/php.md>), [qemu](<https://devfeed.tech/tags/qemu.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>), [security](<https://devfeed.tech/tags/security.md>), [selinux](<https://devfeed.tech/tags/selinux.md>), [x86](<https://devfeed.tech/tags/x86.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

AlmaLinux announces the availability of AlmaLinux 9.9 Beta, "Chartreuse Bobcat," for Intel/AMD, ARM64, IBM PowerPC, and IBM Z. The release includes updated compiler toolsets, module streams, virtualization components, graphics, and security software. It also upgrades fapolicyd to version 2.0.1 and asks users to test the beta and report bugs before production release.

### Source excerpt

Hello Community! The AlmaLinux OS Foundation is announcing the availability of AlmaLinux 9.9 Beta "Chartreuse Bobcat" for all supported architectures: Intel/AMD (x86_64) ARM64 (aarch64) IBM PowerPC (ppc64le) IBM Z (s390x) Beta ISOs are available at vault.almalinux.org. A usual reminder: this is a BETA release. It should not be used for production installations. The provided upgrade instructions should not be used on production machines unless you don't mind if something breaks. If you are looking to see how things are going to work in stable, you are on the right track.

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