Hello, Dev.to community!
My name is Yash Arya. I am a 14-year-old student with a massive passion for computer science. Today, I want to humbly share a journey I recently started—one that is easily the most challenging and exciting thing I have ever attempted.
I am building my own low-level programming language from scratch. It is called Ion+.
When we first start coding, languages feel like magic. We type words into a screen, and the computer somehow just knows what to do. But recently, I started wondering: what actually happens under the hood? How does the text I write become a set of instructions that a machine can execute?
To find out, I decided the best way to learn was to build one myself.
The Architecture of Ion+
I wanted this project to bridge two worlds: the readability and developer-friendliness of Python, and the raw performance of low-level systems. Here is the architecture I chose for Ion+:
- The Frontend (Python): I am using Python to handle all the text processing. Python is beautiful for writing complex logic quickly, making it perfect for the Lexer and Parser stages.
- The Backend (LLVM): To give the language real power and speed, the ultimate goal is to pass the parsed code to an LLVM backend for optimization and machine code generation.
My Milestone: Conquering the Lexer
When I first opened an empty code file, I had no idea where to start. But I learned that the first step of a compiler is the Lexer (or tokenizer).
I am incredibly proud to say that the Lexer for Ion+ is completely finished!
Writing the Lexer taught me how to break raw source code down into a stream of meaningful tokens. It forced me to think about edge cases, string literals, and how a computer distinguishes between a keyword, an operator, and a variable name. Getting that code to successfully output a clean list of tokens was one of the best feelings I’ve had in programming.
The Current Challenge: Hitting the "Parser" Wall
I want to be completely honest about where the project is right now. I have reached the parsing stage—attempting to turn those tokens into an Abstract Syntax Tree (AST) using Recursive Descent.
It is incredibly intimidating. Looking at the logic required to handle operator precedence and tree structures feels like staring at a massive brick wall. For the first time in this project, I realized I had reached the limits of what I currently know.
I decided to take a step back and breathe. But I am not giving up. I am taking this time to study, to reach out to the community, and to learn how compiler engineers tackle this exact problem.
A Humble Request for Community Wisdom
I am building Ion+ completely open-source under the MIT license.
I have pushed this project as far as I can on my own, but to get over this next wall, I would love the guidance of developers who have walked this path before me.
Here is the repository: YashAryaPersonal/ion-plus
And a Minimal Web which may develop as documentation for it in future: ion-plus-preview.onrender.com
If you are a compiler enthusiast, a Python developer, or just someone who loves supporting open-source side projects, I would be deeply honored if you took a look.
- If you have advice on structuring an AST, please drop it in the comments.
- If you want to contribute, open a pull request!
- And if you just want to support a young developer trying to build something cool, a star on the repo would mean the world to me.
I have so much respect for the developers on this platform, and I cannot wait to learn from all of you. Thank you for reading my story, and I will be sure to post updates as Ion+ continues to grow!
Top comments (0)