Pine Compiler: Statically Typed Language and LLVM-IR Generation

I wanted to understand how programming languages actually work. So I built one. Nova is a statically-typed language I wrote from scratch in C++17. Not just a parser or a toy interpreter, a complete toolchain: The compiler has a lexer, parser, semantic analyzer, multi-pass optimizer, and code generator. It targets three backends: a stack-based bytecode VM, a JIT compiler that emits x86-64 machine code, and an LLVM IR generator. The language supports generics with monomorphization, traits with bounded generics, enums, pattern matching, first-class functions, closures, and a module system. Memory is managed by a mark-and-sweep garbage collector. But I didn't stop at the compiler. I built a step-through debugger, an LSP server for VS Code with diagnostics, hover, go-to-definition, and autocomplete, and published it as a VS Code extension on the marketplace. Then I compiled the whole thing to WebAssembly so anyone can try it in the browser. 196 tests. Zero external dependencies. Everything from scratch. Try it: https://lnkd.in/dMYy9jFA Code: https://lnkd.in/dCss3vb4 Extension: https://lnkd.in/dMnsXSPf #programming #compilers #cpp #webassembly #computerscience #softwareengineering

ATLAS v0.1 — Released I’ve released ATLAS v0.1, a correctness-first programming language for modeling explicit state machines. ATLAS enforces correctness before execution through a strict AST-based compiler: exactly one explicit initial state explicit state declarations explicit transitions explicit termination full reachability validation If an ATLAS program runs, its structure has already been proven valid. ATLAS is not a general-purpose language. It is a deliberately constrained language for modeling systems with explicit state, transition, and termination. The architecture and semantics of v0.1 are locked. Only bug fixes are allowed. Any new capability will target v0.2 or later. Source (Apache 2.0): 👉 https://lnkd.in/g_eprVF2 ATLAS models reality through explicit state, transition, and termination — nothing more, nothing less.

Creating a new programming language completely from scratch, in just two weeks. About a year ago, I had an idea for a programming language called Stride. It sat on the shelf for a while, but about 2 weeks ago, I finally regained the motivation to see if I could actually make it work (again...). I started typing, and sooner or later, I had a working prototype. Stride is currently JIT-compiled using the LLVM compiler toolchain. By leveraging LLVM’s optimization passes, the current implementation is already performing significantly faster than I expected for an early-stage project. Beyond the compiler itself, I also built a web-based editor with syntax highlighting. I’ve always felt that the environment where you write code is just as important as the code itself, so I wanted to make sure the "feel" of the language was right from the start. This project has been a deep dive into the internals of compilers and low-level architecture. It’s still early, but the foundation is there. If you’re interested in compilers or C++, or just improving the language cause you think it looks cool, feel free to have a look, leave a suggestion, or even open a PR. You can find the repository here: https://lnkd.in/ekjCJTA8

🦾 Pine’s New Import System — A Major Milestone in My Programming Language Journey Today feels special. I just implemented a full module import system in Pine, the programming language I’ve been designing and building from scratch. This feature unlocks something huge: Pine is no longer limited to single-file scripts — it now supports modular, scalable programs. Here’s a quick look at the new syntax: use io use math use local use "github.com/aavtic/std" fn main() { let x = 10 let a = square(x) print(local_greeting()) return a } What’s new? • Import standard library modules • Import local project files • Foundation for a future package ecosystem Designing this pushed me deep into: – Module resolution systems – Dependency graphs – Compiler symbol tables There’s still a long roadmap ahead (exports, versioning, package manager, caching, etc.), but this milestone makes Pine feel truly scalable. Building a language teaches you to recognize your own limitations, approach problems methodically, and stay patient through complex challenges — but milestones like this make it incredibly rewarding. Excited to keep pushing Pine forward 🌲 https://lnkd.in/gpPppbXG #ProgrammingLanguages #Compilers #SystemsProgramming #OpenSource #LanguageDesign #DeveloperJourney

I had fun reading the Anthropic blog post about building a C compiler with Opus 4.6. I was interested in how they set up their project (including how they coordinate their agents), along with how they described their outcomes. I think they could have hyped up the project a bit more, and I appreciated that they called out the myriad of limitations they had in attempting this. > The generated code is not very efficient. Even with all optimizations enabled, it outputs less efficient code than GCC with all optimizations disabled. I already have a ton of examples of this in my own projects, and I'm curious about how they're going to address this. There's so much contextless 'magic' encoded into production software. How will these LLMs find these hidden local minima that represent the 'one true path'? Especially considering the quantity of human slop we've generated over the past 80 years 😅 Original post: https://lnkd.in/gR_smeQV HN thread: https://lnkd.in/g5zirWWP

Read the Anthropic blog where they just had 16 Claude agents autonomously build a C compiler in Rust. 100,000 lines of code. Compiles the Linux kernel. $20,000 in API costs. Two weeks. I have some criticism around the narrative here Firstly, the innovation here is genuinely remarkable This isn't Claude Code sub-agents being orchestrated top-down. It's a swarm of agents working toward a shared plan with context communication, task locking via git, and self-directed parallel problem solving. This is a fundamentally different paradigm for long-running autonomous work. Co incidentally at R Systems , many of our Optima AI autonomous programming agents were already built using Claude Code + Claude Flow (https://lnkd.in/gDD4v822) for exactly this kind of long-running multi-agent orchestration even before Agent Teams existed. So this resonates deeply with what we've been seeing in production. BUT here's where the narrative gets a little ahead of itself. "From scratch" is doing a lot of heavy lifting in the headline. When the agents got stuck compiling the Linux kernel, they used GCC as an oracle, compiling most files with GCC and only testing a subset with Claude's compiler. The compiler itself still calls out to GCC for 16-bit x86 boot code. It relies on GCC headers. The assembler and linker are buggy. The generated code is less efficient than GCC with all optimizations turned off. As the community on Reddit pointed out: GCC was essentially the source of truth the agents were converging toward. That's less "building from scratch" and more "building with an answer key" None of this diminishes the technical achievement. Agent teams + long-running orchestration + parallel autonomous work is a massive unlock The scaffolding, the test harnesses, the swarm coordination — all genuinely impressive engineering. But the framing matters Or as Carl Sagan might say if he were reviewing pull requests: "If you wish to build a compiler from scratch, you must first invent the universe." And in this case, the universe was GCC. #AgenticAI #AI #SoftwareEngineering #Compilers #Anthropic #Claude

Building on my recent tutorial on compiler construction ( link in the comments), I am sharing a deep dive into one of the most critical components of a language runtime: the Garbage Collector (GC). In my previous guide, "Building a Compiler with Rust and LLVM," we integrated the compiler with the Boehm GC to handle memory management. While using an established library is practical for a Proof of Concept , understanding how to build a GC from scratch is essential for anyone interested in the internal mechanics of programming languages and formal systems. This exposition moves from theoretical concepts to the practical implementation details of a tracing collector. Whether you are a systems researcher or a curious developer, mastering these fundamentals provides a clearer perspective on how modern managed languages operate at scale. Resources You can find the full exposition and the original compiler tutorial at the links below: GC Deep Dive : https://lnkd.in/dcf-FdqR Nirmalya Sengupta Rajat Singhal Pradeep Ck Sanjeev Asher Ashok Hegde Vsrv Raghavan #Rust #LLVM #CompilerDesign #ComputerScience #GarbageCollection #SystemsProgramming #ProgrammingLanguages #SoftwareArchitecture

Today I published the first release of something I've been brewing for quite a while: Incan, a programming language. Incan is statically typed with Python-like syntax, and it compiles to Rust. The goal is to bridge the gap between "I want to write something quickly" and "I want it to be fast, safe, and maintainable." When you write Incan, you get: - Python's readability - models, classes, f-strings, list comprehensions - Rust's guarantees - no runtime, no GC, real type safety - A real toolchain - CLI, formatter, language server, test runner v0.1.0 is the first published release. It covers the core language, a trait/derive system, web framework support with typed extractors, and a full documentation site built with MkDocs. It's a 0.x release - there's plenty left to build. But shipping a first version is a milestone I wanted to mark. If you're curious about language design, compilers, or the Python-to-Rust pipeline, I'd love for you to take a look. Docs: https://incan.io/v0.1/ GitHub: https://lnkd.in/e3D7xYFr And if you're wondering: "Danny, why on earth did you create a new programming language?" - let's have a conversation 😇 I have been able to get Incan to be 100's of times faster than Python - it compiles to native Rust, so that's no GIL, no interpreter overhead, and real multithreading out of the box. #programming #rust #python #opensource #compilers #languagedesign #incan

🚀 Day 6/30: Strings – Why "Immutable" is a Feature, Not a Bug! 🧵 In most programming languages, Strings are more than just arrays of characters. They have a special property that often surprises new developers: Immutability. Today, I'm diving into why this exists and how we handle it. 📍 What is Immutability? It means once a string is created in memory, it cannot be changed. If you try to capitalize a word or append a character, the computer doesn't "edit" the old string; it creates a brand new one and points your variable to it. 📍 Why make them immutable? Memory Efficiency (String Pooling): If ten variables all store the word "Hello," the computer only stores "Hello" once in a "Pool" to save RAM. This only works if the value is guaranteed not to change. Security: Strings are used for sensitive data like passwords, file paths, and URLs. If strings were mutable, an attacker could potentially change the value while the program is using it. Thread Safety: Since they can't change, multiple parts of a program can read them simultaneously without errors. 📍 How to manipulate them efficiently? Because creating a new string every time is "expensive" for the CPU, we use specialized tools: StringBuilder / StringBuffer: These allow us to "build" a string by modifying a mutable buffer before converting the final result into an immutable string. Slicing: Efficiently grabbing parts of a string without copying the whole thing. 💡 The Big Lesson: Understanding that strings are immutable helps you write code that doesn't waste memory. When you're joining thousands of strings together, stop using + and start using a Join or Builder pattern! #DSA #30DaysOfCode #ComputerScience #SoftwareEngineering #Coding #Strings #MemoryManagement #ProgrammingTips #TechEducation #BigO

Need to quickly understand a programming language's syntax?  Learn X in Y Minutes is a community-driven platform with 200+ programming language and tool cheat sheets.  Each guide is heavily commented, executable code designed for rapid learning - perfect for syntax refreshers or getting started with a new language. Want to quickly grab idea of Ansible playbooks? Understand Lua for ngx_http_lua_module? Get a grasp of Elixir, Zig or Rust? It's all there. Not a replacement for deep learning, but perfect for quick starts and refreshers. Check it out: https://lnkd.in/g4GNhich Direct links:  • Ansible: https://lnkd.in/gJQbHbcn  • Lua: https://lnkd.in/g8K6tNBr  • Elixir: https://lnkd.in/g84ibCef  • Zig: https://lnkd.in/gDV2CERh  • Rust: https://lnkd.in/gPddNuTV  #programming #learning #devtools #ansible #lua #elixir #zig #rust