Folks! Is this acceptable performance for a compiler? it do lexing, parsing, type checking, optimziing and codegen . It simply emits the ELF64 executable directly and runs it without an external linker/object-file pipeline.
--- CODEGEN RESULTS ---
Total Machine Bytes Emitted: 47 bytes
Compilation Speed: 76000 ns
Runnable ELF64 Machine Code Executable Written: boo
I've just finished adding multi-target compilation to my language, and it actually works. Incremental compilation currently halts before the code generation stage, which is intentional and I have no plans to change that.
Currently, the compiler can target x86-64, ARM64, and RISC-V from the same frontend.Raw machine code and assembly.
Are there any common pitfalls or edge cases I should be aware of as I wrap up the backend?
Everything is handwritten—I'm not using LLVM or any other compiler framework. I started by writing raw machine code in Notepad, built an assembler from that, then ported everything to Linux. I'm in the final stage now, and if everything goes according to plan, I should have a demo ready in about 1–2 months.
Hi folks! I’m currently porting my systems language from my own OS environment to Linux/macOS and realized I may be missing important low-level intrinsics or builtin expectations across platforms.
What do modern systems-language users and compiler backends typically expect to exist natively?
Hey folks, old retired systems dev here (spent a good chunk of my life at a major tech company you definitely know, now mostly hacking on pet projects in my downtime). I've been watching the "modern" PL scene, and frankly, everything old is new again. All these shiny new languages just feel like extensions of old ideas. Rust took a lot of cues from Cyclone's region-based memory management, and now we're chasing the next shiny thing. But it got me thinking about the exact flavor of developer masochism we prefer these days. What do you think is genuinely worse to write code in? The Borrow Checker: Fighting it every single second, playing 4D chess with lifetimes and ownership just to copy a piece of data. Linear Types & Capabilities: Where the compiler demands an explicit proof of every single state transition, capability, or resource destruction, every second of the day. Personally, it's driving me crazy enough that I plan to spend the rest of my life trying to solve this exact paradigm friction. But until I do... which poison are you picking? Discuss