# mlir

MLIR is a compiler intermediate representation and extensible compiler infrastructure for representing, analyzing, transforming, and progressively lowering code from high-level dataflow graphs to 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.

## MLIR-MRacle: Memory-Model-Aware Metamorphic Fuzzing of Concurrent MLIR

DevFeed: [MLIR-MRacle: Memory-Model-Aware Metamorphic Fuzzing of Concurrent MLIR](<https://devfeed.tech/articles/mlir-mracle-memory-model-aware-metamorphic-fuzzing-of-concurrent-mlir-142218.md>)

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

Author: Aaron Gabayoyo, Aidan Dakhama, Ajitha Rajan

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

Content type: article

Language: en

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

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [Fuzzing/Fuzz testing](<https://devfeed.tech/topics/fuzzing.md>)

Tags: [bug](<https://devfeed.tech/tags/bug.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [concurrent](<https://devfeed.tech/tags/concurrent.md>), [coverage](<https://devfeed.tech/tags/coverage.md>), [cs-se](<https://devfeed.tech/tags/cs-se.md>), [execution](<https://devfeed.tech/tags/execution.md>), [extension](<https://devfeed.tech/tags/extension.md>), [fixed](<https://devfeed.tech/tags/fixed.md>), [fuzzing](<https://devfeed.tech/tags/fuzzing.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [memory-model](<https://devfeed.tech/tags/memory-model.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [openmp](<https://devfeed.tech/tags/openmp.md>), [optimisation](<https://devfeed.tech/tags/optimisation.md>), [oracles](<https://devfeed.tech/tags/oracles.md>)

### AI overview

MLIR-MRacle tests concurrent MLIR compiler lowerings by applying metamorphic transformations gated by the target memory model, keeping both program variants well defined. It runs each repeatedly and uses one of two statistical oracles to compare outcome sets or distributions, with a libafl coverage-guided driver for continuous fuzzing. In an Armv8 case study, it ran more than 145,000 trials across four configurations, reached up to 93,600 compiler coverage edges, and found an OpenMP dialect verifier bug that has since been fixed upstream. The abstract says transformations, memory models, oracles, and execution backends are extensible.

### Source excerpt

arXiv:2611.24804v1 Announce Type: new Abstract: Multi-level compilers built on MLIR lower concurrent programs through many stages towards targets with potentially drastically different memory models, where an optimisation which appears reasonable, can silently change program behaviour. Testing these lowerings is hard: a concurrent program often has no single expected outcome, and existing MLIR fuzzers often assume determinism. We present MLIR-MRacle, a memory-model-aware metamorphic fuzzer for concurrent MLIR programs. MLIR-MRacle applies metamorphic relations gated by the target memory model, so that both the original and transformed programs remain well defined - executing both repeatedly, and comparing their outcome sets or distributions withone of two statistical oracles. A coverage guided campaign driver built on libafl is used to perform continuous fuzzing. MRs, memory models, oracles, and execution backends all provide extension points for future researchers and compiler engineers to build off this package. In a case study on Armv8 hardware, MLIR-MRacle ran over 145k trials across four configurations, reaching up to 93.6k compiler coverage edges, and found a bug in the OpenMP dialect verifier that has since been fixed upstream. Video: https://youtu.be/lKtGk0H97Ts?si=dWLUHl2CJ24ep6JY

## Keeping Agents Fast: High-Interactivity Decode with FlyDSL MonoKernels in vLLM

DevFeed: [Keeping Agents Fast: High-Interactivity Decode with FlyDSL MonoKernels in vLLM](<https://devfeed.tech/articles/keeping-agents-fast-high-interactivity-decode-with-flydsl-monokernels-in-vllm-140940.md>)

Original publisher: [Read original article](<https://vllm.ai/blog/2026-11-18-flydsl-monokernels>)

Author: Felix Li, Lingpeng Jin, Hattie Wu, Carlus Huang, Fangzhou Ai, Zaidy Ali, Amanzhol Salykov, Hyukjoon Lee, Ziming Huang, Jun Chen, Yifeng Huang, Bin Ding, Xiaobing Zhang, Yi Gan, Vinayak Gokhale, Hongxi

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

Content type: article

Language: en

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

Topics: [vllm](<https://devfeed.tech/topics/vllm.md>), [rocm](<https://devfeed.tech/topics/rocm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [quantization](<https://devfeed.tech/topics/quantization.md>), [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>)

Tags: [agents](<https://devfeed.tech/tags/agents.md>), [ai-engineering](<https://devfeed.tech/tags/ai-engineering.md>), [amd](<https://devfeed.tech/tags/amd.md>), [decode](<https://devfeed.tech/tags/decode.md>), [fusion](<https://devfeed.tech/tags/fusion.md>), [handoffs](<https://devfeed.tech/tags/handoffs.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [instinct](<https://devfeed.tech/tags/instinct.md>), [integration](<https://devfeed.tech/tags/integration.md>), [llm-inference](<https://devfeed.tech/tags/llm-inference.md>), [model](<https://devfeed.tech/tags/model.md>), [model-serving](<https://devfeed.tech/tags/model-serving.md>), [open-source-ai](<https://devfeed.tech/tags/open-source-ai.md>), [performance](<https://devfeed.tech/tags/performance.md>), [vllm](<https://devfeed.tech/tags/vllm.md>), [vllm-blog](<https://devfeed.tech/tags/vllm-blog.md>)

### AI overview

FlyDSL MonoKernels aim to reduce low-concurrency decode latency in vLLM on AMD Instinct GPUs by combining dependent stages into a few persistent kernel launches. Authors choose model-specific boundaries and schedules; FlyDSL compiles them, while vLLM selects the opt-in path for supported steps. Thread blocks can reuse work across stages, prefetch weights, and hand off ready tiles through tagged mailboxes, though dependencies and memory traffic remain. Reported evaluations show gains across several models, with results varying by model, GPU, concurrency, and benchmark; some comparisons use historical baselines. The paths preserve vLLM's scheduler and KV cache, fall back to stock layers for unsupported workloads, and require accuracy checks per configuration. Limits include reduced gains at higher concurrency, maximum step widths, and extra weight copies on MI300X/MI325X.

### Source excerpt

How FlyDSL MonoKernels keep agents responsive with high-interactivity decode in vLLM on AMD Instinct GPUs, using model-specific fusion, data-ready handoffs, and specialized-decode integration.

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

## How We Built TLX: A Hardware-Native GPU Compiler for Production ML at Scale

DevFeed: [How We Built TLX: A Hardware-Native GPU Compiler for Production ML at Scale](<https://devfeed.tech/articles/how-we-built-tlx-a-hardware-native-gpu-compiler-for-production-ml-at-scale-126664.md>)

Original publisher: [Read original article](<https://engineering.fb.com/2026/11/10/open-source/tlx-a-hardware-native-gpu-compiler-for-production-ml/>)

Author: Hongtao Yu; Peng Chen; Daohang Shi; Nick Riasanovsky; Lei Wang; Partha Kanuparthy

Published: 2026-11-10T16:59:31Z

Content type: article

Language: en

Sources: [Engineering at Meta](<https://devfeed.tech/sources/engineering-at-meta.md>), [Meta ML Applications](<https://devfeed.tech/sources/meta-ml-applications.md>)

Topics: [LLM optimization](<https://devfeed.tech/topics/llm-optimization.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [Production Engineering](<https://devfeed.tech/topics/production-engineering.md>), [scheduling](<https://devfeed.tech/topics/scheduling.md>)

Tags: [architectures](<https://devfeed.tech/tags/architectures.md>), [capabilities](<https://devfeed.tech/tags/capabilities.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developers](<https://devfeed.tech/tags/developers.md>), [devinfra](<https://devfeed.tech/tags/devinfra.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [engineers](<https://devfeed.tech/tags/engineers.md>), [extension](<https://devfeed.tech/tags/extension.md>), [extensions](<https://devfeed.tech/tags/extensions.md>), [first](<https://devfeed.tech/tags/first.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [helps](<https://devfeed.tech/tags/helps.md>), [improvements](<https://devfeed.tech/tags/improvements.md>), [inference](<https://devfeed.tech/tags/inference.md>), [large](<https://devfeed.tech/tags/large.md>), [llm](<https://devfeed.tech/tags/llm.md>), [ml](<https://devfeed.tech/tags/ml.md>), [ml-applications](<https://devfeed.tech/tags/ml-applications.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [production](<https://devfeed.tech/tags/production.md>), [production-engineering](<https://devfeed.tech/tags/production-engineering.md>), [scale](<https://devfeed.tech/tags/scale.md>)

### AI overview

TLX extends Triton with an execution layer that makes warp-group cooperation, synchronization, asynchronous memory movement, and cluster execution explicit while retaining Triton's tensor operations, Python workflow, and autotuning. The authors describe this as a middle ground between CUDA's thread-level control and Triton's more implicit blocked model. TLX provides access to hardware features such as TMA, async tensor-core operations, and TMEM; layouts are inferred by default and can be tuned when needed, which the authors say eases fusion. Reported deployments include GEM training on Blackwell, where a TLX GDPA kernel delivered up to 2x forward speedup; RecSys inference, where a warp-specialized compression kernel achieved 4x speedup on H100 and a co-designed FlashAttention optimization reduced compute-intensive net latency by up to two-thirds; and distributed grouped GEMM for MoE pretraining. These are workload-specific results. The article says TLX targets NVIDIA Hopper and Blackwell and AMD MI300 and MI350X, with broader architecture support and PyTorch 2.x integration still in development.

### Source excerpt

Triton Low-Level Extensions (TLX), is an extension to Triton that helps engineers optimize GPU performance while preserving Triton's productive programming model. TLX introduces explicit warp-group and cluster-level orchestration, letting developers adopt new hardware capabilities without sacrificing velocity. TLX has demonstrated performance improvements in RecSys training, RecSys inference, and large-scale LLM pretraining. Modern GPU architectures increasingly [...] Read More... The post How We Built TLX: A Hardware-Native GPU Compiler for Production ML at Scale appeared first on Engineering at Meta.

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

## EdgeKernelBench: Unified LLM-Driven Kernel Generation for Edge Backends

DevFeed: [EdgeKernelBench: Unified LLM-Driven Kernel Generation for Edge Backends](<https://devfeed.tech/articles/edgekernelbench-unified-llm-driven-kernel-generation-for-edge-backends-93337.md>)

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

Author: Yuhua Zheng, Xueyi Chen, Xinze Zou, Xin Li, Haoji Hu, Huan Wang

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

Content type: article

Language: en

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

Topics: [Large Language Model](<https://devfeed.tech/topics/llm.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [GPU optimization](<https://devfeed.tech/topics/gpu-optimization.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [deployment](<https://devfeed.tech/tags/deployment.md>), [edge](<https://devfeed.tech/tags/edge.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [framework](<https://devfeed.tech/tags/framework.md>), [functional](<https://devfeed.tech/tags/functional.md>), [generation](<https://devfeed.tech/tags/generation.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [ir](<https://devfeed.tech/tags/ir.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [llm](<https://devfeed.tech/tags/llm.md>), [llms](<https://devfeed.tech/tags/llms.md>), [memory](<https://devfeed.tech/tags/memory.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [performance](<https://devfeed.tech/tags/performance.md>), [software](<https://devfeed.tech/tags/software.md>), [target](<https://devfeed.tech/tags/target.md>)

### AI overview

EdgeKernelBench evaluates LLM-generated kernels across heterogeneous edge backends using a unified IR framework and a hierarchical benchmark ranging from individual operators to compact model graphs. In the TVM-based reference implementation, the best model reached 64.5% Correct@1 but 25.5% Fast@1.0 in a single generation attempt, showing that correctness did not reliably yield speedups. The proposed Layered Edge Kernel Agent (LEKA) organizes optimization through layered IR; on the agent evaluation subset, it achieved 43.5% Fast@1.0, versus 13.0% for direct generation and 26.1% for Claude Code. LEKA and Claude Code used the same base model and optimization budget.

### Source excerpt

arXiv:2610.24648v1 Announce Type: new Abstract: Recent works show that LLMs can generate kernels with strong performance on server GPUs. Edge deployment presents distinct challenges because the hardware is heterogeneous, the software stacks are fragmented, and the resource budgets are tight. LLM kernel generation across diverse edge backends has yet to be studied systematically. We introduce EdgeKernelBench, which combines a unified IR deployment framework with a hierarchical benchmark for edge workloads. The unified IR captures reusable computation, scheduling, and memory decisions and connects to each target backend through a compiler interface. The benchmark spans progressively larger program scopes, from individual operators to compact model graphs, across representative edge application domains. We instantiate the design with TVM as a reference compiler and validate it across heterogeneous edge backends. With a single generation attempt, the best model achieves 64.5% Correct@1 but only 25.5% Fast@1.0. This gap shows that functional correctness does not consistently translate into performance gains. We therefore introduce the Layered Edge Kernel Agent (LEKA), which organizes optimization through a layered IR. On the agent evaluation subset, LEKA achieves 43.5% Fast@1.0, compared with 13.0% for direct generation and 26.1% for Claude Code. LEKA and Claude Code use the same base model and optimization budget. Together, EdgeKernelBench and LEKA support unified evaluation and layered optimization of kernels generated by LLMs across edge backends.

## From KTIR to SpyreCode: An MLIR Dataflow Backend for IBM Spyre

DevFeed: [From KTIR to SpyreCode: An MLIR Dataflow Backend for IBM Spyre](<https://devfeed.tech/articles/from-ktir-to-spyrecode-an-mlir-dataflow-backend-for-ibm-spyre-91072.md>)

Original publisher: [Read original article](<https://pytorch.org/blog/from-ktir-to-spyrecode-an-mlir-dataflow-backend-for-ibm-spyre/>)

Author: Swagath Venkataramani, Bardia Mahjour, Prasanth Chatarasi, Alberto Mannari, Viji Srinivasan, and the IBM Spyre Team

Published: 2026-10-20T16:00:15Z

Content type: article

Language: en

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

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [dma](<https://devfeed.tech/topics/dma.md>), [vectorization techniques](<https://devfeed.tech/topics/vectorization-techniques.md>), [ibm](<https://devfeed.tech/topics/ibm.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [abstract](<https://devfeed.tech/tags/abstract.md>), [abstraction](<https://devfeed.tech/tags/abstraction.md>), [account](<https://devfeed.tech/tags/account.md>), [activation](<https://devfeed.tech/tags/activation.md>), [backend](<https://devfeed.tech/tags/backend.md>), [blog](<https://devfeed.tech/tags/blog.md>), [chip](<https://devfeed.tech/tags/chip.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [dataflow](<https://devfeed.tech/tags/dataflow.md>), [first](<https://devfeed.tech/tags/first.md>), [ibm](<https://devfeed.tech/tags/ibm.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [memory](<https://devfeed.tech/tags/memory.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [post](<https://devfeed.tech/tags/post.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [torch](<https://devfeed.tech/tags/torch.md>), [work](<https://devfeed.tech/tags/work.md>)

### AI overview

KTIR carries Inductor's core assignments, tensor placement and scratchpad residency into the Spyre backend, where an open-source MLIR Dataflow Scheduler turns each compute group into a hardware-ready pipeline. Guided by an architecture description, it routes transfers through available memories and engines, nests tile and vector pipelines, and adds buffering and parallelism before emitting DataflowIR. Device-specific stages convert that representation into SpyreCode with symbolic tensor addresses and shapes; the runtime prepares its binary once and resolves symbols at launch. Version 1 supports elementwise operations, broadcasts and reductions across multi-core programs; the post says it was validated on representative transformer operations. Its scheduling choices use local heuristics, with cost-model optimization and matrix multiplication support described as future work.

### Source excerpt

TL;DR Torch-spyre's Inductor decides how each kernel's work is divided across Spyre's cores and manages tensor residency between on-chip scratchpad and off-chip memory, and the backend compiler turns those decisions... The post From KTIR to SpyreCode: An MLIR Dataflow Backend for IBM Spyre appeared first on PyTorch.

## Unifying Edge AI: How Coral NPU's open standard brings portable, energy-viable intelligence from model to silicon

DevFeed: [Unifying Edge AI: How Coral NPU's open standard brings portable, energy-viable intelligence from model to silicon](<https://devfeed.tech/articles/unifying-edge-ai-how-coral-npu-s-open-standard-brings-portable-energy-viable-intelligence-from-model-to-silicon-90648.md>)

Original publisher: [Read original article](<https://developers.googleblog.com/unifying-edge-ai-how-coral-npus-open-standard-brings-portable-energy-viable-intelligence-from-model-to-silicon/>)

Author: Billy Rutledge

Published: 2026-10-20T14:35:28.700212Z

Content type: release

Language: en

Sources: [Google Developers Blog](<https://devfeed.tech/sources/google-developers-blog.md>)

Topics: [RISC-V](<https://devfeed.tech/topics/riscv.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [edge](<https://devfeed.tech/tags/edge.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>), [risc-v](<https://devfeed.tech/tags/risc-v.md>)

### AI overview

Google Research announces completion of the 32-bit Coral NPU RISC-V design with its Matrix Execution Unit, alongside the v1.0 open-source IREE/MLIR compiler toolchain. The compiler targets models from JAX, PyTorch, and TensorFlow for edge hardware, while the article also describes simulator and FPGA resources, commercial silicon partnerships, and upcoming 64-bit and CHERI work.

### Source excerpt

Google Research has completed the 32-bit open-source Coral NPU RISC-V architecture with the introduction of its Matrix Execution Unit, which delivers up to 1 TOPS while targeting 10 mW average power for edge inference. Alongside this architecture, the release of the v1.0 open-source IREE/MLIR compiler allows developers to take models from JAX, PyTorch, and TensorFlow straight to Coral NPU hardware without writing custom assembly. Developers can now prototype and deploy these multimodal edge applications using new hardware options like the Synaptics Astra SR200 MCU series and globally available Coralboard devkits.12

## Static Memory Planner for MLIR: A GSoC 2026 Journey

DevFeed: [Static Memory Planner for MLIR: A GSoC 2026 Journey](<https://devfeed.tech/articles/static-memory-planner-for-mlir-a-gsoc-2026-journey-89907.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2026-08-24-gsoc-2026-static-memory-planner/>)

Author: Krish Gupta

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

Content type: article

Language: en

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

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [memory handling](<https://devfeed.tech/topics/memory-handling.md>), [memory pool](<https://devfeed.tech/topics/memory-pool.md>), [Memory Safety](<https://devfeed.tech/topics/memory-safety.md>)

Tags: [buffer](<https://devfeed.tech/tags/buffer.md>), [bufferization](<https://devfeed.tech/tags/bufferization.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [heap](<https://devfeed.tech/tags/heap.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-foundation](<https://devfeed.tech/tags/llvm-foundation.md>), [memory](<https://devfeed.tech/tags/memory.md>), [memory-planning](<https://devfeed.tech/tags/memory-planning.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [performance](<https://devfeed.tech/tags/performance.md>), [process](<https://devfeed.tech/tags/process.md>), [time](<https://devfeed.tech/tags/time.md>), [transformation](<https://devfeed.tech/tags/transformation.md>), [types](<https://devfeed.tech/tags/types.md>)

### AI overview

A Google Summer of Code contributor describes an MLIR static memory planning pass that replaces separate heap allocations with a compile-time arena and views. It traces the pass's development through alias analysis, control-flow cases, testing, and upstream review, and notes that current planning is limited to allocations in a function's entry block.

### Source excerpt

Hi, I am Krish Gupta. Over the summer I worked with the LLVM Foundation as partof Google Summer of Code 2026on building a static memory planner for MLIR, mentored byMatthias Springer andJaved Absar. This post walks through what webuilt, why it matters, and what the iterative process of landing it upstreamactually looked like. The Problem After bufferization, buffer lifetimes in MLIR IR are fully explicit: thecompiler knows exactly when each allocation starts and ends (for staticshapes; runtime-dependent allocations are handled conservatively). We use thisinformation to eliminate redundant heap allocations through a static memoryplanner. This matters for accelerator-oriented compilation. On many targets (embeddedCPUs, DSPs, custom accelerators) heap allocation is either not allowed orslow, because access to main memory is expensive. Even where heap allocationis available, individual small allocations hurt performance throughfragmentation and cache pressure. What you want instead is a single staticarena whose layout is computed at compile time: // Before: three separate heap allocations%a = memref.alloc() : memref<1024xf32> // 4096 bytes%b = memref.alloc() : memref<512xf32> // 2048 bytesmemref.dealloc %a : memref<1024xf32>memref.dealloc %b : memref<512xf32>// After: one arena, two views%arena = memref.alloc() : memref<6144xi8>%a = memref.view %arena[0][] : memref<6144xi8> to memref<1024xf32>%b = memref.view %arena[4096][]: memref<6144xi8> to memref<512xf32>// ... uses of %a and %b ...memref.dealloc %arena : memref<6144xi8> The arena is memref<Nxi8> so it can hold buffers of different datatypes.memref.view reinterprets slices back to their original types with zerooverhead. This is the core transformation the planner performs. How the Pass Works The pass is a FunctionOpInterface pass: it runs per function and processesthe entire function body in six steps: Step 1: Collect candidates: walk all memref.alloc ops, find their deallocs via alias analysis, apply eligibility ch

## IREE 3.12 Rewrites Vulkan Driver and Adds Experimental AMD HSA HAL

DevFeed: [IREE 3.12 Rewrites Vulkan Driver and Adds Experimental AMD HSA HAL](<https://devfeed.tech/articles/iree-3-12-introduces-rolls-out-rewritten-vulkan-driver-experimental-amd-hsa-hal-86185.md>)

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

Author: Michael Larabel

Published: 2026-10-13T10:00:22Z

Content type: release

Language: en

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

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

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [desktop-linux](<https://devfeed.tech/tags/desktop-linux.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hal](<https://devfeed.tech/tags/hal.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>), [release](<https://devfeed.tech/tags/release.md>), [ubuntu-benchmarks](<https://devfeed.tech/tags/ubuntu-benchmarks.md>), [ubuntu-hardware](<https://devfeed.tech/tags/ubuntu-hardware.md>), [vulkan](<https://devfeed.tech/tags/vulkan.md>)

### AI overview

IREE 3.12 rewrites its Vulkan driver with support for Vulkan 1.3 and adds an experimental, opt-in AMD HSA HAL driver. The release also adds GPU support and updates CPU execution and compiler targets.

### Source excerpt

Rolling out last week was a new version of IREE as the Intermediate Representation Execution Environment for MLIR-based end-to-end compiler and run-time for lowering machine learning models into a unified IR and working across different hardware/driver stacks. Making IREE 3.12 notable is a rewrite to its Vulkan code...

## ClangIR and the cost of MLIR

DevFeed: [ClangIR and the cost of MLIR](<https://devfeed.tech/articles/clangir-and-the-cost-of-mlir-85056.md>)

Original publisher: [Read original article](<https://maskray.me/blog/clangir-and-the-cost-of-mlir>)

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

Content type: article

Language: en

Sources: [MaskRay](<https://devfeed.tech/sources/maskray.md>)

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

Tags: [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clangir](<https://devfeed.tech/tags/clangir.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-ir](<https://devfeed.tech/tags/llvm-ir.md>), [mlir](<https://devfeed.tech/tags/mlir.md>)

### AI overview

The article examines ClangIR (CIR), an MLIR-based intermediate representation for Clang, and the engineering costs of making it part of Clang's build. It details effects on build time, binary size, contributor workflows, and maintenance, then considers an MLIR-free CIR as a thought experiment. It argues that the costs fall largely on Clang contributors and users while benefits accrue to organizations funding CIR.

### Source excerpt

ClangIR (CIR) is an MLIR dialect between the AST and LLVM IR, and in October 2026 the clang area team accepted building it by default. CIR is built on MLIR because each step along the way was locally reasonable, and together the steps locked MLIR in. The costs (build time, binary size, MLIR API churn) land largely on Clang contributors who neither chose MLIR nor use CIR. This post traces how CIR came to depend on MLIR, collects what the dependency costs, and uses an MLIR-free CIR as a thought experiment to separate the costs inherent to MLIR from those that can be reduced.

## \[$\] Analyzing Rust programs with Charon

DevFeed: [\[$\] Analyzing Rust programs with Charon](<https://devfeed.tech/articles/analyzing-rust-programs-with-charon-66979.md>)

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

Author: daroc

Published: 2026-10-07T15:19:59Z

Content type: news

Language: en

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

Topics: [Rust](<https://devfeed.tech/topics/rust.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [OCaml](<https://devfeed.tech/topics/ocaml.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>)

Tags: [abi](<https://devfeed.tech/tags/abi.md>), [abstraction](<https://devfeed.tech/tags/abstraction.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [api](<https://devfeed.tech/tags/api.md>), [c](<https://devfeed.tech/tags/c.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cryptography](<https://devfeed.tech/tags/cryptography.md>), [functions](<https://devfeed.tech/tags/functions.md>), [pattern-matching](<https://devfeed.tech/tags/pattern-matching.md>), [rust](<https://devfeed.tech/tags/rust.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [usability](<https://devfeed.tech/tags/usability.md>)

### AI overview

Charon gives tools a stable, regular way to inspect what rustc sees in a Rust crate, avoiding repeated dependence on compiler interfaces that can break without warning. Running `charon cargo` compiles a project and emits readable JSON in a `.llbc` file, with types, traits, functions, layouts and explicit details such as drops and unwinding; it can also pretty-print this data as Rust-like code. The regular output simplifies tooling, including a demonstrated linter of about 60 lines. Compared with `rustc_public`, Charon adds more abstraction and parsing-friendly formatting. It supports either MIR by default or elaborated MIR with `--precise-drops`. The text says it supports Rust features except async, with bugs remaining. Rust-to-C translation targets safe Rust and can produce legible code, but generating fast C is harder because patterns that perform well differ between Rust and C. Showing optimization-pass effects was suggested as a useful future capability, but Charon did not yet provide it.

### Source excerpt

Nadrieril is a long-time Rust contributor, and the maintainer of the rustc pattern-matching infrastructure. During his involvement with Rust, he has noticed a problem with the usability of the language: it is difficult to automatically extract information from a Rust crate for use with other tooling. The Charon project aims to fix that by providing a stable API for accessing internal information from the Rust compiler.

## Google Adds Cycle-Level Kernel Profiling to XProf

DevFeed: [Google Adds Cycle-Level Kernel Profiling to XProf](<https://devfeed.tech/articles/google-adds-cycle-level-kernel-profiling-to-xprof-58474.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/09/google-tpu-xprof/>)

Author: Claudio Masolo

Published: 2026-09-23T10:00:00Z

Content type: news

Language: en

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

Topics: [Kernel](<https://devfeed.tech/topics/kernel.md>), [Google](<https://devfeed.tech/topics/google.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [mlir](<https://devfeed.tech/topics/mlir.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-ml-data-engineering](<https://devfeed.tech/tags/ai-ml-data-engineering.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [code-profiler](<https://devfeed.tech/tags/code-profiler.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [developers](<https://devfeed.tech/tags/developers.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [google](<https://devfeed.tech/tags/google.md>), [google-tpu-xprof](<https://devfeed.tech/tags/google-tpu-xprof.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [kernel](<https://devfeed.tech/tags/kernel.md>), [low-level](<https://devfeed.tech/tags/low-level.md>), [memory](<https://devfeed.tech/tags/memory.md>), [ml-data-engineering](<https://devfeed.tech/tags/ml-data-engineering.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [news](<https://devfeed.tech/tags/news.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [performance](<https://devfeed.tech/tags/performance.md>), [profiling](<https://devfeed.tech/tags/profiling.md>), [runtime-telemetry](<https://devfeed.tech/tags/runtime-telemetry.md>), [tpu](<https://devfeed.tech/tags/tpu.md>), [trace](<https://devfeed.tech/tags/trace.md>)

### AI overview

Google added a Kernel Profiling suite to its open-source XProf profiler, giving developers cycle-level visibility into custom TPU kernels. The tooling inspects lowered MLIR, static execution, and runtime hardware-counter telemetry. A Google-authored matmul example reduced kernel time from 125.5µs to 88µs through triple buffering, but the result is presented as a workflow demonstration rather than a broad benchmark.

### Source excerpt

Google has added a Kernel Profiling suite to XProf. This is its open-source profiler for TPU workloads. Now, developers can see cycle-level details in custom Pallas kernels. Before, these kernels appeared as single opaque blocks in trace captures. By Claudio Masolo

## Your Guide to Hardware Acceleration & Compute Infrastructure at PyTorch Conference North America 2026

DevFeed: [Your Guide to Hardware Acceleration & Compute Infrastructure at PyTorch Conference North America 2026](<https://devfeed.tech/articles/your-guide-to-hardware-acceleration-compute-infrastructure-at-pytorch-conference-north-america-2026-49482.md>)

Original publisher: [Read original article](<https://pytorch.org/blog/your-guide-to-hardware-acceleration-compute-infrastructure-at-pytorch-conference-north-america-2026/>)

Author: PyTorch Foundation

Published: 2026-09-04T17:45:31Z

Content type: article

Language: en

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

Topics: [PyTorch](<https://devfeed.tech/topics/pytorch.md>), [Hardware](<https://devfeed.tech/topics/hardware.md>), [GPU](<https://devfeed.tech/topics/gpu.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [cloud-infrastructure](<https://devfeed.tech/topics/cloud-infrastructure.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [blog](<https://devfeed.tech/tags/blog.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compute](<https://devfeed.tech/tags/compute.md>), [conference](<https://devfeed.tech/tags/conference.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [hardware](<https://devfeed.tech/tags/hardware.md>), [infrastructure](<https://devfeed.tech/tags/infrastructure.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [pytorch](<https://devfeed.tech/tags/pytorch.md>)

### AI overview

A guide to PyTorch Conference North America 2026 sessions covering hardware acceleration and compute infrastructure, including GPUs, TPUs, NPUs, custom ASICs, compiler backends, kernel engineering, and observability tooling.

### Source excerpt

TL:DR PyTorch Conference North America 2026 (San Jose, October 20-21) is packed with sessions on getting PyTorch to run fast, portably, and reliably across an increasingly diverse silicon landscape -...

## GSoC 2025: ClangIR upstreaming

DevFeed: [GSoC 2025: ClangIR upstreaming](<https://devfeed.tech/articles/gsoc-2025-clangir-upstreaming-43126.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-gsoc-clangir-upstreaming/>)

Author: Amr Hesham (amrdeveloper)

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

Content type: article

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [c/c++](<https://devfeed.tech/topics/c-c-plus-plus.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Exception handling](<https://devfeed.tech/topics/exception-handling.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clangir](<https://devfeed.tech/tags/clangir.md>), [code](<https://devfeed.tech/tags/code.md>), [exception-handling](<https://devfeed.tech/tags/exception-handling.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>)

### AI overview

A Google Summer of Code 2025 project report describes upstreaming ClangIR, a high-level C/C++ representation implemented with MLIR between Clang's AST and LLVM IR. The work covered design improvements, built-in vector operations, complex-number operations, and C++ exception handling.

### Source excerpt

Hello everyone 👋! My name is Amr Hesham, and for Google Summer of Code 2025, I've been working on the ClangIR Upstreaming project. My mentors were Bruno Cardoso Lopes, Andy Kaylor and Erich Keane. Background ClangIR is a high-level representation in Clang that reflects aspects of the C/C++ languages and their extensions. It is implemented using MLIR and occupies a position between Clang's AST and LLVM IR. Starting from April 2024, the upstreaming process started to migrate the code from the incubator to the main LLVM repository. The ClangIR upstreaming process includes the following steps: Improve the design of ClangIR dialect operations, attributes, syntax and implementation details if needed. Align with LLVM coding standards and quality expectations. Implement missing features in the incubator and upstream it. Backport the new design/implementation from the LLVM repository to the incubator. Implement folders for ClangIR dialect operations. The goal of this project was to implement the following C/C++ features in the ClangIR project. Built-in VectorType (vector_size and ext_vector_type attributes) with operators and built-ins functions. ComplexType with operators and all -complex-range flag values to allow selecting different arithmatic calculation algorithms, for example, the SMITH, R. L. Algorithm 116: Complex division. Commun. ACM 5, 8 (1962). C++ Exception handling. What we did Over the coding period, I did the following. Builtin VectorType I have implemented support for all C/C++ operators for built-in VectorType that includes arithmetic, comparison, shifts and logical operators, also supporting using VectorType in many expressions, for example, index and ternary expression, and now we can compile C++ code successfully. Also, implemented folders for ClangIR VectorType operations to fold specific patterns. For example, in cir::VecExtractOp, if both the vector and the index are constant, we can fold that operation and replace it with the actual result. // Before

## Integer Set Library (ISL) - A Primer

DevFeed: [Integer Set Library (ISL) - A Primer](<https://devfeed.tech/articles/integer-set-library-isl-a-primer-40491.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/2025/10/19/isl-a-primer/>)

Published: 2025-10-19T20:14:22Z

Content type: tutorial

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [Library](<https://devfeed.tech/topics/library.md>), [Optimization](<https://devfeed.tech/topics/optimization.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [mlir](<https://devfeed.tech/topics/mlir.md>)

Tags: [code](<https://devfeed.tech/tags/code.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [isl](<https://devfeed.tech/tags/isl.md>), [library](<https://devfeed.tech/tags/library.md>), [loops](<https://devfeed.tech/tags/loops.md>), [mathematics](<https://devfeed.tech/tags/mathematics.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [polyhedral-optimization](<https://devfeed.tech/tags/polyhedral-optimization.md>), [programming](<https://devfeed.tech/tags/programming.md>), [set-theory](<https://devfeed.tech/tags/set-theory.md>)

### AI overview

This primer introduces the Integer Set Library (ISL), an open-source C library that implements core algorithms for polyhedral optimization. It focuses on representing integer sets and relations, manipulating them, and the relationship between ISL and MLIR's Fast Presburger Library.

### Source excerpt

Polyhedral optimization is a tool used in compilers for optimizing loop nests. While the major compilers that use this implement polyhedral optimizations from scratch,1 there is a generally-applicable open source C library called the Integer Set Library (ISL) that implements the core algorithms used in polyhedral optimization. This article gives an overview of a subset of ISL, mainly focusing on the representation of sets and relations and basic manipulations on them.

## LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC

DevFeed: [LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC](<https://devfeed.tech/articles/llvmcgo25-carts-enabling-event-driven-task-and-data-block-compilation-for-distributed-hpc-43114.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-03-26-llvmcgo-carts/>)

Author: Rafael Andres Herrera Guaitero

Published: 2025-08-04T00:00:00Z

Content type: article

Language: en

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

Topics: [High-Performance Computing](<https://devfeed.tech/topics/high-performance-computing.md>), [toolchain](<https://devfeed.tech/topics/toolchain.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [distributed-systems](<https://devfeed.tech/topics/distributed-systems.md>), [event driven](<https://devfeed.tech/topics/event-driven.md>), [Concurrency](<https://devfeed.tech/topics/concurrency.md>), [data](<https://devfeed.tech/topics/data.md>), [Computing](<https://devfeed.tech/topics/computing.md>)

Tags: [arts](<https://devfeed.tech/tags/arts.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [computing](<https://devfeed.tech/tags/computing.md>), [concurrency](<https://devfeed.tech/tags/concurrency.md>), [data](<https://devfeed.tech/tags/data.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [event-driven](<https://devfeed.tech/tags/event-driven.md>), [hpc](<https://devfeed.tech/tags/hpc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [software](<https://devfeed.tech/tags/software.md>)

### AI overview

A conference blog post introduces CARTS, a compiler framework for optimizing applications in distributed high-performance computing environments. It describes how CARTS combines MLIR and LLVM and explains ARTS, an event-driven runtime based on independent tasks and data dependencies.

### Source excerpt

LLVMCGO25 - CARTS: Enabling Event-Driven Task and Data Block Compilation for Distributed HPC Hello everyone! I'm Rafael, a PhD candidate at the University of Delaware. I recently flew from Philadelphia to Las Vegas to attend the CGO conference,where I had the chance to present my project and soak in new ideas about HPC. In this blog, I'll dive into the project I discussed at the conference and share some personal insights and lessons I learned along the way.Although comments aren't enabled here, I'd love to hear from you, feel free to reach out at (rafaelhg at udel dot edu) if you're interested in collaborating, have questions, or just want to chat. Motivation: Why CARTS? Modern High-Performance Computing (HPC) and AI/ML workloads are pushing our hardware and software to the limits. Some key challenges include: Evolving Architectures: Systems now have complex memory hierarchies that need smart utilization. Hardware Heterogeneity: With multi-core CPUs, GPUs, and specialized accelerators in the mix, resource management gets tricky. Performance Pressure: Large-scale systems demand efficient handling of concurrency, synchronization, and communication. These challenges led to the creation of CARTS--a compiler framework that combines the flexibility of MLIR with the reliability of LLVM to optimize applications for distributed HPC environments. A Closer Look at ARTS and Its Inspirations At the heart of CARTS is ARTS. Originally, ARTS stood for the Abstract Runtime System.I often get mixed up and mistakenly call it the Asynchronous Runtime System. To keep things light,we sometimes joke about it being the Any Runtime System. ARTS is inspired by the Codelet model, a concept I could talk about all day!The Codelet model breaks a computation into small, independent tasks (or "codelets") that can run as soon as their data dependencies are met.If you're curious to learn more about this model (or find it delightfully abstract), I suggest you visit our research group websiteat CAPSL,

## LLVM Fortran Levels Up: Goodbye flang-new, Hello flang!

DevFeed: [LLVM Fortran Levels Up: Goodbye flang-new, Hello flang!](<https://devfeed.tech/articles/llvm-fortran-levels-up-goodbye-flang-new-hello-flang-43113.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2025-03-11-flang-new/>)

Author: David Spickett

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

Content type: article

Language: en

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

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

Tags: [assembly](<https://devfeed.tech/tags/assembly.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compilers](<https://devfeed.tech/tags/compilers.md>), [computing](<https://devfeed.tech/tags/computing.md>), [flang](<https://devfeed.tech/tags/flang.md>), [high-performance-computing](<https://devfeed.tech/tags/high-performance-computing.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [open-source](<https://devfeed.tech/tags/open-source.md>)

### AI overview

This article describes Flang, LLVM's Fortran compiler, including its transition from flang-new to flang in LLVM 20. It reviews the compiler's development, adoption of MLIR, history, and role in high-performance and scientific computing.

### Source excerpt

LLVM has included a Fortran compiler "Flang" since LLVM 11 in late 2020. However,until recently the Flang binary was not flang (like clang) but insteadflang-new. LLVM 20 ends the era of flang-new. The community has decided that Flang isworthy of a new name. The "new" name? You guessed it, flang. A simple change that represents a major milestone for Flang. This article will cover the almost 10 year journey of Flang. The firstconcepts, multiple rewrites, the adoption of LLVM's Multi Level IntermediateRepresentation (MLIR) and Flang entering the LLVM Project. If you want to try flang right now, you candownloadit or try it in your browser usingCompiler Explorer. Why Fortran? Fortran was first created in the 1950s, and the name came from "Formula Translation".Fortran focused on the mathematics use case and freed programmers from writingassembly code that could only run on specific machines. Instead they could write code that looked like a formula. You expect this todaybut for the time it was a revolution. This feature led to heavy use in scientificcomputing: weather modelling, fluid dynamics and computational chemistry, justto name a few. Whilst many alternative programming languages have comeand gone, it [Fortran] has regained its popularity for writing highperformance codes. Indeed, over 80% of the applicationsrunning on ARCHER2, a 750,000 core Cray EX which isthe UK national supercomputer, are written in Fortran. Fortran High-Level Synthesis: Reducing the barriersto accelerating High Performance Computing (HPC) codes on FPGAs (Gabriel Rodriguez-Canal et al., 2023) Fortran has had a resurgencein recent years, gaining a package manager, an unofficialstandard library and LFortran,a compiler that supports interactive programming (LFortran also uses LLVM). For the full history of Fortran, IBM has an excellent articleon the topic and I encourage you to look at the"Programmer's Primer for Fortran"if you want to see the early form of Fortran. If you want to learn the language

## Lightstorm: minimalistic Ruby compiler

DevFeed: [Lightstorm: minimalistic Ruby compiler](<https://devfeed.tech/articles/lightstorm-minimalistic-ruby-compiler-43111.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2024-12-03-minimalistic-ruby-compiler/>)

Author: Alex Denisov, Amir Rajan

Published: 2024-12-09T00: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>), [Ruby](<https://devfeed.tech/topics/ruby.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [Code generation](<https://devfeed.tech/topics/code-generation.md>), [C](<https://devfeed.tech/topics/c.md>), [cross-platform](<https://devfeed.tech/topics/cross-platform.md>), [mruby](<https://devfeed.tech/topics/mruby.md>), [Game Development](<https://devfeed.tech/topics/game-development.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [codegen](<https://devfeed.tech/tags/codegen.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cross-platform](<https://devfeed.tech/tags/cross-platform.md>), [dragonruby](<https://devfeed.tech/tags/dragonruby.md>), [game-development](<https://devfeed.tech/tags/game-development.md>), [interpreter](<https://devfeed.tech/tags/interpreter.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [ruby](<https://devfeed.tech/tags/ruby.md>)

### AI overview

This article describes Lightstorm, a minimalistic ahead-of-time Ruby compiler. It explains how the project uses MLIR and EmitC to translate Ruby VM bytecode into C, with the goal of simplifying cross-platform support and evaluating whether precompiled Ruby code can improve performance in an indie-focused game engine.

### Source excerpt

Some time ago I was talking about an ahead-of-time Ruby compiler.We started the project with certain goals and hypotheses in mind, and while the original compiler is at nearly 90% completion, there are still those other 90% that needs to be done. In the meantime, we decided to strip it down to a bare minimum and implement just enough features to validate the hypotheses. Just like the original compiler we use MLIR to bridge the gap between Ruby VM's bytecode and the codegen, but instead of targeting LLVM IR directly, we go through EmitC dialect and targeting C language, as it significantly simplifies OS/CPU support. We go into a bit more details later. The source code of our minimalistic Ruby compiler is here: https://github.com/dragonruby/lightstorm. The rest of the article covers why we decided to build it, how we approached the problem, and what we discovered along the way. Motivation and the use case Our use case is pretty straightforward: we are building a cross-platform game engine that's indie-focused, productive, and easy to use. The game engine itself is written in a mix of C and Ruby, but the main user-interface is the Ruby itself. As soon as the game development is done and the game is ready for "deployment," the code is more or less static and so we asked ourselves if we can pre-compile it into machine code to make it run faster. But given all the dynamism of Ruby, why would a compilation make it faster? So here comes our hypothesis. But first let's look at some high-level implementation details to see where the hypothesis comes from. Compilers vs Interpreters While a language itself cannot be strictly qualified as compiled or interpreted, the typical implementations certainly are. In case of a "compiled" language the compiler would take the whole program, analyze it and produce the machine code targeting a specific hardware (real or virtual), while an interpreter would take the program and execute it right away, one "instruction" at a time. The definitio

## GSoC 2024: ABI Lowering in ClangIR

DevFeed: [GSoC 2024: ABI Lowering in ClangIR](<https://devfeed.tech/articles/gsoc-2024-abi-lowering-in-clangir-43108.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2024-09-07-abi-lowering-in-clangir/>)

Author: Vinicius Espindola

Published: 2024-09-30T00: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>), [mlir](<https://devfeed.tech/topics/mlir.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [Code](<https://devfeed.tech/topics/code.md>), [software-development](<https://devfeed.tech/topics/software-development.md>)

Tags: [architecture](<https://devfeed.tech/tags/architecture.md>), [architectures](<https://devfeed.tech/tags/architectures.md>), [ast](<https://devfeed.tech/tags/ast.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [build](<https://devfeed.tech/tags/build.md>), [c](<https://devfeed.tech/tags/c.md>), [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clangir](<https://devfeed.tech/tags/clangir.md>), [code](<https://devfeed.tech/tags/code.md>), [code-generation](<https://devfeed.tech/tags/code-generation.md>), [codegen](<https://devfeed.tech/tags/codegen.md>), [compile](<https://devfeed.tech/tags/compile.md>), [contribution](<https://devfeed.tech/tags/contribution.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [principles](<https://devfeed.tech/tags/principles.md>), [structs](<https://devfeed.tech/tags/structs.md>), [x86-64](<https://devfeed.tech/tags/x86-64.md>)

### AI overview

This article describes a Google Summer of Code project extending ClangIR with target-specific ABI and calling-convention lowering for X86-64 and additional architectures. It covers a modular TargetLowering library, lowering passes, feature guarding, and integration into the main pipeline.

### Source excerpt

ClangIR is an ongoing effort to build a high-level intermediate representation(IR) for C/C++ within the LLVM ecosystem. Its key advantage lies in its abilityto retain more source code information. While ClangIR is making progress, itstill lacks certain features, notably ABI handling. Currently, ClangIR lowersmost functions without accounting for ABI-specific calling convention details. Goals The "Build & Run SingleSource Benchmarks with ClangIR - Part 2" Google Summer ofCode 2024 builds on my contributions from GSoC 2023 by addressing one of themain issues I encountered: target-specific lowering. It focuses on extendingClangIR's code generation capabilities, particularly in ABI-lowering for X86-64.Several tests rely on operations and types (e.g., va_arg calls and complexdata types) that require target-specific information to compile correctly. The concrete steps to achieve this were: Implement foundational infrastructure that can scale to multiplearchitectures while adhering to ClangIR design principles such as CodeGenparity, feature guarding, and AST backreferences. Handle basic calling convention scenarios as a proof of concept tovalidate the foundational infrastructure. Add lowering for a second architecture to further validate theinfrastructure's extensibility to multiple architectures. Unify target-specific ClangIR lowering into the library, as there are afew isolated methods handling target-specific code lowering likecir.va_arg. Integrate calling convention lowering into the main pipeline to ensurefuture contributions and continued development of this infrastructure. Contributions The list of contribution (PRs) can be foundhere. Target Lowering Library The most significant contribution of this project was the development of amodular TargetLowering library.This ensures that target-specific MLIR lowering passes can leverage this sharedlibrary for lowering logic. The library also follows ClangIR's feature guardingprinciples, ensuring that any contributor can refe

## GSoC 2024: Compile GPU kernels using ClangIR

DevFeed: [GSoC 2024: Compile GPU kernels using ClangIR](<https://devfeed.tech/articles/gsoc-2024-compile-gpu-kernels-using-clangir-43103.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2024-08-29-gsoc-opencl-c-support-for-clangir/>)

Author: Zhi Ma (7mile)

Published: 2024-09-09T00: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>), [GPU](<https://devfeed.tech/topics/gpu.md>), [OpenCL](<https://devfeed.tech/topics/opencl.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [Programming](<https://devfeed.tech/topics/programming.md>), [Code](<https://devfeed.tech/topics/code.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [Kernel](<https://devfeed.tech/topics/kernel.md>), [kernels](<https://devfeed.tech/topics/kernels.md>)

Tags: [c](<https://devfeed.tech/tags/c.md>), [clang](<https://devfeed.tech/tags/clang.md>), [clangir](<https://devfeed.tech/tags/clangir.md>), [compilation](<https://devfeed.tech/tags/compilation.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [cuda](<https://devfeed.tech/tags/cuda.md>), [design](<https://devfeed.tech/tags/design.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [gsoc](<https://devfeed.tech/tags/gsoc.md>), [hooks](<https://devfeed.tech/tags/hooks.md>), [kernels](<https://devfeed.tech/tags/kernels.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [llvm-ir](<https://devfeed.tech/tags/llvm-ir.md>), [opencl](<https://devfeed.tech/tags/opencl.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [programming](<https://devfeed.tech/tags/programming.md>)

### AI overview

A GSoC project report describes adding OpenCL C support to ClangIR, an MLIR-based intermediate representation for Clang. The work targets compilation of GPU kernels to LLVM IR for SPIR-V and covers address spaces, OpenCL and SPIR-V integration, vector types, metadata, qualified variables, and calling conventions.

### Source excerpt

Hello everyone! I'm 7mile. My GSoC project this summer is Compile GPU kernels using ClangIR. It's been an exciting journey in compiler development, and I'm thrilled to share the progress and insights gained along the way here. Background The ClangIR project aims to establish a new IR for Clang, built on top of MLIR. As part of the ongoing effort to support heterogeneous programming models, this project focuses on integrating OpenCL C language support into ClangIR. The ultimate goal is to enable the compilation of GPU kernels written in OpenCL C into LLVM IR targeting the SPIR-V architecture, laying the groundwork for future enhancements in SYCL and CUDA support. What We Did Our work involved several key areas: Address Space Support: One of the fundamental tasks was teaching ClangIR to handle address spaces, a vital feature for languages like OpenCL. Initially, we considered mimicking LLVM's approach, but this proved inadequate for ClangIR's goals. After thorough discussion and an RFC, we implemented a unified address space design that aligns with ClangIR's objectives, ensuring a clean and maintainable code structure. OpenCL Language and SPIR-V Target Integration: We extended ClangIR to support the OpenCL language and the SPIR-V target. This involved enhancing the pipeline to accommodate the latest OpenCL 3.0 specification and implementing hooks for language-specific and target-specific customizations. Vector Type Support: OpenCL vector types, a critical feature for GPU programming, were integrated into ClangIR. We leveraged ClangIR's existing cir.vector type to generate the necessary code, ensuring consistent compilation results. Kernel and Module Metadata Emission: We added support for emitting OpenCL kernel and module metadata in ClangIR, a necessary step for proper integration with the SPIR-V target. This included the creation of structured attributes to represent metadata, following MLIR's preferences for well-defined structures. Global and Static Variables with

## Polynomial dialect and mlir-opt tutorial upstreamed

DevFeed: [Polynomial dialect and mlir-opt tutorial upstreamed](<https://devfeed.tech/articles/polynomial-dialect-and-mlir-opt-tutorial-upstreamed-40507.md>)

Original publisher: [Read original article](<https://www.jeremykun.com/shortform/2024-08-02-1551/>)

Published: 2024-08-02T22:51:23Z

Content type: article

Language: en

Sources: [Jeremy Kun](<https://devfeed.tech/sources/jeremy-kun.md>)

Topics: [mlir](<https://devfeed.tech/topics/mlir.md>), [Tutorial](<https://devfeed.tech/topics/tutorial.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [debugging](<https://devfeed.tech/topics/debugging.md>), [Algorithms](<https://devfeed.tech/topics/algorithms.md>), [Mathematics](<https://devfeed.tech/topics/mathematics.md>), [LLVM](<https://devfeed.tech/topics/llvm.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [debugging](<https://devfeed.tech/tags/debugging.md>), [llvm](<https://devfeed.tech/tags/llvm.md>), [math](<https://devfeed.tech/tags/math.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [shortform](<https://devfeed.tech/tags/shortform.md>), [tutorial](<https://devfeed.tech/tags/tutorial.md>)

### AI overview

The author describes upstreaming compiler work to MLIR, including a tutorial on mlir-opt for debugging MLIR pass pipelines and the beginning of a polynomial math dialect. They also discuss planned polynomial approximation passes that would track approximation error in the IR.

### Source excerpt

I've been upstreaming a bit of my compiler work to the MLIR project. Yesterday, I merged in a tutorial on mlir-opt, the main debugging tool for running passes on MLIR code. This is roughly the upstreamable parts of my first MLIR tutorial entry, MLIR -- Running and Testing a Lowering. Mehdi Amini also provided a lot of useful information during review that taught me some stuff I didn't know about the tool.

## Elixir and Machine Learning in 2024 so far: MLIR, Apache Arrow, structured LLM, and more

DevFeed: [Elixir and Machine Learning in 2024 so far: MLIR, Apache Arrow, structured LLM, and more](<https://devfeed.tech/articles/elixir-and-machine-learning-in-2024-so-far-mlir-apache-arrow-structured-llm-and-more-43998.md>)

Original publisher: [Read original article](<https://dashbit.co/blog/elixir-ml-s1-2024-mlir-arrow-instructor>)

Author: José Valim

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

Content type: article

Language: en

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

Topics: [Elixir](<https://devfeed.tech/topics/elixir.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>), [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [apache-arrow](<https://devfeed.tech/topics/apache-arrow.md>), [data-engineering](<https://devfeed.tech/topics/data-engineering.md>), [data](<https://devfeed.tech/topics/data.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [clustering](<https://devfeed.tech/topics/clustering.md>)

Tags: [algorithms](<https://devfeed.tech/tags/algorithms.md>), [apache-arrow](<https://devfeed.tech/tags/apache-arrow.md>), [clustering](<https://devfeed.tech/tags/clustering.md>), [cross-compilation](<https://devfeed.tech/tags/cross-compilation.md>), [data](<https://devfeed.tech/tags/data.md>), [data-and-machine-learning](<https://devfeed.tech/tags/data-and-machine-learning.md>), [elixir](<https://devfeed.tech/tags/elixir.md>), [embedded-devices](<https://devfeed.tech/tags/embedded-devices.md>), [explorer](<https://devfeed.tech/tags/explorer.md>), [json](<https://devfeed.tech/tags/json.md>), [livebook](<https://devfeed.tech/tags/livebook.md>), [llm](<https://devfeed.tech/tags/llm.md>), [machine-learning](<https://devfeed.tech/tags/machine-learning.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [nx](<https://devfeed.tech/tags/nx.md>), [quantization](<https://devfeed.tech/tags/quantization.md>), [s3](<https://devfeed.tech/tags/s3.md>), [scholar](<https://devfeed.tech/tags/scholar.md>), [storage](<https://devfeed.tech/tags/storage.md>)

### AI overview

An update on Elixir and machine learning projects, covering MLIR support in Nx, Arrow-compatible types and S3 streaming in Explorer, traditional machine learning features in Scholar, and structured LLM work.

### Source excerpt

An update on the latest advancements of Elixir, data, and Machine Learning.

## LLVM Google Summer of Code 2024 & 2023

DevFeed: [LLVM Google Summer of Code 2024 & 2023](<https://devfeed.tech/articles/llvm-google-summer-of-code-2024-2023-43100.md>)

Original publisher: [Read original article](<https://blog.llvm.org/posts/2024-02-26-gsoc/>)

Author: Anton Korobeynikov

Published: 2024-03-14T00:00:00Z

Content type: article

Language: en

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

Topics: [LLVM](<https://devfeed.tech/topics/llvm.md>), [Compiler](<https://devfeed.tech/topics/compiler.md>), [software-development](<https://devfeed.tech/topics/software-development.md>), [clang](<https://devfeed.tech/topics/clang.md>), [mlir](<https://devfeed.tech/topics/mlir.md>), [Google](<https://devfeed.tech/topics/google.md>), [C++](<https://devfeed.tech/topics/c-plus-plus.md>), [WebAssembly](<https://devfeed.tech/topics/web-assembly.md>)

Tags: [c-plus-plus](<https://devfeed.tech/tags/c-plus-plus.md>), [clang](<https://devfeed.tech/tags/clang.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compiler-optimization](<https://devfeed.tech/tags/compiler-optimization.md>), [contributing](<https://devfeed.tech/tags/contributing.md>), [data](<https://devfeed.tech/tags/data.md>), [development](<https://devfeed.tech/tags/development.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>), [llvm](<https://devfeed.tech/tags/llvm.md>), [mlir](<https://devfeed.tech/tags/mlir.md>), [webassembly](<https://devfeed.tech/tags/webassembly.md>)

### AI overview

LLVM describes its participation in Google Summer of Code 2024 and reviews 20 projects completed during the 2023 program across LLVM and its subprojects.

### Source excerpt

The LLVM organization was accepted to participate in Google Summer of Code in 2024. Soon, prospective participants will begin submitting their project proposals, and mentors will review them to select those who will spend a significant amount of time this year contributing to various parts of LLVM. But first, let's look back and see what we had in 2023. The Google Summer of Code 2023 was very successful for the LLVM project. Overall, we received 54 proposals for 24 open projects. Out of this set of proposals, 20 projects were successfully completed and covered many different aspects of LLVM and its subprojects. ExtractAPI while building by Ankur Saini, mentored by Daniel Grumberg WebAssembly Support for clang-repl by Anubhab Ghosh, mentored by Vassil Vassilev and Alexander Penev Modules Build Daemon: Build System Agnostic Support for Explicitly Built Modules by Connor Sughrue, mentored by Jan Svoboda, Michael Spencer [Interactive MLIR query tool to make exploring the IR easier] (https://summerofcode.withgoogle.com/archive/2023/projects/bdePp9VD) by Devajith Valaparambil Sreeramaswamy, mentored by Jacques Pienaar Improving Compile Times by Dhruv Chawla, mentored by Nikita Popov Adding C++ Support to Clang's ExtractAPI by Erick Velez, mentored by Daniel Grumberg Optimizing MLIR's Presburger library by gilsaia, mentored by Kunwar Grover Adapting IR Load Semantics to Freeze All or Freeze Only Uninitialized Data by John McIver, mentored by Nuno Lopes Addressing Rust optimization failures in LLVM by Kohei Asano, mentored by Nikita Popov Tutorial development with clang-repl by Krishna Narayanan, mentored by Vassil Vassilev Fix Handling of Undefined Behavior in NewGVN by Manuel Brito, mentored by Nuno Lopes Map LLVM values to corresponding source-level expressions by phyBrackets, mentored by Satish Guggilla and Karthik Senthil Machine Learning Guided Ordering of Compiler Optimization Passes by Puneeth A R, mentored by Tarindu Jayatilaka, Johannes Doerfert, and Mircea Trofin

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