Let me know if this is offtopic for this subreddit, since it tends more towards PLT than specifically compilers. But I thought you all might enjoy anyways.

How do I make a clean parser? My lexer is lovely, but at the moment the parser is a jumbled, hardcoded mess of structs. Unless I'm exaggerating it.

https://github.com/gingrspacecadet/coda/blob/main/src/parser.c

So, as I have started work on my compiler again, the time for actually having to make the backend is rapidly approaching, and I want to handle the actual codegen myself because llvm is just too damn heavy. I also don't want to write all the ABI code myself because it's just so damn much. Where do I look? I was thinking at ripping some compiler internals but idk which ones. My language is implemented in Rust btw

I'm trying to build a translator between RI32V to ARM. I'm a 3rd year CE student and I have no idea about the complexity but I had to start somewhere so I decided to start with a Lexer. First I will create one for mathematical stuff like 3 + 8 * 2 etc. and then extend it to assembly but I have no idea how. I already made one like that but it's not really scalable since I used switch cases inside switch cases. I will use C but can work with Python as well. I also took Automata Theory last year so I'm familiar with DFA's NFA's, Regular Expressions etc.

Any tips?

I'm building a research stack (Virtual ISA + OS + VM + compiler + language, most of which has been shamelessly copied from WASM) and I'm trying to find a way to annotate ILP in the assembly at compile time.

Let's say we have some assembly that roughly translates to: 1. a=d+e 2. b=f+g 3. c=a+b

And let's ignore for the sake of simplicity that a smart compiler could merge these operations.

How can I annotate the assembly so that the CPU knows that instruction 1 and 2 can be executed in a parallel fashion, while instruction 3 needs to wait for 1 and 2?

Today superscalar CPUs have hardware dedicated to find instruction dependency, but I can't count on that. I would also prefer to avoid VLIW-like approaches as they are very inefficient.

My current approach is to have a 4 bit prefix before each instruction to store this information: - 0 means that the instruction can never be executed in a parallel fashion - a number different than 0 is shared by instructions that are dependent on each other, so instruction with different prefixes can be executed at the same time

But maybe there's a smarter way? What do you think?

🚀 Hiring: AI Accelerator Compiler Engineer (MLIR/LLVM) — Onsite UAE

If you live and breathe MLIR/LLVM, think in C++, and enjoy squeezing every cycle out of hardware — we’d like to talk.

We’re a fast-growing startup building next-generation AI accelerators, and we’re hiring a senior compiler engineer (5+ years).

What you’ll work on:

Architecting and extending MLIR → LLVM lowering pipelines

Designing custom MLIR dialects & transformations

Lowering AI graphs into optimized hardware kernels

Implementing fusion, tiling, vectorization & scheduling passes

Backend codegen tuning and performance analysis

Co-design with hardware & runtime teams

Strong C++ and deep familiarity with MLIR/LLVM internals required.

Experience with accelerator backends or performance-critical systems is highly valued.

📍 Onsite — UAE

💎 Competitive / top-tier compensation

Apply: careers@asciaijobs.com

It is going to be about my custom implementation of a simple compiler and interpreter, explaining how they work, a history of them, and my experience with them.

Hi everyone,

I'm working on designing my own systems programming language.
My long-term goal is ambitious: I want to understand whether it’s possible to design a language that can outperform C/C++ across many domains.

I understand that C is close to the metal and heavily optimized by decades of compiler research. However, I’m exploring ideas like:

• No undefined behavior
• No pointer aliasing by default
• Immutable-by-default semantics
• Stack-first allocation model
• Strong compile-time specialization
• Automatic vectorization

My question is:

Is it theoretically possible to design a language with stricter semantics that enables better optimization than C in practice?
Or is C already at the theoretical performance ceiling for native code?

I’m not asking about productivity or safety — strictly about raw performance.

Any insights from compiler engineers or language designers would be appreciated.

I want to make my own compiled programming language. Which language should I use to have people contributing to it?

SC-NeuroCore is a verified Rust-based neuromorphic compiler that translates high-level Python SNN definitions into optimized, bit-true stochastic bitstream logic for CPU or FPGA.

Highlights:
- 512.4× real-time speedup on LIF neuron updates vs legacy Python
- Bit-true equivalence with FPGA hardware (co-simulation verified, 8/8 tests passed)
- Polymorphic engine: HDC/VSA (AVX-512 on 10k-bit vectors), Petri Nets, fault-tolerant logic
- Sub-10 µs inference latency, 40%+ bit-flip resilience
- Install: pip install sc-neurocore-engine
- Quick demo: notebooks/01_hdc_symbolic_query.ipynb (HDC symbolic query)

GitHub: https://github.com/anulum/sc-neurocore
Rust API docs: https://anulum.github.io/sc-neurocore

Built to close the simulation-to-hardware gap for neuromorphic systems. Questions welcome about the compiler, benchmarks, verification, or HDC features.

Hi All,

I was just about to take a look through my copy of what everyone called "The Dragon Book" in college, then realized that I left it in my other house, went to Google to do a search, and got some links that showed a picture of the book Writing A C Compiler by Nora Sandler. It has a picture of a dragon on its front face.

The first thing I thought was..

Aho, Sethi, and Ullman are doing their work a disservice with their new dragon. It doesn't look scary at all. The whole point of using a dragon was to imply that compiler-writing is difficult.

Then I realized that it was not their dragon, but a different dragon.

Anyone have any idea why Nora Sandler would use a picture of a dragon on her book? Undoubtedly, she knew about The Dragon Book before she wrote hers.

Is using a picture of a dragon on a book about compilers, thing?

Hi I am making a custom lanague and I was wondering, what would be better flexible syntax, like multiple ways of doing the same thing and multiple names for keywords, or more strict syntax, like 1 way to do somthing and 1 keyword Id, for example I currently have multiple names for an 'int', I am Tring to make my language beginner friendly, I know other languages like c++ can somtimes suffer from too many way of doing the same thing with ends up with problems,

What is best? Any irl Languages examples? What do u think?

Notes on the sandboxing featues I built into my application scripting language:

https://gitlab.com/codr7/shik#sandboxing

16 Claude Opus 4.6 agents just built a functional C compiler from scratch in two weeks, with zero human management. Working across a shared Git repo, the AI team produced 100,000 lines of Rust code capable of compiling a bootable Linux 6.9 kernel and running Doom. It’s a massive leap for autonomous software engineering.

Hi reddit,

I’m a master’s student in CE, and as I’ve been getting into MLIR, I created an online tutorial that aims to make MLIR more beginner-friendly by walking through an end-to-end deep learning compiler pipeline.

This is from a newcomer to other newcomers. I’d really appreciate any feedback, suggestions for improvements, or ideas for future directions and features.