Tootfinder

QTurbo: A Robust and Efficient Compiler for Analog Quantum Simulation
Junyu Zhou, Yuhao Liu, Shize Che, Anupam Mitra, Efekan K\"okc\"u, Ermal Rrapaj, Costin Iancu, Gushu Li
https://arxiv.org/abs/2506.22958

QTurbo: A Robust and Efficient Compiler for Analog Quantum Simulation
Analog quantum simulation leverages native hardware dynamics to emulate complex quantum systems with great efficiency by bypassing the quantum circuit abstraction. However, conventional compilation methods for analog simulators are typically labor-intensive, prone to errors, and computationally demanding. This paper introduces QTurbo, a powerful analog quantum simulation compiler designed to significantly enhance compilation efficiency and optimize hardware execution time. By generating precise…

Compiling a Q# Subset to QASM 3.0 in TypeScript via a JSON Based IR
Marcus Edwards
https://arxiv.org/abs/2506.23407 https://arxiv.org…

Compiling a Q# Subset to QASM 3.0 in TypeScript via a JSON Based IR
We implement a compile toolchain from Q# to QASM 3.0 including a full-featured lexer and parser implementation, as well as a compiler that supports a subset of Q# features. The lexer, parser and compiler are shown to work with various input Q# programs and the implementation is compared against existing Q# compile tools. Unlike the Microsoft implementation of the official Q# compile toolchain, our implementation is written in TypeScript in order to port functionality to web environments.

from my link log —
The Manchester Compiler Compiler and CPL: reflections of a user 50 years on.
https://curation.cs.manchester.ac.uk/atlas/docs/CC_Reflections-v4 final.pdf
saved 2024-11-06

TPDE: A Fast Adaptable Compiler Back-End Framework
Tobias Schwarz (Technical University of Munich), Tobias Kamm (Technical University of Munich), Alexis Engelke (Technical University of Munich)
https://arxiv.org/abs/2505.22610

TPDE: A Fast Adaptable Compiler Back-End Framework
Fast machine code generation is especially important for fast start-up just-in-time compilation, where the compilation time is part of the end-to-end latency. However, widely used compiler frameworks like LLVM do not prioritize fast compilation and require an extra IR translation step increasing latency even further; and rolling a custom code generator is a substantial engineering effort, especially when targeting multiple architectures. Therefore, in this paper, we present TPDE, a compiler b…

I tried to explain what a compiler is to the 8yo, and her takeaway is: "a compiler is a thing that translates to Baby Language."

"William Zani, one of the core programmers of the first BASIC compiler, tells the story of the demo of the DTSS system at the San Francisco AFIPS 1964 conference (minute 26:17), sending a BASIC program to from San Francisco to Hanover, New Hampshire over a telephone line, live in front of an audience, who (I quote) “went bananas”."

Dartmouth College
In August 2014, Dartmouth College published a video commemorating the 50th anniversary of the BASIC programming language, the subject of this month's Vidéothèque section. It features original footage from the 1960s and interviews of former students and team members, including Professor Thomas Kurtz, who was 85 years old at the time. But the heart and soul of the video is, without any doubt, Professor John Kemeny himself; not only his technical contributions, which were outstanding by every st…

I think this is a great summary of “vibe coding.” 🫠 (The whole thread is worth a read.) /cc @…
https://mastodon.social/@jcoglan/114752172786629305…

Improving Compiler Bug Isolation by Leveraging Large Language Models
Yixian Qi, Jiajun Jiang, Fengjie Li, Bowen Chen, Hongyu Zhang, Junjie Chen
https://arxiv.org/abs/2506.17647

Improving Compiler Bug Isolation by Leveraging Large Language Models
Compilers play a foundational role in building reliable software systems, and bugs within them can lead to catastrophic consequences. The compilation process typically involves hundreds of files, making traditional automated bug isolation techniques inapplicable due to scalability or effectiveness issues. Current mainstream compiler bug localization techniques have limitations in test program mutation and resource consumption. Inspired by the recent advances of pre-trained Large Language Models…

A very simple code to describe emotions or how does this work in real life?!?? ;)
```rust
#[allow(warnings)]
fn main() {
let mut emo: &str;
match 1 1 == 0b10 {
true => emo = "🤓",
_ => emo = "😵‍💫",
};
println!("Perception: {}", emo);
}
```
Play 🦀:

crikey, on compiler explorer you can hash include a url https://github.com/compiler-explorer/compiler-explorer/issues/1442

How do you include files from urls? · Issue #1442 · compiler-explorer/compiler-explorer
I have seen some talk where compiler explorer accepts includes from URL. For example #include "https://...." Is there an option to allow this and make it work?

LEGO-Compiler: Enhancing Neural Compilation Through Translation Composability
Shuoming Zhang, Jiacheng Zhao, Chunwei Xia, Zheng Wang, Yunji Chen, Xiaobing Feng, Huimin Cui
https://arxiv.org/abs/2505.20356

LEGO-Compiler: Enhancing Neural Compilation Through Translation Composability
Large language models (LLMs) have the potential to revolutionize how we design and implement compilers and code translation tools. However, existing LLMs struggle to handle long and complex programs. We introduce LEGO-Compiler, a novel neural compilation system that leverages LLMs to translate high-level languages into assembly code. Our approach centers on three key innovations: LEGO translation, which decomposes the input program into manageable blocks; breaking down the complex compilation p…

This https://arxiv.org/abs/2409.04668 has been replaced.
initial toot: https://mastoxiv.page/@ar…

Performance Portable Monte Carlo Neutron Transport in MCDC via Numba
Finding a software engineering approach that allows for portability, rapid development, and open collaboration for high-performance computing on GPUs and CPUs is a challenge. We implement a portability scheme using the Numba compiler for Python in Monte Carlo / Dynamic Code (MC/DC), a new neutron transport application for rapidly developing Monte Carlo. Using this scheme, we have built MC/DC as an application that can run as a pure Python, compiled CPU, or compiled GPU solver. In GPU mode, we u…

How can you check if a version of #Emacs was compiler with native-compilation on?

Me: "I need to an older compiler, because there is a bug in the latest version."
Microsoft: 🖕

Evaluating Disassembly Errors With Only Binaries
Lambang Akbar Wijayadi, Yuancheng Jiang, Roland H. C. Yap, Zhenkai Liang, Zhuohao Liu
https://arxiv.org/abs/2506.20109

Evaluating Disassembly Errors With Only Binaries
Disassemblers are crucial in the analysis and modification of binaries. Existing works showing disassembler errors largely rely on practical implementation without specific guarantees and assume source code and compiler toolchains to evaluate ground truth. However, the assumption of source code is contrary to typical binary scenarios where only the binary is available. In this work, we investigate an approach with minimal assumptions and a sound approach to disassembly error evaluation that doe…

HetGPU: The pursuit of making binary compatibility towards GPUs
Yiwei Yang, Yusheng Zheng, Tong Yu, Andi Quinn
https://arxiv.org/abs/2506.15993 https://

HetGPU: The pursuit of making binary compatibility towards GPUs
Heterogeneous GPU infrastructures present a binary compatibility challenge: code compiled for one vendor's GPU will not run on another due to divergent instruction sets, execution models, and driver stacks . We propose hetGPU, a new system comprising a compiler, runtime, and abstraction layer that together enable a single GPU binary to execute on NVIDIA, AMD, Intel, and Tenstorrent hardware. The hetGPU compiler emits an architecture-agnostic GPU intermediate representation (IR) and inserts meta…

Dataset of Yul Contracts to Support Solidity Compiler Research
Krzysztof Fonal
https://arxiv.org/abs/2506.19153 https://arxiv.org/pdf…

Dataset of Yul Contracts to Support Solidity Compiler Research
The YulCode dataset presents a comprehensive collection of 348,840 Yul-based smart contract instances, comprising approximately 135,013 unique contracts. These contracts were generated through the compilation of Solidity source files that have been deployed on the Ethereum mainnet, making the dataset directly representative of real-world decentralized applications. YulCode provides a rich foundation for a variety of research and development tasks, including but not limited to machine learning a…

A System Level Compiler for Massively-Parallel, Spatial, Dataflow Architectures
Dirk Van Essendelft, Patrick Wingo, Terry Jordan, Ryan Smith, Wissam Saidi
https://arxiv.org/abs/2506.15875

A System Level Compiler for Massively-Parallel, Spatial, Dataflow Architectures
We have developed a novel compiler called the Multiple-Architecture Compiler for Advanced Computing Hardware (MACH) designed specifically for massively-parallel, spatial, dataflow architectures like the Wafer Scale Engine. Additionally, MACH can execute code on traditional unified-memory devices. MACH addresses the complexities in compiling for spatial architectures through a conceptual Virtual Machine, a flexible domain-specific language, and a compiler that can lower high-level languages to m…

That's Not the Feedback I Need! -- Student Engagement with GenAI Feedback in the Tutor Kai
Sven Jacobs, Maurice Kempf, Natalie Kiesler
https://arxiv.org/abs/2506.20433

That's Not the Feedback I Need! -- Student Engagement with GenAI Feedback in the Tutor Kai
The potential of Generative AI (GenAI) for generating feedback in computing education has been the subject of numerous studies. However, there is still limited research on how computing students engage with this feedback and to what extent it supports their problem-solving. For this reason, we built a custom web application providing students with Python programming tasks, a code editor, GenAI feedback, and compiler feedback. Via a think-aloud protocol including eye-tracking and a post-intervie…

from my link log —
awe: A compiler for the Algol W programming language.
https://github.com/glynawe/awe
saved 2025-04-12 https://do…

GitHub - glynawe/awe: A compiler for the Algol W programming language.
A compiler for the Algol W programming language. Contribute to glynawe/awe development by creating an account on GitHub.

I get mixed feelings when I can create a small reproduction project for an issue caused by a single version bump in a third party dependency. It's nice to know it's not my code, but a fix-release is also out of my control
Today's problem; The compiler in #Kotlin 2.1.20. I've even managed to boil it down to a 1 line change where "2.1.10" works, and "2.1.20" o…

This https://arxiv.org/abs/2504.19442 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csDC_…

Triton-distributed: Programming Overlapping Kernels on Distributed AI Systems with the Triton Compiler
In this report, we propose Triton-distributed, an extension of existing Triton compiler, to overcome the programming challenges in distributed AI systems. Triton-distributed is the first compiler that supports native overlapping optimizations for distributed AI workloads, providing a good coverage of existing optimizations from different frameworks. First, we integrate communication primitives compliant with the OpenSHMEM standard into the compiler. This enables programmers to utilize these pri…

I'm currently bisecting isc-dhcpd to figure out where the javastation boot breaks; it's hideous - the versions I'm on use manually coded configure scripts with switches on Linux major version (2 being largest) and have headers that need extern's scattering in for a modern compiler for some reason.
(Current status, 2.0.5 works, 3.1.3 fails)

from my link log —
Representing type lattices compactly.
https://bernsteinbear.com/blog/lattice-bitset/
saved 2025-03-12 https://…

Adaptive random compiler for Hamiltonian simulation
Yun-Zhuo Fan, Yu-Xia Wu, Dan-Bo Zhang
https://arxiv.org/abs/2506.15466 https://ar…

Adaptive random compiler for Hamiltonian simulation
Randomized compilation protocols have recently attracted attention as alternatives to traditional deterministic Trotter-Suzuki methods, potentially reducing circuit depth and resource overhead. These protocols determine gate application probabilities based on the strengths of Hamiltonian terms, as measured by the trace norm. However, relying solely on the trace norm to define sampling distributions may not be optimal, especially for continuous-variable and hybrid-variable systems involving unbo…

@… Oh, I totally get this. We had the same problem at my last job. Until we get a new GHC with a server-client architecture, I’m not holding my breath on a fix. (I hope to replace Cabal one day, but I’m not going to go and make a Haskell compiler. MicroHs is cool though.)
Maybe I met your coworkers! I didn’t go to any workshops because I’m lazy, I ju…

Every few years I go and dig out a 65-line C program that I wrote as a grad student and try to gently poke it through a compiler but I finally got tired of that and replaced it with a 10-line awk script.
Wow, take a look at this jalopy! Written ca. 1977 (with ed(1), the standard editor) on a PDP-11/45 running V7, prob'ly on an ADM-3A "glass terminal" in the terminal room on the second floor of the E-Quad.

Rust's Stable MIR project is being slept on. It's pitched as a tool for formal verification, but it's more general than that. Once stabilized, it will almost be a stable compiler plugin API!
It doesn't just include what you get from `--emit=mir` (IR for each function), but also has full type and trait information, and will likely even support interactive queries like "does type implement trait”.
In short, it'll be perfect for metaprogramming!
[1/2]…

This https://arxiv.org/abs/2406.06095 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csMS_…

An extension of C++ with memory-centric specifications for HPC to reduce memory footprints and streamline MPI development
The C++ programming language and its cousins lean towards a memory-inefficient storage of structs: The compiler inserts helper bits such that individual instance variables fit to byte or cache boundaries, while it is not able to exploit knowledge about the range of integers, enums or bitsets. Furthermore, the language provides neither support for data exchange via MPI nor for arbitrary floating-point precisions. We propose C++ attributes through which developers can guide the compiler what memo…

"[…] Let's take a look at 6 improvements to look forward to in the upcoming #GCC 15.
1. Prettier execution paths
2. A new look for C template errors
3. Machine-readable diagnostics
4. An easier transition to C23
5. A revamped color scheme
6. libgdiagnostics
We're still fixing bugs, but we hope that GCC 15 will be ready to officially release (as …

HPCTransCompile: An AI Compiler Generated Dataset for High-Performance CUDA Transpilation and LLM Preliminary Exploration
Jiaqi Lv, Xufeng He, Yanchen Liu, Xu Dai, Yang Hu, Shouyi Yin
https://arxiv.org/abs/2506.10401

HPCTransCompile: An AI Compiler Generated Dataset for High-Performance CUDA Transpilation and LLM Preliminary Exploration
The rapid growth of deep learning has driven exponential increases in model parameters and computational demands. NVIDIA GPUs and their CUDA-based software ecosystem provide robust support for parallel computing, significantly alleviating computational bottlenecks. Meanwhile, due to the cultivation of user programming habits and the high performance of GPUs, the CUDA ecosystem has established a dominant position in the field of parallel software. This dominance requires other hardware platforms…

»This is an awful language. Don't program in INTERCAL«
@… is talking about his work on bringing the original INTERCAL72 compiler from 1973 back to life again. Podcast recommendation, enjoy:

Advent of Computing
Welcome to Advent of Computing, the show that talks about the shocking, intriguing, and all too often relevant history of computing. A lot of little things we take for granted today have rich stories behind their creation, in each episode we will learn how older tech has lead to our modern world.

Ok, more C fun today. I'm getting -fsanitize=undefined working and am hitting the wall when trying to get the language to support arithmetic right shift operations. There doesn't appear to be a simple way to get the compiler to emit this instruction except by exercising implementation-defined behavior of the right-shift operator on signed integer types.
I ask again what kind of systems language is C supposed to be if it can't express a universal operation of this nature?…

CompilerGPT: Leveraging Large Language Models for Analyzing and Acting on Compiler Optimization Reports
Peter Pirkelbauer
https://arxiv.org/abs/2506.06227 …

CompilerGPT: Leveraging Large Language Models for Analyzing and Acting on Compiler Optimization Reports
Current compiler optimization reports often present complex, technical information that is difficult for programmers to interpret and act upon effectively. This paper assesses the capability of large language models (LLM) to understand compiler optimization reports and automatically rewrite the code accordingly. To this end, the paper introduces CompilerGPT, a novel framework that automates the interaction between compilers, LLMs, and user defined test and evaluation harness. CompilerGPT's wo…

from my link log —
When should a Java JIT compiler expand garbage collection barriers?
https://robcasloz.github.io/blog/2024/02/14/when-should-a-compiler-expand-garbage-collection-barriers.html
saved…

Solsmith: Solidity Random Program Generator for Compiler Testing
Lantian Li, Zhihao Liu, Zhongxing Yu
https://arxiv.org/abs/2506.03909 https://

Solsmith: Solidity Random Program Generator for Compiler Testing
Smart contracts are computer programs that run on blockchain platforms, with Solidity being the most widely used language for their development. As blockchain technology advances, smart contracts have become increasingly important across various fields. In order for smart contracts to operate correctly, the correctness of the compiler is particularly crucial. Although some research efforts have been devoted to testing Solidity compilers, they primarily focus on testing methods and do not addres…

"We cannot preclude developers from “vibe coding” their way into a working application; but we can teach them how to properly integrate the very likely spaghetti mess produced by those bullshit machines, how to understand it, and how to make it work with today’s compilers, which, let us be honest: are the best we have ever had, and it would be a shame to ignore them completely."

The Allure Of Vibe Coding
"Compiler Explorer" is the name of a fascinating project by Matt Godbolt, a British C++ software developer living in Chicago. It is the simplest and most wonderful thing; just paste a snippet of code on the left pane (in C, C++, D, C#, Java, Python, and a myriad more languages), and you will see on the right its equivalent in assembly code, as produced by one of a long list of compilers, including some commercial ones, for a wide variety of CPU architectures and software versions.

I am once again asking GHC devs to make it possible for tooling such as HLint and the Haskell Language Server to compile against multiple versions of GHC.
I realise that this is a gigantic undertaking, but if you're wondering why people don't stick with Haskell, it might be because every compiler version upgrade breaks *everything*.

Wspaniały dzisiejszy #Python: #Gentoo uruchamia testy w paczkach związanych z #ProtoBuf z pomocą #PyTest-forked, żeby obejść s…

Linguine: A Natural-Language Programming Language with Formal Semantics and a Clean Compiler Pipeline
Lifan Hu
https://arxiv.org/abs/2506.08396 https://

Linguine: A Natural-Language Programming Language with Formal Semantics and a Clean Compiler Pipeline
Linguine is a natural-language-inspired programming language that enables users to write programs in a fluent, controlled subset of English while preserving formal semantics. The language introduces anaphoric constructs, such as pronoun variables (e.g., "it", "them"), that are statically resolved through referent-tracking analysis combined with a Hindley-Milner-style type system. Each pronoun is guaranteed to be unambiguous and well-typed at compile time. The Linguine compiler pipeline includ…

from my link log —
Silent bugs matter: a study of compiler-introduced security bugs.
https://www.usenix.org/conference/usenixsecurity23/presentation/xu-jianhao
saved 2025-04-27

Quantifying Azure RBAC Wildcard Overreach
Christophe Parisel
https://arxiv.org/abs/2506.10755 https://arxiv.org/pdf/2506.10755…

Quantifying Azure RBAC Wildcard Overreach
Azure RBAC leverages wildcard permissions to simplify policy authoring, but this abstraction often obscures the actual set of allowed operations and undermines least-privilege guarantees. We introduce Belshazaar, a two-stage framework that targets both the effective permission set problem and the evaluation of wildcards permissions spread. First, we formalize Azure action syntax via a context free grammar and implement a compiler that expands any wildcard into its explicit action set. Second, w…

This https://arxiv.org/abs/2503.19449 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

VecTrans: Enhancing Compiler Auto-Vectorization through LLM-Assisted Code Transformations
Auto-vectorization is a fundamental optimization for modern compilers to exploit SIMD parallelism. However, state-of-the-art approaches still struggle to handle intricate code patterns, often requiring manual hints or domain-specific expertise. Large language models (LLMs), with their ability to capture intricate patterns, provide a promising solution, yet their effective application in compiler optimizations remains an open challenge due to issues such as hallucinations and a lack of domain-sp…

This https://arxiv.org/abs/2503.19449 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csSE_…

VecTrans: Enhancing Compiler Auto-Vectorization through LLM-Assisted Code Transformations
Auto-vectorization is a fundamental optimization for modern compilers to exploit SIMD parallelism. However, state-of-the-art approaches still struggle to handle intricate code patterns, often requiring manual hints or domain-specific expertise. Large language models (LLMs), with their ability to capture intricate patterns, provide a promising solution, yet their effective application in compiler optimizations remains an open challenge due to issues such as hallucinations and a lack of domain-sp…

HEC: Equivalence Verification Checking for Code Transformation via Equality Saturation
Jiaqi Yin, Zhan Song, Nicolas Bohm Agostini, Antonino Tumeo, Cunxi Yu
https://arxiv.org/abs/2506.02290

HEC: Equivalence Verification Checking for Code Transformation via Equality Saturation
In modern computing systems, compilation employs numerous optimization techniques to enhance code performance. Source-to-source code transformations, which include control flow and datapath transformations, have been widely used in High-Level Synthesis (HLS) and compiler optimization. While researchers actively investigate methods to improve performance with source-to-source code transformations, they often overlook the significance of verifying their correctness. Current tools cannot provide…

Improving compiler support for SIMD offload using Arm Streaming SVE
Mohamed Husain Noor Mohamed, Adarsh Patil, Latchesar Ionkov, Eric Van Hensbergen
https://arxiv.org/abs/2506.02233

Improving compiler support for SIMD offload using Arm Streaming SVE
The wider adoption of tightly coupled core-adjacent accelerators, such as Arm Scalable Matrix Extension (SME), hinges on lowering software programming complexity. In this paper, we focus on enabling the use of SME architecture in Streaming Scalable Vector Extension (SSVE) mode for workloads written in C/C++. While current compilers optimize loops for all types of SIMD instructions, these techniques primarily target vector units within the core and falter when applied to disaggregated, core-adja…

Some fun facts about #Python limited API / stable ABI.
1. #CPython supports "limited API". When you use it, you get extensions that are compatible with the specified CPython version and versions newer than that. To indicate this compatibility, such extensions use `.abi3.so` suffix (or equivalent) rather than the usual `.cpython-313-x86_64-linux-gnu.so` or alike.
2. The actual support is split between CPython itself and #PEP517 build systems. For example, if you use #setuptools and specify `py_limited_api=` argument to the extension, setuptools will pass appropriate C compiler flags and swap extension suffix. There's a similar support in #meson, and probably other build systems.
3. Except that CPython freethreading builds don't support stable ABI right now, so building with "limited API" triggers an explicit error from the headers. Setuptools have opted for building explicit about this: it emits an error if you try to use `py_limited_api` on a freethreading interpreter. Meson currently just gives the compile error. This implies that package authors need to actively special-case freethreading builds and enable "limited API" conditionally.
4. A some future versions of CPython will support "limited API" in freethreading builds. I haven't been following the discussions closely, but I suspect that it will only be possible when you target that version or newer. So I guess people will need to be building two stable ABI wheels for a time — one targeting older Python versions, and one targeting newer versions plus freethreading. On top of that, all these projects will need to update their "no 'limited API' on freethreading" conditions.
5. And then there's #PyPy. PyPy does not feature a stable ABI, but it allows you to build extensions using "limited API". So setuptools and meson just detect that there is no `.abi3.so` on PyPy, and use regular suffix for the extensions built with "limited API".

This https://arxiv.org/abs/2502.16517 has been replaced.
link: https://scholar.google.com/scholar?q=a

Annotation-guided AoS-to-SoA conversions and GPU offloading with data views in C++
The C++ programming language provides classes and structs as fundamental modeling entities. Consequently, C++ code tends to favour array-of-structs (AoS) for encoding data sequences, even though structure-of-arrays (SoA) yields better performance for some calculations. We propose a C++ language extension based on attributes that allows developers to guide the compiler in selecting memory arrangements, i.e.~to select the optimal choice between AoS and SoA dynamically depending on both the execut…

This https://arxiv.org/abs/2410.18042 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csPL_…

Charon: An Analysis Framework for Rust
With the explosion in popularity of the Rust programming language, a wealth of tools have recently been developed to analyze, verify, and test Rust programs. Alas, the Rust ecosystem remains relatively young, meaning that every one of these tools has had to re-implement difficult, time-consuming machinery to interface with the Rust compiler and its cargo build system, to hook into the Rust compiler's internal representation, and to expose an abstract syntax tree (AST) that is suitable for analy…

This https://arxiv.org/abs/2501.08249 has been replaced.
initial toot: https://mastoxiv.page/@arXiv_csPL_…

Verifying Device Drivers with Pancake
Device driver bugs are the leading cause of OS compromises, and their formal verification is therefore highly desirable. To the best of our knowledge, no realistic and performant driver has been verified for a non-trivial device. We propose Pancake, an imperative language for systems programming that features a well-defined and verification-friendly semantics. Leveraging the verified compiler backend of the CakeML functional language, we develop a compiler for Pancake that guarantees that the b…

Replaced article(s) found for cs.PL. https://arxiv.org/list/cs.PL/new/
[1/1]:
CompilerDream: Learning a Compiler World Model for General Code Optimization

SysLLMatic: Large Language Models are Software System Optimizers
Huiyun Peng, Arjun Gupte, Ryan Hasler, Nicholas John Eliopoulos, Chien-Chou Ho, Rishi Mantri, Leo Deng, Konstantin L\"aufer, George K. Thiruvathukal, James C. Davis
https://arxiv.org/abs/2506.01249

SysLLMatic: Large Language Models are Software System Optimizers
Automatic software system optimization can improve software speed, reduce operating costs, and save energy. Traditional approaches to optimization rely on manual tuning and compiler heuristics, limiting their ability to generalize across diverse codebases and system contexts. Recent methods using Large Language Models (LLMs) offer automation to address these limitations, but often fail to scale to the complexity of real-world software systems and applications. We present SysLLMatic, a system th…

An Execution Model for RICE
Steven Libby
https://arxiv.org/abs/2506.05839 https://arxiv.org/pdf/2506.05839

An Execution Model for RICE
In this paper, we build on the previous work of the RICE compiler by giving its execution model. We show the restrictions to the FlatCurry language that were made to produce executable code, and present the execution model using operational semantics similar to Launchbury. Finally, we show that the execution model conforms with the standard operational semantics for Curry.