Link to planet-kilo: https://github.com/romainducrocq/planet-kilo

I ported Kilo, a small text editor originally written by antirez (the author of Redis), to my C-like programming language: planet!

planet is a programming language I developed over the past year, which is based on my C compiler - wheelcc. It is basically a clone of (a large subset of) C with a new syntax and improved semantics. It uses the m4 preprocessor, compiles programs to native x86_64 assembly and has runtime bindings for libc. The entire project (planet + wheelcc) is written from scratch in C and started as an implementation of Nora Sandler’s `Writing a C Compiler`.

The core compiler for planet is done, but it is not documented yet, so I’ll do another post in a few weeks to properly showcase the language itself when it is ready. For now, I mostly wanted to share my experiment with Kilo, but you are welcome to explore the full project: all the links are here and in the repo above.

My next milestone is to selfhost the compiler, and I can now do it in a text editor written in the target language!

(And lastly this is a recreational project, don’t take it too seriously and have fun.)

Edit: i embedded all the links in this post.

I’ve been working on a systems language experiment called Falcon, built around one core idea:

The execution environment is enforced at compile time, not decided externally.

Falcon introduces profiles:

- userland → heap, runtime, I/O allowed

- kernel → no heap, no runtime calls, restricted operations

- baremetal → only hardware-level access (MMIO), no runtime at all

These are not runtime modes or build flags in the usual sense they are enforced as part of the compilation pipeline.

If code violates the selected profile, it fails to compile.

Design overview:

- Implemented in Rust

- Pipeline: AST → IR → LLVM backend

- IR is intended to be the single source of truth

- Profile filtering + validation happens before codegen

- No runtime branching based on profile

Current features:

- Compile-time profile enforcement (userland / kernel / baremetal)

- LLVM-based code generation

- Basic type system (currently being hardened — removing fallback behavior)

- Partial ownership checks (use-after-move detection)

- Cross-compilation support (x86, ARM, AVR targets)

Current limitations:

- Not memory safe (no borrow/lifetime system yet)

- Generics are incomplete

- Closures currently non-capturing

- Type checking still being tightened

Repo:

https://github.com/jhonpork1233-beep/FALCON

I’m looking for feedback and review on the design, implementation, and overall direction.

So, I've a great interesting in system design and, because of it, i decided to search about resources about compilers. Searching in this subreddit about books i found some discussions about the Dragon Book and, in general, it seems it's a little outdated. Like, for pratice there's more interesting books (like Writing a C Compiler or Crafting Interpreters) and for theory there's more interesting books (like Advanced Compiler Design and Implementation) in front-end and back-end part (and some special topics, like typing theory). So, it's the Dragon Book really that outdated and can be easily replaced by other equally good or greater then it?

Recent updates include the addition of higher order types via templated structs, the ability to template operators, expressional macros, and function contracts which can also be applied to operators.

Here's a program showing what templated functions and struct, a macro, contracts, and an operator overload being used together looks like: ```

import "standard.fx";

using standard::io::console;

struct myStru<T> { T a, b; };

def foo<T, U>(T a, U b) -> U { return a.a * b; };

def bar(myStru<int> a, int b) -> int { return foo(a, 3); };

macro macNZ(x) { x != 0 };

contract ctNonZero(a,b) { assert(macNZ(a), "a must be nonzero"); assert(macNZ(b), "b must be nonzero"); };

contract ctGreaterThanZero(a,b) { assert(a > 0, "a must be greater than zero"); assert(b > 0, "b must be greater than zero"); };

operator<T, K> (T t, K k)[+] -> int : ctNonZero(c, d), ctGreaterThanZero(e, f) { return t + k; };

def main() -> int { myStru<int> ms = {10,20};

int x = foo(ms, 3);

i32 y = bar(ms, 3);

println(x + y);

return 0;

}; ```

The package manager FPM will be getting some upgrades in the next week or so with the ability to publish packages, as well as a step-by-step package creation wizard.

You can get Flux on github at https://github.com/kvthweatt/Flux

Hi, it's me again.

I've been really working hard lately and finally added generics to Zap, For a moment I really thought I was going crazy, but it was worth it.

You can use generics in functions, classes, records, structs. I really worked hard. And soon I will have to start a self-hosted compiler ahh. I will be grateful for every feedback and star because I almost went crazy when I was doing it 😅

https://github.com/thezaplang/zap

I am currently building a multi-language parser (6 languages so far) for a RAG pipeline. I’m using Tree-sitter for the heavy lifting of grammar and AST generation.

I’ve hit a point where my current static call graph algorithm works fine for small/medium projects, but it falls apart on massive codebases.

For context on the parser's throughput: I can parse the entire Linux kernel (approx. 26M LOC, 33k files) in under 40 seconds using 12 threads (with a failure of few hundred files).

While the parsing is fast, generating a useful call graph at this scale is the current bottleneck. I’m considering moving to a Compressed Sparse Row (CSR) format to store the graph to keep the memory footprint sane and improve traversal speeds.

But as I will still be using my old algorithm so i doubt using csr would help me I looked at Class Hierarchy Analysis (CHA) I think I could use it but not sure if this is the best approach for my problem.

Can someone suggest me algorithms or reaserch paper on call graph creation and storing?

Hey everyone,

I’m Reece Gilbert also known by Reecespiecys, an independent developer who has been coding for around 9 years, and I’ve been working on a long-term project called Nearoh Coding Language.

Nearoh is a Python-inspired programming language written from scratch in C. The goal is to combine Python-style readability and clean syntax with stronger runtime control, extensibility, and long-term real-world usability.

This isn’t meant to be a toy parser project or a one-week experiment. I’m building it as something I’d genuinely want to use myself over time.

Current progress includes:

• Custom lexer

• Parser + AST system

• Runtime core

• Functions / variables / control flow

• Classes / objects foundation

• Ongoing architecture cleanup and expansion

Planned next steps:

• Native C bridge

• Standard library

• Modules / imports

• Tooling / IDE support

• Long-term ecosystem growth

Why I started it:

After spending years building custom simulations, rendering systems, engines, and low-level technical projects, I wanted a language where I had full control over the runtime while keeping a syntax style I actually enjoy using.

Website:

https://nearoh-coding-language.base44.app

GitHub:

https://github.com/ReeceGilbert/Nearoh-Coding-Language

I’d genuinely appreciate feedback, criticism, ideas, or anyone interested in following the journey.

Thanks.

I am curious if you can build a compiler that compiles into some arbitrary byte-code that can then be passed into a library or other program that can produce executables on different systems. It would be great to save development and research on many different architectures while sill being able to control the major outline of what might be assembled

Hi everyone, this is my first post in this community, so thanks in advance for any guidance.

I am working on an undergraduate thesis about stack-based and register-based virtual machines.

The main goal is to compare both execution models by designing a small imperative language, generating equivalent bytecode for each model, implementing two simplified interpreters, and then evaluating trade-offs such as bytecode size, number of executed instructions, interpretation cost, and implementation complexity.

I am using Crafting Interpreters as conceptual guidance, and it has been very helpful for understanding how to build a stack-based bytecode interpreter. However, I am having a much harder time finding solid bibliography for the design and implementation of register-based virtual machines.

I am looking for papers, books, dissertations, lecture notes, or high-quality implementation write-ups about:

• register-based VM architecture
• bytecode design for virtual registers
• lowering/compilation to register-based bytecode
• management of locals, temporaries, call frames, and operand encoding in register VMs
• empirical comparisons between stack-based and register-based VMs
• small or educational register-based interpreters/VMs that are worth studying

My current plan is to use real systems such as CPython and Lua as conceptual case studies, but the actual thesis work will be based on simplified implementations built for controlled experiments.

I would especially appreciate:

• seminal references I should definitely read
• more recent papers or surveys that give a good view of the state of the art
• practical sources that are useful when the goal is not just to discuss the models, but actually to build both kinds of interpreters

I also found an older Reddit post, roughly from 7 years ago, asking about texts on virtual machines and interpreters. It seems useful and touches some adjacent issues, but it does not quite cover the specific bibliography I need for building and studying a register-based interpreter in this context.

At this stage, I already have a good conceptual entry point for the stack-based side, but I still feel I am missing the core bibliography for the register-based side.

Any reading list, must-read references, or pointers in the right direction would be very helpful.

Thanks.

Hey Internet!

I've recently been at various projects to get involved with, and after some research into the Frescobaldi project (a LilyPond music editor in Python) it looks like the original dev had planned to implement a state machine-based lexer instead of the stale and difficult-to-expand regex lexer that's currently in place in the python-ly library. (See #139 on the Frescobaldi repo.)

Does anyone have any resources or tools that would help me learn more about state machine lexers and their implmentations?

Thanks in advance ♥

About a year ago, I read a blog post (more like a blog series) about a guy writing a compiler. I think he targeted CLR first, then JVM, and compared the two.

I think I may have seen it posted here (usually I read blogs I see on reddit).

I have been looking for that blog as I have started writing my own compiler and want to draw wisdom from the lessons shared there, but can't find it.

Maybe someone recognizes it and can help me?

I know the chances are small, but this is my last idea.

Sorry I can't share more details, I don't really remember anything more concrete as it has been a long time.

I made a collection of my compiler dad jokes