jax

This work addresses the lack of a unified framework in existing domain-specific language (DSL) compilers, which leads to redundant development, maintenance challenges, and difficulty meeting production-grade requirements. The paper presents the first fully MLIR-based NumPy-like DSL, featuring native implementation of both front-end parsing and semantic analysis within MLIR. It introduces a novel dialect-agnostic type checker and a parallelism-first lowering strategy that seamlessly integrates with MLIR’s dataflow dialects. By doing so, this approach not only advances the standardization of DSLs within the MLIR ecosystem but also demonstrates strong performance on real-world Fortran applications in domains such as weather modeling and computational fluid dynamics.

This paper addresses the challenge of automatically mapping PyTorch models to synthesizable hardware. We propose an open-source, end-to-end compilation toolchain that innovatively integrates Allo (an accelerator design language), Calyx (a hardware intermediate representation), and CIRCT (an LLVM-based hardware compilation framework). A key methodological contribution is a memory-partitioning compilation pass tailored for memory-intensive machine learning workloads, which significantly enhances data parallelism and on-chip memory efficiency. Our core contributions are threefold: (1) the first fully automated, synthesizable translation from PyTorch frontend to SystemVerilog RTL; (2) a memory optimization strategy that preserves functional correctness while substantially reducing off-chip bandwidth pressure; and (3) experimental validation showing that the generated FPGA implementations achieve throughput and resource utilization comparable to industrial-grade, closed-source tools such as Vitis HLS.

Virtual machines (VMs) generated by meta-compilation frameworks—such as RPython and Graal/Truffle—typically lack multi-tier just-in-time (JIT) compilation support, hindering the balance between startup latency and peak performance for dynamic languages. Method: This paper proposes a lightweight, backend-agnostic paradigm for constructing multi-tier JIT compilers: by embedding compilation directives directly into the interpreter definition, a first-tier lightweight compiler can be built without modifying the underlying framework backend. Contribution/Results: Our approach achieves the first clean decoupling of compilation tiers from the framework backend. Implemented in the RPython-generated 2SOM VM, it enables cooperative two-tier compilation—combining a threaded-code interpreter with a tracing JIT. Evaluation shows a 15% improvement in warmup performance over the standard RPython VM, with only a 5% degradation in peak performance. This significantly enhances the trade-off between startup latency and sustained execution efficiency in dynamic-language VMs.

This work addresses the longstanding challenge in scientific computing of balancing performance and developer productivity, compounded by poor cross-GPU platform portability. To this end, we propose a Mojo-language compilation framework built on MLIR. The framework unifies Python ecosystem interoperability with CUDA-like syntax and introduces, for the first time, a compile-time programming model tailored to scientific computing kernels—including 7-point stencil, BabelStream, miniBUDE, and Hartree–Fock. Leveraging integrated MLIR-based lowering to LLVM, CUDA, and HIP backends, it delivers native support for both NVIDIA (H100) and AMD (MI300A) GPUs. Experimental evaluation shows that memory-bound kernels achieve performance on par with hand-optimized CUDA/HIP implementations, significantly bridging the toolchain fragmentation gap between AI and traditional HPC. However, kernels dominated by atomic operations or fast-math intrinsics remain targets for future optimization.

This work addresses the feasibility of leveraging state-of-the-art general-purpose large language models (LLMs)—specifically GPT-4.1 and o4-mini—for automated, high-performance BLAS (Levels 1–3) C code generation directly on CPU platforms. Method: Given only standard routine names or reference Fortran implementations, we employ prompt engineering to elicit LLM outputs incorporating OpenMP parallelism, SIMD vectorization, and cache-blocking optimizations, followed by rigorous functional correctness verification and performance benchmarking against BLAS specifications. Contribution/Results: The LLMs generate syntactically valid and semantically compliant code without natural-language descriptions; approximately 70% of routines pass functional tests upon first-generation. Notably, several LLM-generated implementations surpass OpenBLAS in single- and multi-threaded performance, achieving up to 2.3× speedup. This study demonstrates, for the first time, the practical viability of general-purpose LLMs in generating production-grade numerical library kernels, establishing a novel paradigm for AI-assisted development of high-performance computing infrastructure.

This study presents the first systematic evaluation of large language models’ (LLMs’) ability to generate efficient task-parallel code across three prominent parallel programming frameworks: OpenMP Tasking, the C++ Standard Parallel Library, and the HPX runtime. We compare the correctness and strong/weak scalability of code generated under three prompting strategies—natural language descriptions, serial reference implementations, and parallel pseudocode. Our experiments reveal that while LLMs perform adequately on simple parallelization tasks, they exhibit significant limitations in handling complex task dependencies and fine-grained control constructs. Moreover, the choice of parallel framework substantially influences the quality of the generated code. These findings provide empirical evidence and delineate the practical boundaries for leveraging LLMs in high-performance computing contexts.

This work addresses the inefficiencies of conventional GPU linear algebra libraries, which often fail to fully exploit hardware capabilities due to redundant memory accesses and runtime overhead. To overcome these limitations, the authors propose Bandicoot, a toolkit that leverages C++ template metaprogramming to perform expression fusion at compile time, thereby automatically generating highly optimized GPU kernels that saturate memory bandwidth—without relying on just-in-time compilation or runtime scheduling. Bandicoot provides an API compatible with Armadillo, facilitating straightforward migration of existing CPU codebases. Experimental results demonstrate that Bandicoot significantly outperforms PyTorch, TensorFlow, and JAX across multiple benchmarks, achieving substantial speedups in several scenarios.

Existing benchmarks for large language models fail to capture the practical demands of high-energy physics and high-performance computing, such as scientific constraints, complex dependencies, and performance-critical requirements. To address this gap, this work proposes the first reproducible, automated, and multidimensional evaluation framework tailored to this domain, encompassing three core tasks: Doxygen-style documentation generation, end-to-end GPU kernel synthesis, and vision-enhanced scientific data analysis. By establishing a unified evaluation protocol and an automated scoring mechanism, the framework provides reliable metrics for code correctness, integration capability, robustness, and multimodal validation. This enables fair and systematic comparison of AI programming assistants and establishes a new benchmark for AI-assisted software development in scientific computing.

This work addresses the challenge of automatically generating high-performance computing (HPC) code that simultaneously preserves contextual awareness and structural consistency within complex codebases. To this end, the authors propose an in-terminal CLI framework that integrates large language models (LLMs), retrieval-augmented generation (RAG), and abstract syntax tree (AST) analysis. Their key innovation lies in embedding AST-derived structural information into the RAG retrieval process to construct high-fidelity prompts, thereby enabling structure-preserving, precise code generation. Experimental evaluation on representative HPC projects such as AMReX demonstrates that the proposed approach effectively produces high-quality code adhering to existing structural conventions and programming paradigms, significantly enhancing both development efficiency and code consistency.

Existing approaches struggle to reliably verify the semantic correctness of large language models (LLMs) when translating high-performance computing (HPC) code across programming models. This work proposes Kaizen, a novel framework that, for the first time, integrates mutation-based metamorphic fuzzing with differential testing and introduces syntax-guided input generation to systematically evaluate LLM-generated translations. Experiments on 16 scientific applications demonstrate that successful compilation does not guarantee semantic correctness, and full-program translation is significantly more challenging than kernel-level translation. The study uncovers nine categories of kernel-level and twenty-seven categories of full-program error patterns, revealing critical limitations of current LLMs in HPC code migration tasks.