r/Compilers

Hello,

I'm searching for a compiler for my Python game so It can run faster and can be package in a standalone file (without need of Python installed on the host)

Hi, im a begginer and i want to learn how to make a compiler for my project

im at chapter 2 of the engineering compiler ,wich is about laxical analyzer and i just struggle to understand the utility/ the reason on why i should use a graph instead of if statement ?

i barely understand how to use it in this context also

i have seen some video and some code but i still dont get it

the concept is really hard for me to understand, if someone could help me it would be cool

Hi,

I’m currently working on a new programming language called Klyn.

I know some people will probably say: “Why yet another programming language?” And maybe they have a point. But from another perspective, why not be bold and try to offer a different take?

Anyway, my starting point is this: Python offers a clean and readable syntax, but when it comes to execution performance, it is not always ideal. So I started wondering: why not bring some of the good ideas from C++ into a Python-like language, especially for performance? And while we’re at it, Java and C# also have some interesting ideas worth borrowing. I also wanted to experiment with a few personal ideas, especially around collection syntax.

That is how I started building Klyn: a Python-like language focused on performance.

At this stage, Klyn currently offers:

• a readable and pleasant syntax, close to Python;
• static typing for more reliable code;
• implicit native compilation for performance;
• C#-inspired properties;
• several personal ideas around syntax and libraries;
• an already fairly broad API covering collections, strings, files, terminal I/O, GUI, databases, threads, LLM APIs, and more.

Since I’m currently working alone on the project, I have made extensive use of AI. I prefer to be transparent about that; I’m on the Codex side. Honestly, I don’t regret it. Still, the project is not production-ready yet, and that is exactly why I’m looking for feedback before moving toward that future stage.

So I’d really appreciate your impressions. And if you find the general approach interesting, what else would you expect from such a project?

Project website: https://klyn.deepcodia.fr
Tutorial: https://klyn.deepcodia.fr/docs/tutorial/index.html
API reference: https://klyn.deepcodia.fr/docs/api/index.html

I’m looking for technical feedback, constructive criticism, and suggestions for improvement.

Thanks in advance for your thoughts.

PS: I know there are already many great and performant languages out there, such as Rust, Go, and others, but I really want to give this idea a chance. So please don’t crush my hopes too much ;-)

I want to make my own programming language as a recreational programming exercise. I don't get much time other than weekends and have absolutely no experience of compiler development. I think learning and implementing deep advanced concepts of how they work under the hood would take so long for my purpose. llvm has steep learning curve, qbe doesn't seem to provide as strong optimization as llvm and lack support for some of the architectures.

Reason that most people don't write code in low level languages like C for web and app development choose modern languages instead because of memory management, difficult syntax, lack of modern programming paradigms, etc. but some of those languages suck too. like javascript itself is type unsafe and things break half the time. python use more memory and it's identation based syntax make formatting difficult. Even if I make a great syntax, learn llvm, implement standard library; it might still end up being a toy language and no one would be interested to use it.

Rather than optimizing the compiler for several platforms and maintaining large code base, I should make the coding part easier by utilizing third party libraries and compile the code into C file and let decades of optimisation which has been put into mature C compilers like gcc or clang do the heavy lifting. This way, developers get performance of C along with ease of modern languages. What are your thoughts on this? Is it a good idea?

This one took a while, it's probably the longest thing I've written on this blog. I wanted to do a proper end-to-end walkthrough of cmd/compile: real package names, real data structures, diagrams for the AST and SSA CFG, and the flags you actually need (-m, -m=2, GOSSAFUNC, -S) to observe each phase yourself rather than just take my word for it.

Covers the full pipeline: lexer → parser → type checker → IR lowering → SSA construction → optimization passes (inlining, escape analysis, BCE, nil check elimination, register allocation) → architecture-specific code emission.

Hope it's useful — happy to answer questions or push back on anything that looks wrong.

Hello everyone!
I was recently affected by layoffs at my last company. I have nearly 5 years of experience in Full-Stack Development, but my passion always have been compilers and programming language tools. My academic studies was strongly focused on this field and I saw the layoff as an opportunity to pivot my career.
However, it has been about 5 months now and I got 0 (zero) interviews. So I am wondering If I am chasing something unrealistic or doing something wrong that I cannot see. If anyone working on the field is willing to help, please send me a message to take a look at my resume / profile. I might doing something wrong that is obvious for you to see. Any feedback or advise would be more than welcome!
Have a nice day!

Hi everyone,

For the past few weeks, I've been working on a project that I think is pretty cool, and I wanted to share it with you guys. I call it "UNIT" ("Unified Native Instruction Translator"). Essentially, it's a combination of the instruction sets used in interpreted stack machines with actual machine code.

I wrote it in C, but I have bindings for C++ and Python, since C is pretty verbose. Here's an example in both of those:

unit::Context ctx;
unit::Procedure proc(ctx, "add");

proc.load_argument(0);
proc.load_argument(1);
proc.add();
proc.return_value();

proc.optimize();
auto compiled = proc.compile(unit::Platform::host());
auto add = compiled.jit<int64_t(*)(int64_t, int64_t)>();

printf("%ld\n", add(3, 4)); // 7

import unit

proc = unit.Procedure("add")

proc.load_argument(0)
proc.load_argument(1)
proc.add()
proc.return_value()

proc.optimize()
compiled = proc.compile()
add = compiled.jit()

print(add(3, 4))  # 7

So far, I've implemented a number of examples using my compiler. My personal favorite is the interpreted language with a JIT, which works fairly well and is just about 1k lines of Python.

I got the idea for this after working on Python's bytecode compiler (which emits instructions for Python's stack-based interpreter loop). I had also been experimenting with LLVM for a separate hobby project, and the difference between the two development experiences was huge. I wanted to combine the DX of stack machines with the ability to actually generate real machine code.

This is still early in development and not production-ready, as it only supports x86-64 on ELF right now with only some primitive optimizations, but I'd appreciate feedback on the API design, the IR, or anything else about the project. If you spot bugs, please feel free to let me know!

GitHub: https://github.com/ZeroIntensity/unit

Hi Folks!

I simply want to share this empirical study on the LLVM -O3 pipeline on the PolyBench suite.
I don't want to bore you with too many details that are already in the paper.
Any feedback is welcome :D

Blog post: https://federicobruzzone.github.io/posts/a-multi-dimensional-per-pass-empirical-study-of-the-llvm-optimization-pipeline.html
arXiv: https://arxiv.org/pdf/2606.31238

So, I decided to write a book on compiler theory! It is past midnight where I live so only 1 chapter is done. I have came here looking for some things that could be improved on it. The link is attached.

I've been working on a hobby programming language/compiler project for several months. AI has been a huge help during development—not by writing the project for me, but by acting as a brainstorming partner, reviewing architecture ideas, discussing trade-offs, and helping me iterate faster.

One of the ideas that came out of those discussions is a compiler architecture where the compiler kernel stays intentionally small. Instead of implementing the language directly in the compiler, things like the grammar, type system, semantic analysis, lowering, and optimizations are implemented as libraries.

The compiler mainly provides the infrastructure: parsing, AST, compile-time execution, diagnostics, and backend support.

The goal is to make language evolution happen by extending libraries instead of modifying compiler internals.

I'm curious what people with compiler or language design experience think about this approach. Does it sound like a reasonable architecture, or are there fundamental problems that would prevent it from scaling?

I'd really appreciate honest criticism. If this idea has already been explored by other projects or papers, I'd love to hear about them as well.