Ion+: An experimental low-level language with indentation scoping written in Python (Seeking feedback on AST & frontend design)

Yash Arya — Thu, 17 Sep 2026 11:23:30 +0000

Hi everyone,

I've been working on a compiler hobby project called Ion+. The project explores combining low-level systems programming concepts (typed variables, manual memory handling, hardware-level control) with a clean, indentation-based syntax.

The entire compiler frontend is written from scratch in Python to keep the pipeline clear, modular, and accessible before targeting an LLVM backend.

What the Syntax Looks Like

struct Node:
   int node_id
   ptr char ip_address
   bool is_active
   byte latency

const unsigned int MAX_RETRIES = 5

alloc ptr buffer = addr MAX_RETRIES

?int Node.connect():
    if not network_ready:
        return none

    int attempts = 0
    while attempts < MAX_RETRIES:
        if hardware.ping() == True:
            return 1
        attempts += 1
    return 0

Current Pipeline & Implementation

The compiler frontend currently covers stages 1 through 4:

Lexing & Scanning: Regex-based tokenizer identifying keywords, types (int, byte, ptr, none), modifiers (const, volatile, atomic, alloc), operators, and literals.
Indentation Handling: Post-lexer stream processor that tracks indentation depth and automatically injects explicit INDENT and DEDENT tokens for block boundaries.
AST Construction: Explicit node definitions (nodes.py) representing program structures, typed variable declarations, member/call expressions, conditionals, and loops.
Parser: Recursive descent parser (core_parser.py) converting token streams into a structured AST ready for semantic analysis.

What You Can Test Right Now

Parsing source files directly using the .ionx extension.
Inspecting token streams and generated AST structures via main.py.
Experimenting with typed variable declarations, structs, and control-flow blocks.

Looking for Contributors & Feedback

Ion+ is open source and licensed under the MIT License.

Contributions, feedback, and discussions are welcome across multiple areas:

Improving parser rules and grammar edge-case handling.
Expanding AST node definitions.
Planning symbol tables, type checking, and semantic validation passes.
Preparing the foundation for LLVM IR code generation.
Writing test cases and improving documentation.
Repository: https://github.com/YashAryaPersonal/ion-plus
Web Preview: https://ion-plus-preview.onrender.com/
License: MIT

Feel free to check out the repository, try the code, open issues, or share your thoughts!

Why I Decided to Build My Own Programming Language at 14 (And What I've Learned So Far)

Yash Arya — Sat, 05 Sep 2026 13:38:12 +0000

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!

DEV Community: Yash Arya