# Compiler

A compiler translates source code through intermediate representations into target-specific code.

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

## Microsoft is experimenting with open-source AMD code to give Xbox up to 16% performance boost

DevFeed: [Microsoft is experimenting with open-source AMD code to give Xbox up to 16% performance boost](<https://devfeed.tech/articles/microsoft-is-experimenting-with-open-source-amd-code-to-give-xbox-up-to-16-performance-boost-142946.md>)

Original publisher: [Read original article](<https://www.techspot.com/news/114617-microsoft-experimenting-open-source-amd-code-give-xbox.html>)

Author: Kishalaya Kundu

Published: 2026-11-19T11:15:00Z

Content type: news

Language: en

Sources: [TechSpot](<https://devfeed.tech/sources/techspot.md>)

Topics: [Xbox](<https://devfeed.tech/topics/xbox.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [amd-compiler](<https://devfeed.tech/tags/amd-compiler.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developers](<https://devfeed.tech/tags/developers.md>), [experimental](<https://devfeed.tech/tags/experimental.md>), [fsr](<https://devfeed.tech/tags/fsr.md>), [game-development](<https://devfeed.tech/tags/game-development.md>), [gaming](<https://devfeed.tech/tags/gaming.md>), [gdk](<https://devfeed.tech/tags/gdk.md>), [instructions](<https://devfeed.tech/tags/instructions.md>), [linux](<https://devfeed.tech/tags/linux.md>), [machine](<https://devfeed.tech/tags/machine.md>), [mesa](<https://devfeed.tech/tags/mesa.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [rdna](<https://devfeed.tech/tags/rdna.md>), [vulkan](<https://devfeed.tech/tags/vulkan.md>), [xbox](<https://devfeed.tech/tags/xbox.md>)

### AI overview

Microsoft's October Xbox GDK includes an experimental AMD shader compiler based on Mesa's ACO, intended to replace the older LLVM-based architecture and optimize code for Xbox Series X|S RDNA 2 GPUs. Developers evaluating the updated kit reported performance gains of 2% to 16%, varying by game engine and graphics content. The compiler is an option for developers to optimize upcoming games; it does not automatically improve existing titles. Microsoft has not announced which games will use it or when players will see benefits. The GDK also adds FSR 4.1.2 with Full INT8 and smaller, lower-cost Lite INT8 models, letting developers choose between frame rate and visual quality.

### Source excerpt

The open-source AMD compiler at the heart of the updated GDK is based on ACO, a shader compiler from the Mesa project that is used by the RADV Vulkan driver for AMD GPUs on Linux. It converts high-level shader instructions into machine code optimized for RDNA 2 GPUs powering Xbox... Read Entire Article

## JITAtlas: Checking Lifetime and Protection Obligations in Compiler Rewrites

DevFeed: [JITAtlas: Checking Lifetime and Protection Obligations in Compiler Rewrites](<https://devfeed.tech/articles/jitatlas-checking-lifetime-and-protection-obligations-in-compiler-rewrites-142193.md>)

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

Author: Baihong Chen (Utah State University), Wen Li (Utah State University)

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

Content type: article

Language: en

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

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

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [lifetime](<https://devfeed.tech/tags/lifetime.md>), [ownership](<https://devfeed.tech/tags/ownership.md>), [protection](<https://devfeed.tech/tags/protection.md>)

### AI overview

JITAtlas checks whether compiler rewrites preserve valid object use, continuous support for borrowed pointers, and caller-visible ownership, even when returned values remain unchanged. It reconstructs reference and target computations from optimizer code. On an independently constructed 58-input benchmark, it detected all 29 defects and reported none of 29 safe cases; PyRefcon detected 20 defects and CpyChecker 18. Across three CPython snapshots, it retained 801 of 3,332 extracted rewrite alternatives in recovered receiving contexts and reported 194 violations. Manual review confirmed 92 reports (47.42% precision); analysis took 35.56-42.31 seconds per snapshot. The study also reports 15 new bugs across five failure classes, each with a reproducible proof of concept.

### Source excerpt

arXiv:2611.23715v1 Announce Type: cross Abstract: Compiler rewrites can preserve returned values while violating object lifetime or ownership. Such failures arise when a rewrite changes when an object remains live, whether a borrowed pointer stays supported, or what ownership reaches the caller. We present JITAtlas, a source-level checker that reconstructs reference and target computations from optimizer code and checks valid uses, continuous borrow support, and caller-visible ownership. On a 58-input benchmark constructed and labeled independently of JITAtlas output, JITAtlas detects all 29 defects and reports none of 29 safe inputs; PyRefcon detects 20 defects and CpyChecker 18. Across three CPython snapshots, JITAtlas extracts 3,332 rewrite alternatives, retains 801 under recovered receiving contexts, and reports 194 violations. Manual review confirms 92 reports, giving 47.42% precision. End-to-end analysis takes 35.56-42.31 s per snapshot. JITAtlas further identifies 15 new bugs across five failure classes, each with a reproducible proof of concept.

## In the Microsoft employee price list, why did the BASIC compiler cost less than the BASIC interpreter?

DevFeed: [In the Microsoft employee price list, why did the BASIC compiler cost less than the BASIC interpreter?](<https://devfeed.tech/articles/in-the-microsoft-employee-price-list-why-did-the-basic-compiler-cost-less-than-the-basic-interpreter-142042.md>)

Original publisher: [Read original article](<https://devblogs.microsoft.com/oldnewthing/20261117-00/?p=112866/>)

Author: Raymond Chen

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

Content type: article

Language: en

Sources: [Raymond Chen](<https://devfeed.tech/sources/raymond-chen.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [compiled language](<https://devfeed.tech/topics/compiled-language.md>)

Tags: [basic](<https://devfeed.tech/tags/basic.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cost](<https://devfeed.tech/tags/cost.md>), [costs](<https://devfeed.tech/tags/costs.md>), [employee](<https://devfeed.tech/tags/employee.md>), [history](<https://devfeed.tech/tags/history.md>), [interpreter](<https://devfeed.tech/tags/interpreter.md>), [less](<https://devfeed.tech/tags/less.md>), [list](<https://devfeed.tech/tags/list.md>), [microsoft](<https://devfeed.tech/tags/microsoft.md>), [old-new-thing](<https://devfeed.tech/tags/old-new-thing.md>), [pricing](<https://devfeed.tech/tags/pricing.md>), [scheme](<https://devfeed.tech/tags/scheme.md>)

### AI overview

Microsoft's 1987 employee pricing was based on product cost plus administrative overhead, not on which program was more powerful. The author doesn't know why the BASIC Compiler package cost less to produce, but suggests its manual may have been thinner: it assumed users already knew BASIC and focused on running the compiler and differences from the interpreter. Less paper, a smaller box, and lower shipping and storage costs could explain the lower employee price. The excerpt notes that this was a guess, and that the employee pricing policy later changed.

### Source excerpt

Understanding the pricing scheme. The post In the Microsoft employee price list, why did the BASIC compiler cost less than the BASIC interpreter? appeared first on The Old New Thing.

## GraphPass: A Study of Graph Neural Networks for Compiler Pass Selection

DevFeed: [GraphPass: A Study of Graph Neural Networks for Compiler Pass Selection](<https://devfeed.tech/articles/graphpass-a-study-of-graph-neural-networks-for-compiler-pass-selection-137498.md>)

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

Author: Mohammed Saqlain

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Graphs](<https://devfeed.tech/topics/graphs.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [graph](<https://devfeed.tech/tags/graph.md>), [graph-neural-networks](<https://devfeed.tech/tags/graph-neural-networks.md>), [selection](<https://devfeed.tech/tags/selection.md>)

### AI overview

GraphPass tests whether a GNN can choose among five compiler-pass sequences from a program's control-flow graph in one forward pass. On 5,000 synthetic CFGs spanning five program families, GAT and GCN encoders matched the benchmark's reference labels on about 92% of held-out programs, compared with 85% for a flat MLP and 68.4% for a rule-based heuristic. Removing CFG edges raised GCN accuracy to 95.0% from 92.2% with true edges, suggesting the benchmark gains came from processing basic-block features rather than graph connectivity. Since labels were determined by program family, this amounts to family recognition; real-compiler speedups were not measured. Inference is reported as O(|V| + |E|), at 1.7 ms for a typical program and about 0.8 seconds for a 100,000-block graph on one CPU core.

### Source excerpt

arXiv:2611.19821v1 Announce Type: cross Abstract: Compiler pass selection is usually governed by fixed pipelines (-O2, -O3) or hand-written heuristics. We study whether a graph neural network (GNN) over a program's control-flow graph (CFG) can select among a fixed menu of five pass sequences in a single forward pass. GraphPass encodes each CFG with a graph attention (GAT) or graph convolutional (GCN) encoder and classifies it into one of the five sequences. On a synthetic benchmark of 5,000 generated CFGs in five program families, both encoders agree with the benchmark's reference label on about 92% of held-out programs, versus 68.4% for a hand-written rule-based heuristic and 85% for a flat MLP. An edge ablation indicates that this gain comes from per-block processing rather than from CFG edges: a GCN given the same basic-block features with all edges removed scores 95.0%, versus 92.2% with the true CFG. In this benchmark the label is determined by the program family, so the task amounts to family recognition. Real-compiler speedup is not measured. Inference costs O(|V| + |E|) per CFG, measured at 1.7 ms for a typical program and about 0.8 s for a 100,000-block graph on one CPU core.

## ElevatorII: High-Performance Fully-Static Cross-ISA Binary Translation

DevFeed: [ElevatorII: High-Performance Fully-Static Cross-ISA Binary Translation](<https://devfeed.tech/articles/elevatorii-high-performance-fully-static-cross-isa-binary-translation-139279.md>)

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

Author: Hongyu Chen, James McGowan, Michael Franz

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

Content type: article

Language: en

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

Topics: [Cross-Compilation](<https://devfeed.tech/topics/cross-compilation.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [x86](<https://devfeed.tech/topics/x86.md>), [obfuscation](<https://devfeed.tech/topics/obfuscation.md>)

Tags: [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [binaries](<https://devfeed.tech/tags/binaries.md>), [branch](<https://devfeed.tech/tags/branch.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [code](<https://devfeed.tech/tags/code.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [control](<https://devfeed.tech/tags/control.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [data](<https://devfeed.tech/tags/data.md>), [execution](<https://devfeed.tech/tags/execution.md>), [faster](<https://devfeed.tech/tags/faster.md>), [flow](<https://devfeed.tech/tags/flow.md>), [functions](<https://devfeed.tech/tags/functions.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [isa](<https://devfeed.tech/tags/isa.md>), [performance](<https://devfeed.tech/tags/performance.md>), [static](<https://devfeed.tech/tags/static.md>), [translation](<https://devfeed.tech/tags/translation.md>)

### AI overview

ElevatorII is a fully static ahead-of-time translator from x86 to AArch64 that requires no target-side runtime support. It uses superset disassembly to pretranslate paths for every possible interpretation of input bytes, including computed jump destinations, then overlays optimized paths selected using observations. On 11 SPEC CPU 2026 Integer benchmarks without C++ exceptions, it runs at 2.5x native AArch64 time, matching Box64 and running 5x faster than QEMU. It also translates binaries obfuscated with virtualization and branch functions. The tradeoff is output code 51x the size of source-compiled code; moving cold code to a separate ELF section leaves 2-3% of hot code in the main section, while the rest is expected to remain unloaded.

### Source excerpt

arXiv:2611.19577v1 Announce Type: new Abstract: The established method for running software compiled for one instruction-set architecture (ISA) on a different ISA is by emulation in conjunction with just-in-time (JIT) compilation. This requires run-time support on the target that needs to be trusted and whose compilation decisions are hard to predict or reconstruct. We present ElevatorII, a fully static, ahead-of-time cross-ISA binary-to-binary compiler from x86 to AArch64 that challenges the established consensus. Our approach eliminates the need for run-time support on the target, removes the hard to reproduce effects of dynamic compilation, and provides the capability to exhaustively test the actual binary that is eventually executed. Our approach combines superset disassembly with observation-guided path selection. Superset disassembly overcomes the code vs. data differentiation problem by creating a separate control flow path for every possible interpretation of every byte in the input binary. It guarantees that there is pre-translated code for every possible jump destination in the original text segment, even for computed jumps that are not statically decidable. Static and observation-guided path selection then creates additional optimized "confirmed code paths" that overlay the regular grid. On the 11 SPEC CPU 2026 Integer benchmarks that do not use C++ exceptions, ElevatorII runs at 2.5x native AArch64 time, on par with Box64, the fastest dynamic translator, and 5x faster than QEMU. It also translates binaries obfuscated with virtualization and branch functions, which no static disassembler can follow. Our approach trades execution performance for space: our output code is 51x the size of code compiled from source. We alleviate this by separating cold code to a .text.unlikely ELF section: only 2-3% hot code winds up in the main ELF section, while the rest will likely never be loaded into memory.

## Synapse: Optimizing Natural-Language Agent Skills through Program Repair

DevFeed: [Synapse: Optimizing Natural-Language Agent Skills through Program Repair](<https://devfeed.tech/articles/synapse-optimizing-natural-language-agent-skills-through-program-repair-138005.md>)

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

Author: Lijuan Li (Nanjing University), Zhenpeng Chen (Tsinghua University), Chenxi Zhang (Xidian University), Yihao Huang (East China Normal University), Yang Liu (Nanyang Technological University), Chong Wa

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

Content type: article

Language: en

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

Topics: [Agent Skills](<https://devfeed.tech/topics/agent-skills.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [patches](<https://devfeed.tech/topics/patches.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [agent-skills](<https://devfeed.tech/tags/agent-skills.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [natural-language](<https://devfeed.tech/tags/natural-language.md>), [repair](<https://devfeed.tech/tags/repair.md>), [skills](<https://devfeed.tech/tags/skills.md>)

### AI overview

Synapse improves natural-language agent skills through validated, source-linked repairs rather than model-parameter updates. It compiles recognized skill constructs into an intermediate representation (SkIR), uses execution traces plus control-flow and dependence relations to locate faults and select repair tests--including previously passing tests--and recompiles each source-mapped mutation before accepting it. Accepted patches preserve untargeted instruction spans and produce well-formed skills; test completeness is claimed under a one-hop-local execution assumption. Across DocVQA and LiveMath with three execution models, Synapse beats SkillOpt by 3.74-4.54 and 2.40-4.00 percentage points, respectively, and outperforms Trace2Skill and SkillBoost in all six settings. On DocVQA, replacing SkIR repair and test screening with constrained text editing tested only on failures reduced success by 2.40 and 2.67 points for two models. Structural relations added tests for 23 of 37 patches in two recorded runs, and one such test caught a regression missed by coverage of the edited instruction.

### Source excerpt

arXiv:2611.20856v1 Announce Type: new Abstract: Large language model (LLM) agents can improve task performance by optimizing reusable natural-language skills without updating model parameters. Execution feedback reveals failures but does not directly identify which instructions to edit, which related instructions matter, or which tasks an edit may break. We propose Synapse, which casts skill optimization as generate-and-validate repair over a partial program view. A deterministic compiler translates recognized skill constructs into SkIR, a source-linked intermediate representation, while retaining other requirements in the text. Synapse combines execution traces with control-flow and dependence relations to localize faults, propose typed mutations, and select related repair tests, including previously passing ones. Each mutation is written back to its mapped source span and recompiled; validation determines acceptance. Every accepted patch yields a well-formed skill and preserves untargeted instruction spans. Under a one-hop-local execution assumption, selected tests include every test an edit can affect. On DocVQA and LiveMath with three execution models, Synapse improves task success rates over SkillOpt by 3.74-4.54 and 2.40-4.00 percentage points, respectively, and outperforms Trace2Skill and SkillBoost in all six settings. Replacing SkIR-based repair and its test screening with constrained text editing screened only on failing tests lowers DocVQA success rates by 2.40 and 2.67 percentage points for two models. In two recorded repair runs, structural relations add tests for 23 of 37 patches; in one repair, a test added through a control-flow relation exposes a regression missed by coverage of the edited instruction.

## 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...

## Borland C++ 2.0 Compiler Source Reconstructed

DevFeed: [Borland C++ 2.0 Compiler Source Reconstructed](<https://devfeed.tech/articles/borland-c-2-0-compiler-source-reconstructed-133527.md>)

Original publisher: [Read original article](<https://hackaday.com/2026/11/13/borland-c-2-0-compiler-source-reconstructed/>)

Author: Maya Posch

Published: 2026-11-14T03:00:44Z

Content type: news

Language: en

Sources: [Hackaday](<https://devfeed.tech/sources/hackaday.md>)

Topics: [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>)

Tags: [borland](<https://devfeed.tech/tags/borland.md>), [borland-c-plus-plus](<https://devfeed.tech/tags/borland-c-plus-plus.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [claude-code](<https://devfeed.tech/tags/claude-code.md>), [code](<https://devfeed.tech/tags/code.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [development](<https://devfeed.tech/tags/development.md>), [dos](<https://devfeed.tech/tags/dos.md>), [ides](<https://devfeed.tech/tags/ides.md>), [language](<https://devfeed.tech/tags/language.md>), [original](<https://devfeed.tech/tags/original.md>), [process](<https://devfeed.tech/tags/process.md>), [programming](<https://devfeed.tech/tags/programming.md>), [programming-language](<https://devfeed.tech/tags/programming-language.md>), [project](<https://devfeed.tech/tags/project.md>), [projects](<https://devfeed.tech/tags/projects.md>), [release](<https://devfeed.tech/tags/release.md>), [reverse-engineering](<https://devfeed.tech/tags/reverse-engineering.md>), [software-development](<https://devfeed.tech/tags/software-development.md>), [source](<https://devfeed.tech/tags/source.md>), [turbo-c-plus-plus](<https://devfeed.tech/tags/turbo-c-plus-plus.md>)

### AI overview

Borland C++ 2.0's source has been reconstructed from the original toolchain binaries. The project claims the recreated source is byte-perfect in the practical sense that it produces binaries identical to those from the original compiler. A separate document details the process, including use of Exhume, a Claude Code-based tool. The source may help projects working with DOS software from the period and has historical interest; the excerpt notes that C89 had only just been standardized and C++'s first standard was still years away.

### Source excerpt

As the successor to Turbo C++, Borland C++ was a staple of professional IDEs for C and C++ development, starting with the initial 2.0 release in 1991. Being a commercial ...read more

## Intel Posts Initial GCC Compiler Code For Razor Lake & Coral Rapids

DevFeed: [Intel Posts Initial GCC Compiler Code For Razor Lake & Coral Rapids](<https://devfeed.tech/articles/intel-posts-initial-gcc-compiler-code-for-razor-lake-coral-rapids-131654.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/Intel-GCC-Coral-Rapids-Razor>)

Author: Michael Larabel

Published: 2026-11-13T11:29:00Z

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>)

Tags: [64-bit](<https://devfeed.tech/tags/64-bit.md>), [avx](<https://devfeed.tech/tags/avx.md>), [avx2](<https://devfeed.tech/tags/avx2.md>), [avx512](<https://devfeed.tech/tags/avx512.md>), [bf16](<https://devfeed.tech/tags/bf16.md>), [butterfly](<https://devfeed.tech/tags/butterfly.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [diamond-rapids](<https://devfeed.tech/tags/diamond-rapids.md>), [features](<https://devfeed.tech/tags/features.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [intel](<https://devfeed.tech/tags/intel.md>), [isa](<https://devfeed.tech/tags/isa.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](<https://devfeed.tech/tags/open-source.md>), [open-source-graphics](<https://devfeed.tech/tags/open-source-graphics.md>), [patches](<https://devfeed.tech/tags/patches.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>), [rapids](<https://devfeed.tech/tags/rapids.md>), [razor](<https://devfeed.tech/tags/razor.md>), [support](<https://devfeed.tech/tags/support.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>)

### AI overview

Intel has posted initial GCC patches for Coral Rapids and Razor Lake, processors the source says are not expected to ship before 2028. The early enablement is expected to reach GCC 17 and potentially Linux distributions before the processors arrive. Razor Lake's patch indicates the same ISA features as Nova Lake. Coral Rapids is identified as supporting AVX10.2, including AVX10_VPMLDSABFLYDQ for packed ML-DSA butterfly operations; the source says this is a key ISA difference from Diamond Rapids. A separate patch adds the corresponding GCC intrinsics. Coral Rapids is not reported to support AVX10.3, while an updated AVX10.3 patch series now also includes AVX10_BMM.

### Source excerpt

One of the consistent wonderful praise I have for Intel over the past 22+ years of covering the Linux hardware scene has been their upstreaming of new CPU targets into the open-source compilers like GCC well ahead of product launches. Particularly with GCC on an annual feature release cycle and not being quickly picked up by new Linux distribution releases, Intel upstreaming their new CPU targets and ISA features at times years in advance of product releases has helped ensure smooth compiler ecosystem support by the time their products ship. The latest example, today they posted their patches providing new ISA features and enabling for both Coral Rapids and Razor Lake processors...

## MLIRBench - A Benchmark and Dataset for Compiler and Hardware-Aware Reasoning

DevFeed: [MLIRBench - A Benchmark and Dataset for Compiler and Hardware-Aware Reasoning](<https://devfeed.tech/articles/mlirbench-a-benchmark-and-dataset-for-compiler-and-hardware-aware-reasoning-132060.md>)

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

Author: Pranava Sai Maganti, Meghasyam Peddireddy, Muzakker Hossain, Kaining Gao, Farhan Ahmed, Ali Jannesari

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [execution](<https://devfeed.tech/tags/execution.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [intermediate-representations](<https://devfeed.tech/tags/intermediate-representations.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [pairs](<https://devfeed.tech/tags/pairs.md>), [reasoning](<https://devfeed.tech/tags/reasoning.md>)

### AI overview

MLIRBench evaluates LLM reasoning about MLIR using execution-validated mutations of torch and linalg program pairs. Its 1,768 pairs are labeled EQUIV, DIVERGE, or ERROR. In tests of nine models, Gemini 3.1 Pro had the highest hard-label accuracy at 92.65%, counting unsuccessful predictions as incorrect. Yet its judge-assigned result-behavior score was 5.04/10, indicating that accurate semantic labels did not guarantee accurate predictions of detailed execution behavior. The benchmark offers a reproducible basis for studying this gap and related tasks such as program repair and semantic classification.

### Source excerpt

arXiv:2611.14881v1 Announce Type: cross Abstract: In recent years, large language models (LLMs) have become increasingly popular in software engineering and have performed well on different programming tasks. However, it is still difficult to know whether these models truly understand program behavior or whether they mainly rely on patterns learned from their training data. This distinction is particularly important for intermediate representations (IRs), where operations, dataflow, and execution semantics are explicitly represented. In this paper, we introduce MLIRBench, a benchmark for evaluating how LLMs reason about MLIR programs. MLIRBench uses a multi-agent pipeline to generate program mutations, validate their behavior through execution, and construct reasoning tasks from torch and linalg program pairs. The dataset contains 1,768 validated pairs, including 888 linalg pairs and 880 torch pairs, labeled as EQUIV, DIVERGE, or ERROR. We evaluated nine models, including five open-weight and four proprietary models. Gemini 3.1 Pro achieved the highest hard-label accuracy of 92.65% across all 1,768 pairs, counting unsuccessful predictions as incorrect. Across its 1,768 scored predictions, it achieved an aggregate score of 74.18 and a judge-assigned result-behavior score of 5.04/10. These results show that strong semantic classification does not necessarily imply accurate prediction of detailed execution behavior, highlighting a gap in current LLM reasoning over compiler IRs. By exposing this gap through execution-validated program pairs, MLIRBench provides a reproducible foundation for studying semantic reasoning over compiler IRs and related tasks such as program repair and semantic classification.

## 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...

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

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

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

Author: Daniel Curtis

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

Content type: news

Language: en

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

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

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

### AI overview

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

### Source excerpt

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

## Samyama-SDG: A Declarative GraphQL @count and Regex/Ontology Synthetic Data Compiler with $O(1)$-Memory Referential Integrity and Causal Ground Truth

DevFeed: [Samyama-SDG: A Declarative GraphQL @count and Regex/Ontology Synthetic Data Compiler with $O(1)$-Memory Referential Integrity and Causal Ground Truth](<https://devfeed.tech/articles/samyama-sdg-a-declarative-graphql-count-and-regex-ontology-synthetic-data-compiler-with-o-1-memory-referential-integrity-and-causal-ground-truth-125669.md>)

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

Author: Madhulatha Mandarapu, Sandeep Kunkunuru

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

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [Ground truth / benchmark quality](<https://devfeed.tech/topics/ground-truth-benchmark-quality.md>), [GraphQL](<https://devfeed.tech/topics/graphql.md>), [database-consistency](<https://devfeed.tech/topics/database-consistency.md>), [schema design](<https://devfeed.tech/topics/schema-design.md>)

Tags: [000](<https://devfeed.tech/tags/000.md>), [2](<https://devfeed.tech/tags/2.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [after](<https://devfeed.tech/tags/after.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [based](<https://devfeed.tech/tags/based.md>), [binder](<https://devfeed.tech/tags/binder.md>), [buffer](<https://devfeed.tech/tags/buffer.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [data](<https://devfeed.tech/tags/data.md>), [declarative](<https://devfeed.tech/tags/declarative.md>), [graphql](<https://devfeed.tech/tags/graphql.md>), [integrity](<https://devfeed.tech/tags/integrity.md>), [memory](<https://devfeed.tech/tags/memory.md>), [ontology](<https://devfeed.tech/tags/ontology.md>), [referential-integrity](<https://devfeed.tech/tags/referential-integrity.md>), [regex](<https://devfeed.tech/tags/regex.md>), [synthetic](<https://devfeed.tech/tags/synthetic.md>), [synthetic-data](<https://devfeed.tech/tags/synthetic-data.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

Samyama-SDG (sdg-rs) combines declarative data generation with ontology-bound causal simulation. It compiles GraphQL schemas and an Attribute Data Dictionary into a dependency DAG; seekable SplitMix64 values and index-bijective primary keys let it resolve uniform or Zipfian foreign keys and multi-hop temporal constraints without storing parent-key pools, using O(1) memory. A second layer adds fault propagation and machine-scorable ground truth. Across three schemas, the abstract reports generation rates of 5.80-7.76 million rows per second at one million records, and 31.4-35.1 MiB memory at five million records. It reports zero conformance errors across 1.15 million foreign keys and 900,000 temporal constraints.

### Source excerpt

arXiv:2611.11295v1 Announce Type: new Abstract: Synthetic data generators face a divide between declarative relational mockets and domain causal simulators. Declarative generators specify entities, regexes, and foreign keys via schemas, but buffer parent primary-key pools in RAM ($O(N)$ memory) and lack ontology bindings or causal ground truth. Conversely, domain simulators emit realistic streams and ground-truth labels, but require thousands of lines of procedural code per domain. We present Samyama-SDG (sdg-rs), a Rust synthetic data compiler unifying declarative schema compilation with ontology-bound causal simulation. At Layer 1, Samyama-SDG compiles Cardinality-Extended GraphQL schemas (@count, @pk, @ontology, @regex, @dist, @fk, @after) and an Attribute Data Dictionary into a topologically sorted DAG. Combining stateless counter-based seekable PRNGs (SplitMix64 over $(\text{seed}, \text{entity}, \text{row}, \text{field})$) with index-bijective primary keys $f_{\text{PK}}(s, E, i)$ lets child tables resolve uniform or Zipfian foreign keys and multi-hop @after constraints in $O(1)$ memory without buffering parent tables. At Layer 2, causal processes layer fault propagation and machine-scorable ground truth (ground_truth.jsonl) over the same seekable PRNG and samyama-ontologies binder. Across three schemas, Samyama-SDG generates $1{,}000{,}000$ records in $128.79\text{ ms}$--$172.43\text{ ms}$ ($5.80\text{M}$--$7.76\text{M}$ rows/s) and $5{,}000{,}000$ records in $676.12\text{ ms}$--$808.56\text{ ms}$ at flat $31.4\text{ MiB}$--$35.1\text{ MiB}$ memory, with $0$ conformance errors across $1{,}150{,}000$ foreign keys and $900{,}000$ temporal constraints.

## TypeScript 7.1 Beta: Restores the Compiler API and Makes Vue and Svelte First-Class

DevFeed: [TypeScript 7.1 Beta: Restores the Compiler API and Makes Vue and Svelte First-Class](<https://devfeed.tech/articles/typescript-7-1-beta-restores-the-compiler-api-and-makes-vue-and-svelte-first-class-121076.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/11/typescript-7-1-beta/>)

Author: Daniel Curtis

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

Content type: news

Language: en

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

Topics: [TypeScript](<https://devfeed.tech/topics/typescript.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Svelte](<https://devfeed.tech/topics/svelte.md>)

Tags: [api](<https://devfeed.tech/tags/api.md>), [beta](<https://devfeed.tech/tags/beta.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [development](<https://devfeed.tech/tags/development.md>), [javascript](<https://devfeed.tech/tags/javascript.md>), [news](<https://devfeed.tech/tags/news.md>), [svelte](<https://devfeed.tech/tags/svelte.md>), [typescript](<https://devfeed.tech/tags/typescript.md>), [typescript-7](<https://devfeed.tech/tags/typescript-7.md>), [typescript-7-1-beta](<https://devfeed.tech/tags/typescript-7-1-beta.md>), [vue](<https://devfeed.tech/tags/vue.md>), [vue-js](<https://devfeed.tech/tags/vue-js.md>), [web-development](<https://devfeed.tech/tags/web-development.md>)

### AI overview

TypeScript 7.1 Beta restores a programmatic compiler API through focused entry points such as `typescript/sync`, `typescript/async`, `typescript/fs` and `typescript/ast`, with reusable snapshots for incremental edits. Its content mappers let opted-in plugins present `.vue` and `.svelte` files as virtual TypeScript input while mapping errors back to source locations. Vue Language Tools has a v4 alpha using this mechanism; one Directus project's checks fell from 14.19 to 3.10 seconds, while the article reports smaller gains for heavier codebases such as VS Code. Teams may need TypeScript 6 in the editor alongside 7.1 in CI until framework tooling stabilizes. A reported editor issue can leave types stale after saving a watched mapper configuration file, requiring a language-server restart; it remains open. The beta also adds import attributes in ambient declarations, source-phase imports for WebAssembly, and an `es2026` target.

### Source excerpt

TypeScript 7.1 Beta, announced October 20, 2026, restores the compiler API removed in 7.0, now split into separate entry points. It adds content mappers, letting tools like Vue check non-standard files. One Vue project's type checks fell from 14.19 to 3.10 seconds. An editor issue remains open, and teams may need TypeScript 6 alongside 7. By Daniel Curtis

## xDSL-CCPP: An alternative code generator for atmospheric modelling

DevFeed: [xDSL-CCPP: An alternative code generator for atmospheric modelling](<https://devfeed.tech/articles/xdsl-ccpp-an-alternative-code-generator-for-atmospheric-modelling-121274.md>)

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

Author: Nick Brown, John Dennis

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

Content type: article

Language: en

Sources: [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>)

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [Fortran](<https://devfeed.tech/topics/fortran.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [code-generator](<https://devfeed.tech/tags/code-generator.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [complexity](<https://devfeed.tech/tags/complexity.md>), [computing](<https://devfeed.tech/tags/computing.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [domain-specific-languages](<https://devfeed.tech/tags/domain-specific-languages.md>), [dsl](<https://devfeed.tech/tags/dsl.md>), [dsls](<https://devfeed.tech/tags/dsls.md>), [flexibility](<https://devfeed.tech/tags/flexibility.md>), [fortran](<https://devfeed.tech/tags/fortran.md>), [framework](<https://devfeed.tech/tags/framework.md>), [frameworks](<https://devfeed.tech/tags/frameworks.md>), [generator](<https://devfeed.tech/tags/generator.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [high-performance](<https://devfeed.tech/tags/high-performance.md>), [high-performance-computing](<https://devfeed.tech/tags/high-performance-computing.md>), [high-performance-computing-hpc](<https://devfeed.tech/tags/high-performance-computing-hpc.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [modelling](<https://devfeed.tech/tags/modelling.md>)

### AI overview

xDSL-CCPP replaces CCPP's increasingly complex, bespoke Python and regular-expression code generator with an application-specific generator built on MLIR and xDSL. The authors report reducing bespoke tooling from about 15,000 to 5,000 lines of code, while maintaining application performance and promoting flexibility. They present these compiler frameworks as lowering the effort and specialist-skill barriers to developing HPC domain-specific languages, in a context where GPU modernization adds demands to the existing generator. This summary is based on the supplied abstract.

### Source excerpt

arXiv:2611.08060v1 Announce Type: new Abstract: The Common Community Physics Package (CCPP) is a framework designed to simplify the exchange of physics packages between state-of-the-art atmospheric models. A core software component of CCPP is a code generator: a bespoke Python-based application that uses regular expressions to transform an input specification into Fortran source code. While the code generator initially provided a simple transformation capability, the demands of state-of-the-art atmospheric models have resulted in significant increases in its complexity. Furthermore, ongoing code modernisation efforts to enable GPU-based computing have placed additional demands on the code generator for which it was never designed. Domain Specific Languages (DSLs) have proven to be highly effective in High Performance Computing (HPC), offering the ability to simplify code modernisation efforts. However, traditionally the effort and specialist skills required in the development of a DSL have been a blocker to adoption. In recent years, however, there have been great advances in compiler technologies, and frameworks such as MLIR and xDSL have the potential to greatly lower this barrier to entry. In this paper, we present xDSL-CCPP, a new application-specific code generator based upon the latest MLIR and xDSL compiler technologies, for CCPP. Demonstrating a reduction in bespoke tooling code of around three times, from approximately 15,000 LoC to 5,000 LoC, we highlight the opportunities provided by these compiler frameworks and demonstrate how they significantly lower the barrier to development of HPC application-specific DSLs whilst maintaining application performance and promoting flexibility.

## Together Compiler: Continual Compilation for AI inference

DevFeed: [Together Compiler: Continual Compilation for AI inference](<https://devfeed.tech/articles/together-compiler-continual-compilation-for-ai-inference-118999.md>)

Original publisher: [Read original article](<https://www.together.ai/blog/together-compiler-continual-compilation-for-ai-inference>)

Author: Reyna Abhyankar, Dylan Lim, and Simran Arora

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

Content type: article

Language: en

Sources: [Together.ai](<https://devfeed.tech/sources/together-ai.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [agent orchestration](<https://devfeed.tech/topics/agent-orchestration.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agentic](<https://devfeed.tech/tags/agentic.md>), [agentic-systems](<https://devfeed.tech/tags/agentic-systems.md>), [agentic-workloads](<https://devfeed.tech/tags/agentic-workloads.md>), [agents](<https://devfeed.tech/tags/agents.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-inference](<https://devfeed.tech/tags/ai-inference.md>), [ai-systems](<https://devfeed.tech/tags/ai-systems.md>), [ai-workloads](<https://devfeed.tech/tags/ai-workloads.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [attention](<https://devfeed.tech/tags/attention.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [engines](<https://devfeed.tech/tags/engines.md>), [inference](<https://devfeed.tech/tags/inference.md>), [models](<https://devfeed.tech/tags/models.md>), [optimize](<https://devfeed.tech/tags/optimize.md>), [throughput](<https://devfeed.tech/tags/throughput.md>), [traffic](<https://devfeed.tech/tags/traffic.md>)

### AI overview

Together Compiler (TKCC) targets changing inference workloads by using parallel agents and persistent engines that hot-reload candidate forward passes, avoiding the tens-of-minutes startup and teardown costs of conventional engines. Fast engines support rapid, low-variance experiments; slower engines test optimizations on more layers and realistic data distributions. A tiered cost model combines hardware specifications, microbenchmarks, and measured passes to prune parallelism choices while accounting for traffic properties such as MoE imbalance. The excerpt reports up to 2.6x higher throughput across frontier open models in under 24 hours, 1.7x on Llama 1B at batch size 1, and low-latency results of 1,111 TPS on MiniMax M3.1-Flash and 1,205 TPS on DeepSeek v4.1-Flash. It also reports 252x higher experiment throughput than baseline agentic optimization systems and generalization to several non-LLM workloads. A footnote says the Trainium2 result used synthetic traffic because higher concurrencies were not supported.

### Source excerpt

Together Compiler uses agents and persistent engines to optimize open models in under 24 hours, delivering up to 3.7x higher throughput as traffic changes.

## GCC 17 Compiler Merges Support For AVX10V1AUX

DevFeed: [GCC 17 Compiler Merges Support For AVX10V1AUX](<https://devfeed.tech/articles/gcc-17-compiler-merges-support-for-avx10v1aux-113666.md>)

Original publisher: [Read original article](<https://www.phoronix.com/news/GCC-17-Merges-AVX10V1AUX>)

Author: Michael Larabel

Published: 2026-11-03T10:22:12Z

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>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>)

Tags: [ace](<https://devfeed.tech/tags/ace.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-compute](<https://devfeed.tech/tags/ai-compute.md>), [amd](<https://devfeed.tech/tags/amd.md>), [borrowing](<https://devfeed.tech/tags/borrowing.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [changes](<https://devfeed.tech/tags/changes.md>), [commit](<https://devfeed.tech/tags/commit.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compute](<https://devfeed.tech/tags/compute.md>), [cross](<https://devfeed.tech/tags/cross.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [exposed](<https://devfeed.tech/tags/exposed.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [gcc](<https://devfeed.tech/tags/gcc.md>), [git](<https://devfeed.tech/tags/git.md>), [initiative](<https://devfeed.tech/tags/initiative.md>), [intel](<https://devfeed.tech/tags/intel.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>), [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>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

GCC 17 has merged initial support for AVX10V1AUX, exposed through the -mavx10v1aux compiler switch. The excerpt says the extension adds native VNNI INT8 and INT16 support, instruction borrowing, and other incremental updates that bridge early AVX10 hardware and later AVX10.2 capabilities. It is not yet tied to specific Intel or AMD processor generations in GCC targeting.

### Source excerpt

Landing today into the GCC 17 compiler codebase is initial support for AVX10V1AUX as the auxillary updates to AVX10.1 that are out of the cross-vendor AI Compute Extensions "ACE" initiative between AMD and Intel...

## TIRx: A Unified Tile Primitive ML Compiler Across Heterogeneous Backends

DevFeed: [TIRx: A Unified Tile Primitive ML Compiler Across Heterogeneous Backends](<https://devfeed.tech/articles/tirx-a-unified-tile-primitive-ml-compiler-across-heterogeneous-backends-111370.md>)

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

Author: Bohan Hou, Hongyi Jin, Guanjie Wang, Shushi Hong, Jinqi Chen, Yaxing Cai, Lijie Yang, Zihao Ye, Yaoyao Ding, Ruihang Lai, Todd Mowry, Tianqi Chen

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

Content type: article

Language: en

Sources: [arXiv: Artificial Intelligence](<https://devfeed.tech/sources/arxiv-artificial-intelligence.md>), [arXiv: Distributed Computing](<https://devfeed.tech/sources/arxiv-distributed-computing.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [GPU optimization](<https://devfeed.tech/topics/gpu-optimization.md>), [Distributed Systems & Parallel Computing](<https://devfeed.tech/topics/distributed-systems-parallel-computing.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>)

Tags: [accelerators](<https://devfeed.tech/tags/accelerators.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-accelerators](<https://devfeed.tech/tags/ai-accelerators.md>), [backends](<https://devfeed.tech/tags/backends.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-dc](<https://devfeed.tech/tags/cs-dc.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [dispatch](<https://devfeed.tech/tags/dispatch.md>), [gpus](<https://devfeed.tech/tags/gpus.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [layout](<https://devfeed.tech/tags/layout.md>), [layouts](<https://devfeed.tech/tags/layouts.md>), [memory](<https://devfeed.tech/tags/memory.md>), [ml](<https://devfeed.tech/tags/ml.md>), [performance](<https://devfeed.tech/tags/performance.md>), [scope](<https://devfeed.tech/tags/scope.md>), [tensors](<https://devfeed.tech/tags/tensors.md>)

### AI overview

TIRx aims to retain native-level performance control while simplifying ML kernel implementation across GPUs and AI accelerators. It makes participating hardware teams explicit through execution scopes, maps logical tensors to hardware spaces with named-axis layouts and shard/replica/offset semantics, and dispatches tile primitives based on scope, layout, and backend. This automates recurring address calculations, operand preparation, and instruction-loop generation. The abstract reports vendor-level performance on recent GPUs and AI accelerators and substantial reductions in low-level code in native-code case studies; it gives no benchmark details or specific backend comparisons.

### Source excerpt

arXiv:2601.19092v3 Announce Type: replace-cross Abstract: Modern ML kernels evolve rapidly with new optimizations and hardware features. ML compiler abstractions must accommodate richer memory hierarchies, more forms of thread cooperation, and increasingly heterogeneous backends while retaining the control required for peak performance. We present TIRx, an ML compiler for GPUs and AI accelerators that exposes these ingredients through explicit interfaces. TIRx introduces an explicit execution-scope abstraction that captures participating hardware teams at multiple granularities. It also uses tensor layouts to map logical tensors to heterogeneous hardware spaces through named axes and shard/replica/offset semantics. Finally, it introduces tile-primitive dispatch, which lowers high-level operations to efficient implementations according to scope, layout, and backend. This design preserves native-level control while automating recurring address calculation, operand preparation, and instruction-loop generation. Our evaluation shows vendor-level performance across the latest GPUs and AI accelerators, while native-code case studies show substantial reductions in low-level implementation code.

## The Flash C compiler

DevFeed: [The Flash C compiler](<https://devfeed.tech/articles/the-flash-c-compiler-109872.md>)

Original publisher: [Read original article](<https://blog.adafruit.com/2026/10/31/flash-c-compiler/>)

Author: Anne Barela

Published: 2026-10-31T14:00:58Z

Content type: release

Language: en

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

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [linker](<https://devfeed.tech/topics/linker.md>), [Linux](<https://devfeed.tech/topics/linux.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [debugger](<https://devfeed.tech/tags/debugger.md>), [elf](<https://devfeed.tech/tags/elf.md>), [flash](<https://devfeed.tech/tags/flash.md>), [floating-point](<https://devfeed.tech/tags/floating-point.md>), [functions](<https://devfeed.tech/tags/functions.md>), [github](<https://devfeed.tech/tags/github.md>), [help](<https://devfeed.tech/tags/help.md>), [ide](<https://devfeed.tech/tags/ide.md>), [layout](<https://devfeed.tech/tags/layout.md>), [library](<https://devfeed.tech/tags/library.md>), [linker](<https://devfeed.tech/tags/linker.md>), [linking](<https://devfeed.tech/tags/linking.md>), [linux](<https://devfeed.tech/tags/linux.md>), [screen](<https://devfeed.tech/tags/screen.md>), [software](<https://devfeed.tech/tags/software.md>), [source](<https://devfeed.tech/tags/source.md>), [static](<https://devfeed.tech/tags/static.md>), [text](<https://devfeed.tech/tags/text.md>), [turbo](<https://devfeed.tech/tags/turbo.md>), [turbo-c-plus-plus](<https://devfeed.tech/tags/turbo-c-plus-plus.md>), [vintage-computing](<https://devfeed.tech/tags/vintage-computing.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

Flash C is an x86-64 Linux C compiler and full-screen IDE written from scratch. Its fcc compiler accepts C89 with some C99 conveniences, excludes C++, and emits static ELF executables directly without an assembler, linker, or host C library. Its runtime library is embedded in the compiler; only functions reachable from main are emitted, including floating-point conversion routines only when float or double is used. The optimizer has 48 passes that can be toggled individually. The fc IDE uses a Turbo Vision-style interface and includes a ptrace/int3 source debugger and hyperlinked help. The author says Turbo C++ 3.1 was studied to reproduce interface details, but its code and resources were not used.

### Source excerpt

Dilshan Jayakody has released Flash C, a C compiler and full-screen text-mode IDE written from scratch for x86-64 Linux, documented on his Web Log. The compiler, fcc, reads C source and writes a static ELF executable directly. No assembler, linker or host C library is involved. Flash C handles C89 plus a few C99 conveniences [...]

## 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

## TensorBound: Characterizing Tensor Binding Failures in AI Compiler and Runtime Stacks

DevFeed: [TensorBound: Characterizing Tensor Binding Failures in AI Compiler and Runtime Stacks](<https://devfeed.tech/articles/tensorbound-characterizing-tensor-binding-failures-in-ai-compiler-and-runtime-stacks-109021.md>)

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

Author: Wen Li (Utah State University), Yongxi Sha (Utah State University), Baihong Chen (Utah State University)

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

Content type: article

Language: en

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

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [PyTorch](<https://devfeed.tech/topics/pytorch.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-cr](<https://devfeed.tech/tags/cs-cr.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [study](<https://devfeed.tech/tags/study.md>)

### AI overview

TensorBound studies tensor binding failures across IREE and the XLA and PyTorch ecosystems, analyzing 264 reports and reconstructing 149 repaired causes by tracing source and comparing revisions before and after fixes. It links each cause to the first invalid decision, the violated condition, the resulting physical effect, and the repair. Missing eligibility checks, incorrect mappings or translations, and lost or omitted relations make up 69.1% of reconstructed causes. The 101 first invalid decisions found in compiler code point to candidate checks before execution. Four archived IREE diagnostic attempts show a distinction between locating an effect and explaining its source-based cause. The authors argue for checks at representation transitions that preserve binding facts and verify required conditions where those facts are used.

### Source excerpt

arXiv:2610.37838v1 Announce Type: new Abstract: AI compiler and runtime stacks must preserve bindings between tensor values and their operations, storage, and execution state. These bindings can fail while the underlying objects remain present, with symptoms appearing in another layer. We present TensorBound, an empirical study of tensor binding failures in IREE and the XLA and PyTorch ecosystems. The study analyzes 264 reports and reconstructs 149 distinct repaired causes through source tracing and comparisons of pre-fix and repaired revisions. Each reconstruction connects the first invalid decision to its violated condition, physical effect, and repair. Missing eligibility checks, incorrect mappings or translations, and lost or omitted relations account for 69.1% of repaired causes. These patterns highlight the need to preserve binding facts and check the conditions for their use. The 101 first invalid decisions in compiler code identify candidate checking points before execution. Four archived IREE diagnostic attempts distinguish effect localization from source-based cause explanation. Together, these findings motivate transition-specific checks that preserve binding facts across representations and enforce the required conditions at consuming decisions.

## AWS's Hydro team wants the compiler to catch coding agents' mistakes

DevFeed: [AWS's Hydro team wants the compiler to catch coding agents' mistakes](<https://devfeed.tech/articles/aws-s-hydro-team-wants-the-compiler-to-catch-coding-agents-mistakes-106918.md>)

Original publisher: [Read original article](<https://thenewstack.io/ai-agents-compiler-guardrails/>)

Author: Matthew Burns

Published: 2026-10-29T21:53:05Z

Content type: news

Language: en

Sources: [The New Stack](<https://devfeed.tech/sources/the-new-stack.md>)

Topics: [agentic-coding](<https://devfeed.tech/topics/agentic-coding.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Code review](<https://devfeed.tech/topics/code-review.md>), [consistency](<https://devfeed.tech/topics/consistency.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agent-workflows](<https://devfeed.tech/tags/agent-workflows.md>), [agents](<https://devfeed.tech/tags/agents.md>), [agntcon](<https://devfeed.tech/tags/agntcon.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [assembly](<https://devfeed.tech/tags/assembly.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-marketplace](<https://devfeed.tech/tags/aws-marketplace.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [berkeley](<https://devfeed.tech/tags/berkeley.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [c](<https://devfeed.tech/tags/c.md>), [ci](<https://devfeed.tech/tags/ci.md>), [code](<https://devfeed.tech/tags/code.md>), [code-review](<https://devfeed.tech/tags/code-review.md>), [coding](<https://devfeed.tech/tags/coding.md>), [coding-agents](<https://devfeed.tech/tags/coding-agents.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [distributed-system](<https://devfeed.tech/tags/distributed-system.md>), [mistakes](<https://devfeed.tech/tags/mistakes.md>), [podcast](<https://devfeed.tech/tags/podcast.md>), [premium-event-coverage](<https://devfeed.tech/tags/premium-event-coverage.md>), [rust](<https://devfeed.tech/tags/rust.md>), [software-testing](<https://devfeed.tech/tags/software-testing.md>), [sponsor-aws-marketplace](<https://devfeed.tech/tags/sponsor-aws-marketplace.md>), [sponsored](<https://devfeed.tech/tags/sponsored.md>), [sponsored-podcast](<https://devfeed.tech/tags/sponsored-podcast.md>), [sponsored-premium-event-coverage](<https://devfeed.tech/tags/sponsored-premium-event-coverage.md>), [video](<https://devfeed.tech/tags/video.md>)

### AI overview

Hydro uses compile-time checks to catch several classes of distributed-systems bugs, giving coding agents feedback outside their own tests. AWS research lead Shadaj Laddad argues this can help address a review bottleneck as agents produce larger, faster changes that may work alone but break when combined; tests are limited when agents write both code and tests. The team is exploring reusable, domain-specific guardrails based on recurring design concerns such as idempotency, but this remains exploratory. Compile-time checks have limits: AI-generated Rust can compile and still be wrong. Hydro is an early release for teams running high-throughput, low-latency services, with rough edges and a learning curve. Separately, the article describes Infinity, an open-source runtime that suspends agents while they wait for tool calls or CI jobs; its 75,000-agent Raspberry Pi figure is extrapolated from server testing.

### Source excerpt

Earlier this month, the team behind Hydro developed a new way to check that a distributed system still works correctly The post AWS's Hydro team wants the compiler to catch coding agents' mistakes appeared first on The New Stack.

## ProCerDCL: Query-Efficient Black-Box Probabilistic Verification of Deep Learning Compiler Optimization

DevFeed: [ProCerDCL: Query-Efficient Black-Box Probabilistic Verification of Deep Learning Compiler Optimization](<https://devfeed.tech/articles/procerdcl-query-efficient-black-box-probabilistic-verification-of-deep-learning-compiler-optimization-103145.md>)

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

Author: Zexin Li, Weibo Zhang, Linyi Li, Arvind Easwaran, Simin Chen

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

Content type: article

Language: en

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

Topics: [Compiler](<https://devfeed.tech/topics/compiler.md>), [TensorRT](<https://devfeed.tech/topics/tensorrt.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [acceptance](<https://devfeed.tech/tags/acceptance.md>), [apply](<https://devfeed.tech/tags/apply.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [backend](<https://devfeed.tech/tags/backend.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [black](<https://devfeed.tech/tags/black.md>), [box](<https://devfeed.tech/tags/box.md>), [budget](<https://devfeed.tech/tags/budget.md>), [can](<https://devfeed.tech/tags/can.md>), [case-studies](<https://devfeed.tech/tags/case-studies.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-optimization](<https://devfeed.tech/tags/compiler-optimization.md>), [cs-ai](<https://devfeed.tech/tags/cs-ai.md>), [cs-pl](<https://devfeed.tech/tags/cs-pl.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [deep](<https://devfeed.tech/tags/deep.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [learning](<https://devfeed.tech/tags/learning.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [probabilistic](<https://devfeed.tech/tags/probabilistic.md>), [query](<https://devfeed.tech/tags/query.md>), [verification](<https://devfeed.tech/tags/verification.md>)

### AI overview

ProCerDCL tests whether a binary property oracle's violation probability under a fixed, sampleable input distribution is below a threshold. Assuming independent sampling and a stateless oracle, it returns acceptance, rejection, or inconclusive, with error probabilities bounded by specified budgets; rejection requires evidence that the probability exceeds the threshold by a user-set margin. A single sequential test handles repeated checks using corrected exact binomial intervals or an anytime-valid confidence sequence. Applied to decision-level consistency between reference and compiled model executions, it covers TorchInductor and TensorRT. In paired clean-label radius searches, the baseline used 3.6-4.2 times more unique samples under matched parameters and offered a weaker decision contract. At a threshold of 10⁻³, checks across 840 input-backend instances from 21 tasks produced 817 acceptances, 19 inconclusive verdicts, and 4 rejections. The abstract also reports diagnostic case studies of two documented compiler faults.

### Source excerpt

arXiv:2610.36499v1 Announce Type: cross Abstract: We present \tool, a query-efficient framework for black-box probabilistic verification. Given a fixed, sampleable input distribution and a binary property oracle, \tool assesses the property's violation probability $p$ against a threshold $\theta$. Under independent sampling and stateless oracle behavior, acceptance asserts $p\le\theta$, rejection asserts $p>\theta+\eta$ for a user-specified separation margin, and an inconclusive verdict indicates insufficient evidence for either conclusion. The probability of each type of erroneous verdict is bounded by its specified error budget. To support this three-valued contract efficiently, \tool uses a single sequential test, eliminating the interval family required by the baseline. The test accounts for repeated sampling checks through either corrected exact binomial confidence intervals or an anytime-valid confidence sequence. We apply \tool to probabilistic local model semantic consistency, where the property oracle detects decision-level inconsistencies between reference and compiled executions under a specified perturbation distribution. Our evaluation covers 24 tasks across TorchInductor and TensorRT and examines sampling efficiency, conclusiveness, and diagnostic behavior. For sampling efficiency, we use paired one-model clean-label radius searches: the baseline requires 3.6-4.2 times as many unique samples under matched numerical parameters while providing a weaker decision contract. For model semantic consistency, checks at $\theta=10^{-3}$ yield 817 acceptances, 19 inconclusive verdicts, and 4 rejections across 840 input--backend instances from 21 tasks. Case studies of two documented compiler faults further demonstrate what these local verdicts can diagnose.

## QTUNER: A Feature-Guided Adaptive Framework for Quantum-Compiler Optimization Pass Tuning

DevFeed: [QTUNER: A Feature-Guided Adaptive Framework for Quantum-Compiler Optimization Pass Tuning](<https://devfeed.tech/articles/qtuner-a-feature-guided-adaptive-framework-for-quantum-compiler-optimization-pass-tuning-103606.md>)

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

Author: Ming Zhong, Xiangyu Ren, Jinglei Cheng, Shaohua Li, Zhiding Liang

Published: 2026-10-28T04: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>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Hyperparameter optimization](<https://devfeed.tech/topics/hyperparameter-optimization.md>), [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>)

Tags: [2q](<https://devfeed.tech/tags/2q.md>), [adaptive](<https://devfeed.tech/tags/adaptive.md>), [bayesian](<https://devfeed.tech/tags/bayesian.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [circuit](<https://devfeed.tech/tags/circuit.md>), [circuits](<https://devfeed.tech/tags/circuits.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-optimization](<https://devfeed.tech/tags/compiler-optimization.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [dag](<https://devfeed.tech/tags/dag.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [effectiveness](<https://devfeed.tech/tags/effectiveness.md>), [embeddings](<https://devfeed.tech/tags/embeddings.md>), [execution](<https://devfeed.tech/tags/execution.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [framework](<https://devfeed.tech/tags/framework.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [pass](<https://devfeed.tech/tags/pass.md>), [quant-ph](<https://devfeed.tech/tags/quant-ph.md>), [quantum](<https://devfeed.tech/tags/quantum.md>)

### AI overview

QTuner uses circuit features tied to optimization behavior to find promising quantum-compiler pass sequences. It builds a dataset of sequences found by Bayesian Optimization, combines static circuit features with optimization-aware pass embeddings, and trains two offline models to retrieve and rank candidates for new circuits. Across two benchmarks, Qiskit results show up to a 10.6 percentage-point improvement in 2Q gate reduction over the strongest baseline while cutting tuning time by 73.59%; PyTKET results show up to a 9.4-point improvement and a 64.49% time reduction. The supplied abstract does not detail the benchmarks or evaluation conditions.

### Source excerpt

arXiv:2607.04586v2 Announce Type: replace-cross Abstract: Quantum compiler optimization is important for improving the execution fidelity of quantum circuits. In practice, this optimization is often formulated as reducing circuit-level metrics. In classical compilers, pass tuning has been well-established through various methods. However, these methods cannot be directly applied to quantum compilers, because quantum programs exhibit quantum-specific features. Existing quantum compiler tuning studies have attempted to incorporate quantum circuit features with compiler tuning techniques, but they still suffer from two key limitations. First, they tune only a limited subset of optimization passes, leaving the global effectiveness of the full optimization pass space underexplored. Second, the quantum features they use are mainly static features, such as structure and DAG features, which are not directly tied to the optimization characteristics of quantum circuits. In this paper, we propose QTuner, a feature-guided framework for quantum compiler pass tuning. We first construct an optimization dataset by performing Bayesian Optimization and recording their optimized pass sequences. Based on this dataset, QTuner represents each circuit with two types of features: static circuit features and optimization-aware pass embeddings. Finally, QTuner trains two models offline, which are used to efficiently retrieve and rank promising pass sequences for a new circuit. We evaluate QTuner on two benchmarks across Qiskit and PyTKET compilers. On Qiskit, QTuner achieves up to a 10.6-percentage-point improvement in 2Q gate reduction over the strongest baseline while reducing tuning time by 73.59%. On PyTKET, QTuner achieves up to a 9.4-percentage-point improvement in 2Q gate reduction and reduces tuning time by 64.49%. These results demonstrate that QTuner enables efficient pass tuning across quantum compilers.

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