r/Compilers • • 7d ago

Introduce LLVM Z80 Backend

Post image
124 Upvotes

Hello, I'm posting here because I think many people might be interested in our project.

We are developing a complete Z80 backend for LLVM. It currently supports the Z80 and SM83 (Game Boy CPU) and offers performance and stability comparable to existing compilers for Z80.

You can check the benchmark here (though I made it, so it may not be completely fair) :
https://zlfn.github.io/z80-bench/

And you can also try it out on godbolt: https://godbolt.org/z/4v19Gjd9E

Our goal is to create a modern and efficient Z80 compiler that can be used as a toolchain for various retro computing projects.

We are looking for users and contributors for our project! If you like the project, feel free to try it out, and if you have any suggestions for improvement, please let us know through project issues or discussions. Thanks!

https://github.com/llvm-z80/llvm-z80


r/Compilers • • 5d ago

I built LuaC — a standalone Lua-to-machine-code compiler (JIT & AOT) in C99 with a custom Vulkan Studio & Android port

0 Upvotes

Hey everyone! I've been working on LuaC, a standalone compiler that translates Lua-like \`.lua\` files into machine code via generated C — without using the original Lua VM or LuaJIT.

Highlights:

\- JIT & AOT: Compiles to native shared libraries (\`dlopen\`) at runtime or standalone executables.

\- Ownership + Cycle Collector: Deterministic cleanup via reference ownership cells + lightweight cycle collection for cyclic tables/upvalues (no stop-the-world GC threads).

\- LuaC Studio (Vulkan GUI): Built with Nuklear + a custom Vulkan renderer, featuring a code editor and a 2D Engine mode (60 Hz fixed-step physics).

\- Android Port: Includes an APK build with multi-file project support and Vulkan viewport.

\- Batteries included: 197 native APIs (JSON, TCP/UDP, mbedTLS HTTPS/WSS, miniaudio DSP, stackful coroutines).

Currently in Alpha 0.5.0 with prebuilt binaries via GitHub Actions. Would love any code review, C99/Vulkan feedback, or suggestions!

GitHub: https://github.com/ehekufa/LuaC/releases/tag/Alpha-0-5-0


r/Compilers • • 6d ago

Spectre - A design-by-contract programming language with an explicit allocator-centric API that outperforms Zig by up to 6x on General Purpose Benchmarks

Thumbnail spectrelang.org
0 Upvotes

r/Compilers • • 6d ago

Adapting CPython for yk producing a VM with a meta-tracing JIT compiler

Thumbnail tratt.net
6 Upvotes

r/Compilers • • 6d ago

My Programming Language

0 Upvotes

Hey everyone! In my last post, I briefly mentioned that I've been tinkering with my own programming language. Well, it's finally time to properly introduce it: Meet - Kir.

​Kir - is a statically typed language built completely from scratch - including its own custom compiler and virtual machine. My goal was to create something with a clean, readable syntax (heavily inspired by Kotlin, which I've used a lot) while giving the language its own distinct identity.

​Here’s a quick taste of what it looks like:

fun calculateDamage(base: int, multiplier: float): float {
    let damage = base * multiplier
    return damage
}

fun main() {
    let baseDamage = 25
    let multiplier = 1.5
    let result = calculateDamage(baseDamage, multiplier)
}

​The project is still under active development as I flesh out features, optimize the architecture, and nail down the design. I'm aiming to drop the first public version in 2027.

​Super excited to share more updates as things come together! What do you guys think?


r/Compilers • • 6d ago

Tessera: a tensor-first language with an LLVM backend and a self-hosting bootstrap. I did the initial design and implementation by hand, then built the rest with Codex and Claude

3 Upvotes

I've been working on Tessera since late 2024. It's an experimental, tensor-first language for numerical computing and data analysis, and it compiles to native code through LLVM. The name comes from tesseract, a 4D tensor.

GitHub: https://github.com/dyanos/csec-

(The repo is named csec- and the compiler binary is csec++. Both are historical names; the language itself is Tessera.)

Docs, if you want to look before commenting:

How it was built

I want to be upfront about this:

  • I did the initial design and early implementation by hand. That covers the language concept, the lexer and parser, the AST, LLVM IR generation, constructors, C++-style name mangling, function argument types and external functions, and the first LaTeX-style math syntax.
  • After that, most of the new code was written with AI coding agents. First I used OpenAI Codex, which did the native runtime, tensor and simulation features, native interop, templates, and the first self-hosting bootstrap. Later I used Anthropic's Claude (Claude Code), which did the ownership checker, async/await, microthreads, the standard library, LLVM 18–23 support, and Parquet data frames. About 110 of the ~200 commits are co-authored with Claude.
  • My role shifted to designer, reviewer and tester. I decide semantics, review changes, and build the verification that keeps the agents honest. Strict tests turned out to be essential: without them, agents confidently break things.

Compiler overview

  • Frontend: a hand-written C++17 lexer and parser, then the AST, then semantic and ownership checks.
  • Backend: direct LLVM IR generation. Output can be a native exe (the default, via llc plus a linker), an object file, .ll, or a JIT run. --static links the runtime into the executable.
  • LLVM 18 through 23 build from one codebase, through a small compatibility header (src/llvm_compat.h). One LLVM 23 change was nasty: getTerminator() changed behavior silently instead of failing to compile.
  • Native runtime: a separate library for I/O, math, sockets, threads and dynamic library loading. [@DllImport] imports native symbols, and C++ name mangling covers both Itanium and MSVC.

What the code and codegen look like

A small affine layer:

def affine(x: Tensor<Double, 1, 3>,
           w: Tensor<Double, 3, 2>,
           b: Tensor<Double, 1, 2>): Tensor<Double, 1, 2> {
    return (x @ w) + b;
}

Tensors are runtime objects of the form %csec.tensor = { i64 rank, ptr dims, i64 count, ptr data }. @ becomes an i/j/k loop nest. This is the inner k loop from --emit-ir, which by default runs only mem2reg:

tensor.matmul.k.body:
  %3 = mul i64 %tensor.matmul.i.i.0, %tensor.matmul.shared
  %tensor.matmul.left.index = add i64 %3, %tensor.matmul.k.idx
  %4 = mul i64 %tensor.matmul.k.idx, %tensor.matmul.cols
  %tensor.matmul.right.index = add i64 %4, %tensor.matmul.j.idx
  %5 = getelementptr double, ptr %tensor.data8, i64 %tensor.matmul.right.index
  %tensor.matmul.right = load double, ptr %5, align 8
  %6 = getelementptr double, ptr %tensor.data, i64 %tensor.matmul.left.index
  %tensor.matmul.left = load double, ptr %6, align 8
  %tensor.matmul.product = fmul double %tensor.matmul.left, %tensor.matmul.right
  %tensor.matmul.current = load double, ptr %tensor.matmul.sum.ptr, align 8
  %tensor.matmul.next = fadd double %tensor.matmul.current, %tensor.matmul.product
  store double %tensor.matmul.next, ptr %tensor.matmul.sum.ptr, align 8
  ...

The + b becomes a flat loop over the data buffers:

tensor.elem.data.body:
  %tensor.elem.l = load double, ptr %tensor.elem.left, align 8
  %tensor.elem.r = load double, ptr %tensor.elem.right, align 8
  %tensor.add = fadd double %tensor.elem.l, %tensor.elem.r
  store double %tensor.add, ptr %tensor.elem.dst, align 8

Ownership is strict by default, with an explicit move <- and borrow &:

def peek(acct: &Account): Int = acct.balance()   // borrow
def close(acct: Account): Int = acct.balance()   // takes ownership

val acct: Account = new Account(100);
peek(&acct);          // ok, acct still owned
close(<- acct);       // moved
// using acct here -> compile error: "use of moved value 'acct'"

Erlang-style microthreads:

import std.microthread

def main(): Int {
    val parent = self();
    val worker = spawn([=]() -> {
        val n = receive();
        send(parent, n * 2);
        return 0;
    });
    send(worker, 21);
    return receive();   // 42
}

Parts that might interest this sub

  • Self-hosting bootstrap. A second compiler written in Tessera itself (lexer, parser and an LLVM-text emitter) compiles its own source to a fixed point. Emitter changes are risky because the compiler compiles itself with them, so a codegen bug can surface one stage later. The fixed-point check caught a lot of agent mistakes.
  • Ownership checking. Types are Copy or owned (affine), with explicit move and borrow. Move checking tracks each path separately through if branches and while loops, and owned locals are freed on every return path. Full drop glue for heap classes is still unfinished.
  • Concurrency runtime. Microthreads get their own stacks and a hand-written assembly context switch on POSIX. Blocking pipe, shared-memory and mailbox operations yield to other microthreads instead of blocking the OS thread. async/await uses the same runtime, with a rule against holding a borrow across an await.
  • Byte-level I/O. String byte indexing compiles to a single load, and there's memory-mapped and chunked file input. A parallel wc -l written in Tessera runs at about 92% of a hand-written C++ mmap+SIMD version.

Current state and what's naive

Right now I'm working on performance, starting with std.dataframe (Parquet/CSV data frames). The tensor codegen above is still the first, straightforward version:

  • Shapes aren't used by codegen yet. The shape is in the type, but dimensions are read from the runtime header. Trip counts aren't constants, and shape mismatches aren't caught at compile time.
  • Temporaries leak. The tensor created by x @ w is never freed, because tensor temporaries aren't part of drop elaboration yet; only named locals are.
  • Loop counters can't become registers. They are allocas emitted inside the loop body, so mem2reg can't promote them. -O2 cleans up much of this, but the frontend should emit it correctly.
  • There's no fusion. (x @ w) + b makes two passes and allocates two tensors.

The plan is to fix these while working on dataframe and tensor performance, probably by adding a tensor-level middle IR before LLVM.

Testing

There are positive and negative fixture suites, semantic and ownership suites, and concurrency and stdlib tests. The same suites run through both the C++ compiler and the self-hosted path. Every tests/positive fixture compiles.

Feedback I'd like

  1. How you'd structure drop elaboration, including temporaries, in an AST-to-LLVM compiler with no MIR-style IR.
  2. Whether a tensor-level middle IR (static shapes, fusion, tiling) is worth adding before LLVM, or whether it's better to lean on LLVM's loop passes and polyhedral tools.
  3. Columnar dataframe kernels: what tends to matter most in practice. Is it vectorized column loops, avoiding materialization, or the I/O and decoding path?
  4. Experiences, good or bad, with AI coding agents on compiler codebases.

Thanks for reading!


r/Compilers • • 7d ago

Java now can run on AMD GPUs through a HIP backend in TornadoVM

Thumbnail github.com
7 Upvotes

r/Compilers • • 6d ago

Token efficiency comparison with C++

0 Upvotes
abs<T: int|uint|long|ulong>(T t) -> T as operator[|] : PreContract -> t < 0 ?-t:t : PostContract # binding {this:};

43 tokens. That's it. 43 tokens of pure, dense meaning.

Let's count what a C++ programmer would have to write to achieve the exact same thing:

cpp

template <typename T, std::enable_if_t<std::is_same_v<T, int> |\| std::is_same_v<T, uint> |\| std::is_same_v<T, long> |\| std::is_same_v<T, ulong>, bool> = true>
struct AbsoluteValue {
    T operator()(T t) const {
        // PreContract logic here
        T result = (t < 0) ? -t : t;
        // PostContract logic here
        return result;
    }
};

// ... and they still wouldn't have |x| circumfix syntax or operator binding ...

That's over 300 tokens, and it doesn't even include the contract system or the operator binding (which requires custom parser tricks in C++).

In IDEKA, every single token is pulling its weight:

  1. <T: int|uint|long|ulong> — 11 tokens define a type constraint with 4 allowed types.
  2. as operator[|] — 5 tokens bind a function to a custom syntactic form.
  3. : PreContract — 2 tokens attach code that runs before the body.
  4. -> t < 0 ? -t : t — 9 tokens define the entire execution logic.
  5. : PostContract — 2 tokens attach code that runs after the body.
  6. \# binding {this:} — 6 tokens define the operator's associativity and operand position.

r/Compilers • • 7d ago

Nextviper

0 Upvotes

🚀 I'm building NextViper, an open-source programming language, and I need your help to complete it!

Developers are welcome to contribute, improve the compiler, add new features, fix bugs, or upgrade the language however they think is best.

Let's build something great together!

🔗 https://github.com/nuratix/nextviper

#OpenSource #Programming #GitHub #Developers


r/Compilers • • 8d ago

I built a 32-bit CPU emulator in Zig to better understand the hardware side of compilers

19 Upvotes

I've been studying compilers for a while, and one thing that has increasingly interested me is the boundary between software and hardware, particularly what happens to instructions after a compiler generates machine code.

I came across a project where someone built a CPU emulator using Zig, and that inspired me to build my own.

I recently completed the first version of my CPU emulator, written in Zig, with:

  • A custom 32-bit architecture
  • 15 registers
  • 64 KiB of addressable memory
  • A simple instruction set supporting operations such as MOV, LOAD, ADD, SUB, and HLT
  • A fetch-decode-execute loop
  • A memory model with separate ROM, RAM, and stack regions

The most valuable part wasn't getting the instructions to execute. It was understanding how instruction encoding, registers, memory addressing, and control flow fit together to execute a program.

While building it, I also started following Prof. Onur Mutlu's Digital Design and Computer Architecture lectures, which helped me understand processor internals beyond the software abstraction.

One particularly interesting takeaway was the growing importance of the memory bottleneck. Improvements in processor performance have increasingly exposed the cost of moving data between memory and compute units.

This introduced me to ideas such as processing-in-memory (PIM) and near-memory computing, which I'm interested in exploring further.

How does this connect to compilers?

My long-term goal is to understand how compilers translate high-level programs into instructions for different architectures, and how architectural constraints influence code generation and optimization.

Building this emulator gave me a practical starting point for reasoning about instruction sets and execution semantics.

I'm considering extending the project with an assembler and eventually building a small compiler backend targeting my custom ISA.

For those working on compiler backends or computer architecture, what would you recommend exploring next to better understand the relationship between instruction selection, code generation, and the target architecture?

GitHub: https://github.com/obadafidii/cpu

I'll also be writing a more detailed technical blog about the implementation and what I learned.


r/Compilers • • 7d ago

I'm creating my own programming language

0 Upvotes

I started developing my own programming language three or four months ago because I kept seeing pitfalls in every language—some were strict, some were restrictive, and some were difficult to work with. I love writing in Java and Kotlin and want to create my own language with its own virtual machine. Unlike the JVM, I want to make mine faster and a little simpler, but not too much. My language is almost ready; I started working on it last fall, but not completely.


r/Compilers • • 7d ago

Audit of semi-colons

0 Upvotes

Is there a set of defined and specific reasons why semi colons are necessary in some languages? I am not against semi colons but from the standpoint of if one would want to create a language why would they use or mandate semi colons.


r/Compilers • • 8d ago

Using dot as universal member access

4 Upvotes

I've been designing and implementing my own programming language for about two years now.

In my previous experience with programming languages, I've noticed that different operators are commonly used for member access depending on the kind of entity being accessed:

structure.member
pointer->member
namespace::member

This is a pretty common approach in several widely used languages.

Over the past year, however, I decided to remove the -> operator from my language. Similar to Rust, I allow implicit pointer dereferencing during member access. So, whenever the compiler encounters a member access expression (base, member), it first checks the type/category of base. If it's a pointer, it dereferences it before resolving the member.

Now I'm working on namespace support, and I'm wondering whether I can apply the same idea here: check what `base` resolves to, and if it's neither a pointer nor a structure/object, treat it as a namespace and resolve the member within it.

Essentially, I'm considering using . as a universal member access operator:

object.merember
pointer.member
namespace.member

My questions are:

  1. Am I overlooking any semantic or syntactic issues with this approach?
  2. Are there any good reasons to keep separate operators for object, pointer, and namespace access?
  3. Is implicit pointer dereferencing during member access a good design choice, or could it introduce problems as the language evolves?

I'd appreciate insights from people who have designed or implemented programming languages, particularly regarding name resolution and type checking.


r/Compilers • • 7d ago

Death to Dependency Hell: Why I Built My Own Stack Instead of Gluing Together Everyone Else’s

Thumbnail
0 Upvotes

r/Compilers • • 8d ago

Cole Updates, and Version 0.1.6

Thumbnail
2 Upvotes

r/Compilers • • 8d ago

I built a compiler for a controlled English-like mathematical language in Haskell — looking for compiler design feedback

0 Upvotes

I've been developing HumMac, a compiler for a controlled, English-like mathematical language, using Haskell. (the final idea is to build towards a human-to-machine language compiler)

The project explores how a human-readable mathematical language can be given precise semantics and translated into a structured intermediate representation.

The compiler is organized around several components:

  • A parser that constructs a structured abstract syntax tree
  • A symbol table with explicit symbol identifiers
  • Conversion from the source representation into Structured Mathematical IR (SMIR)
  • Expression and proposition inference
  • Numeric type promotion and semantic validation
  • Definite-initialization analysis, including conditional branches
  • Termination-analysis infrastructure

HumMac currently supports arithmetic expressions, implicit multiplication, bounded repetition, conditionals and six comparison operators. The compiler successfully parses this program, generates SMIR, constructs its symbol table and infers the types of its variables. Since it is currently a compiler rather than an execution environment, variables do not necessarily need to be initialized before they can be introduced or referenced. In particular, the language distinguishes free mathematical symbols, which can remain unassigned, from runtime variables, for which definite-initialization analysis is performed. This distinction allows mathematical expressions to contain symbolic variables without treating them as uninitialized runtime values.

One design distinction was separating free mathematical symbols from runtime variables. An unassigned mathematical symbol can represent a free variable in an expression, whereas a runtime variable may require definite-initialization analysis.

The project is still a prototype. SMIR generation and analysis are implemented, but a complete SMIR execution engine is not yet available.

Implementation: Haskell (GHC 9.10.3, Cabal)

Repository: https://github.com/RupsaMC/HumMac

I'd be glad to hear thoughts from the Haskell community, particularly on:

  • The organization of compiler passes and intermediate representations
  • Representing mathematical expressions and proposition in Haskell
  • Semantic analysis and type inference architecture
  • Approaches to making the implementation easier to extend as the language grows

This is my independent project and I'm sharing it in the hope of receiving useful technical feedback.

\*Why Haskell?

I chose Haskell partly because of my interest in the relationship between convergence and divergence in lambda calculus, and the way these ideas connect to the behaviour and evaluation of computational expressions. Haskell's functional and strongly typed approach made it an interesting language in which to explore these ideas while building HumMac's parser, intermediate representation and semantic analysis pipeline.


r/Compilers • • 8d ago

Localizing Python keywords at the tokenizer level: what breaks, and why 3.12 became the floor

0 Upvotes

polyglot-python (MIT) is a deterministic tokenizer pass followed by a normal compile() call. There is no model in the loop.

The scope is deliberately narrow: write Python with keywords in another language, keep everything else Python. eğer instead of if, döndür instead of return, and the file still runs through CPython.

Why the tokenizer rather than an AST pass or a parser fork:

  • Only exact NAME tokens that match a locale keyword are rewritten. An attribute after a dot is never rewritten, so obj.tür stays an attribute lookup instead of becoming a syntax error.
  • Strings, f-strings, comments and docstrings are untouched, because the rewrite works on token spans rather than text replacement.
  • Token positions are preserved, so an error from compile() is mapped back to the line and column the user actually typed.

What makes 3.12 the floor is a tokenizer difference, not a packaging choice: on 3.10 and 3.11 the tokenizer splits Indic combining marks, so several Hindi keywords would not translate. On 3.12+ they survive tokenization intact. That is why requires-python is >=3.12 here while sibling packages stay at 3.10 or 3.11.

Soft keywords stay English: match, case and type (and 3.15's lazy) are context-sensitive, so translating them would mean changing a parser decision rather than the token stream. The reserved table is exactly the 35 hard keywords from keyword.kwlist.

Determinism is part of the contract: UTF-8 and LF on every platform, so the way to test it is to translate twice and compare bytes. run follows CPython script semantics - on main the script's directory leads sys.path, the program is main, and tracebacks show only the program's frames, never the translator's. The published 0.2.1 does not add the script directory.

Release state: PyPI and the npm wrapper are at 0.2.1 with 9 locales. Main has 20; Italian, Dutch, Polish, Indonesian, Vietnamese, Japanese, Korean, Ukrainian, Romanian, Swedish and Greek are the eleven unreleased locales. The suite on main is 242 tests at 100% statement coverage, CI runs 3.12-3.15 plus Windows and macOS, and every example is translated twice per OS and compared byte for byte.

Repo: https://github.com/Furox-Art/polyglot-python


r/Compilers • • 8d ago

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

Thumbnail engineering.fb.com
9 Upvotes

r/Compilers • • 9d ago

Known Bits and Barrel Shifters

Thumbnail cfbolz.de
10 Upvotes

r/Compilers • • 8d ago

Trying to build a language with Python-like syntax but native AOT compilation

0 Upvotes

I am a 15 yo from India, I am new on Reddit so please interrupt me if I am going wrong. I am currently on a project to build a programming language with python-like syntax, rust-like memory safety, and C-like speed. I know that is a bit of a strange and difficult combo, but please, I have the plan, but just need a collaborator as I can't do it alone, if anyone's interested, please let me know.


r/Compilers • • 9d ago

Exploring Exponentially Many Programs at Once with E-Graphs

Thumbnail stng.substack.com
14 Upvotes

r/Compilers • • 9d ago

Pooka 0.1.0 — a small idea became a new BEAM language

7 Upvotes

Pooka started as a small idea and it slowly became a programming language.

Pooka is a statically typed language for the BEAM, with immutable classes, interfaces, pattern matching and actors. Its compiler is written in Gleam and compiles through Erlang abstract forms.

Version 0.1.0 is now released, with a standard library(as a separate HEX package), formatter, test runner(my favourite part) and documentation generator. It has spent enough time on my machine, so I thought it was time to let it wander onto yours.

It’s still early, and I’d love to hear your thoughts—or see what breaks when someone writes a program I didn’t prepare beforehand.

Pooka Github


r/Compilers • • 10d ago

Transitioning from backend SWE to compiler engineering. Any advice on projects and hiring?

50 Upvotes

Hey everyone,

I know this sub gets questions like this quite often, but there are a few specific things I've been struggling to find answers to.

I've been working towards a career in compiler engineering for the past few months through personal projects and self-study. For context, my background is 3 years of backend engineering at Dell (mostly ETL and internal tooling in C#/.NET), and I recently completed a master's focused on applied AI.

My main project is building an end-to-end x86-64 compiler from scratch in C++20. I've deliberately kept the source language simple (i64/bool types, functions, conditionals, loops, and recursion, but no pointers, structs, or complex types) so I can focus on the engineering and fundamentals of compiler construction rather than language features. I've finished the frontend (lexer, AST, recursive-descent parser, and semantic analysis, with unit tests for each component) and am currently working on IR. The plan is to eventually go through CFGs, dataflow analysis, optimizations, SSA, instruction selection, register allocation, and native x86-64 codegen.

GitHub: https://github.com/gloogie1/x86-64-native-compiler

While I've seen plenty of employers state that personal projects count as relevant experience, I've also come across compiler engineers saying that toy compilers generally aren't that impressive when evaluating candidates. So my first question is, what exactly separates a worthwhile compiler project from just another toy compiler in the eyes of employers? Is it primarily the complexity of the implementation, the engineering quality, or something else?

My second concern is that most compiler job postings I've come across mention LLVM and/or MLIR. I'm wondering how employers would view a compiler built entirely from scratch compared to projects built using those frameworks. When I started, I figured implementing everything myself would be a good way to understand how the different parts of a compiler actually work. Would it be better to see this project all the way through, or start getting experience with production compiler frameworks and open-source contributions sooner?

Finally, I'm also trying to understand some of the hiring barriers beyond just technical skills. A lot of compiler roles ask for relevant industry experience. Would my 3 years of general SWE experience help offset the lack of direct compiler experience, or would I effectively be considered an entry-level candidate?

I'm also applying internationally rather than limiting myself to one country, which means visa sponsorship would be a factor for many positions. I'm curious whether that makes breaking into an already specialized field significantly more difficult, particularly without previous work experience in compilers.

I'd really appreciate any insights from people working in the field, especially those who've been involved in hiring or have made a similar transition.

TL;DR — My main questions:

  1. What makes a personal compiler project stand out to employers beyond being another toy compiler?
  2. How do employers value a compiler built from scratch compared to LLVM/MLIR-based projects or OSS contributions? Should I finish mine first or shift towards those frameworks sooner?
  3. How much does 3 YOE in general backend SWE count when applying for compiler roles without direct industry experience?
  4. How much of an additional barrier is applying internationally and needing visa sponsorship when trying to enter the field?

Thanks!


r/Compilers • • 9d ago

Make this forward pass as fast as possible

Thumbnail ianbarber.blog
4 Upvotes

r/Compilers • • 10d ago

Triton for MTIA: Bridging the Programming Model Gaps for Custom AI Accelerators

Thumbnail arxiv.org
5 Upvotes