By
@arpitaanuna
Blink is a programming language built entirely from scratch in Python. It features a custom lexer, recursive descent parser, abstract syntax tree (AST), and interpreter, along with support for variables, arithmetic, user input, conditionals, loops, and logical operators. Designed as an educational project, Blink makes it easy to explore how programming languages work internally.
**Blink — A Beginner-Friendly Programming Language Built From Scratch**
Blink is a custom programming language designed and developed from scratch to explore the fundamentals of how programming languages work. It provides a simple, readable syntax while implementing the core components of a real language, including lexical analysis, parsing, abstract syntax trees (AST), and interpretation.
The goal behind Blink is to make programming language concepts easier to understand by creating a *lightweight language* where users can write code using intuitive commands and learn how instructions are processed internally.
#Programming Features
- Blink currently supports:
Variables and assignments
Mathematical expressions
String handling
Conditional logic
Logical operators (and, or)
Repetition using loops (repeat, while)
Output commands
#Current Status
Blink v0.1 is the first version, featuring the core language architecture, execution engine, and essential programming constructs. Future versions aim to introduce more advanced features and continue improving.
1h 20m 56s logged
# Devlog 6 — Today’s Progress
Today was a major development day for Blink! I worked on expanding the language features and making Blink easier to install and use.
-Added New Language Features
-Added support for logical operators: and or -Implemented while loops, allowing Blink programs to perform repeated execution based on conditions.
Added Installation Support.
Users can now install Blink directly from GitHub:
pip install git+https://github.com/arpitaa31/Blink.git
After building the core features, improving the structure, and testing the workflow, I am now shipping Blink v0.1 — the first official version of my programming language. I will still keep working over it and add more features to this programming language.
2h 18m 9s logged
#Devlog 5
Today was another huge milestone for Blink! The language is starting to feel much more like an actual programming language now.
Added support for numbers in Blink. Improved the interpreter to handle numerical values instead of only strings.
Made arithmetic operations work successfully, including expressions using operators like +, -, *, and /. Improved BinaryOperationNode so Blink can create and process proper expression trees.
Spent a lot of time testing and debugging how these new features interact with the existing lexer, parser, AST, and interpreter, yesterday as well. Understanding how every feature needs support from multiple parts of the language made the process much clearer.
A few challenges I faced:
Blink can now:
-Print outputs using say
-Store and use values
-Perform calculations
-Take user input
-Make decisions using conditions
-Repeat instructions using loops
Next, I want to focus on improving error handling, adding more features, and eventually creating a playground where anyone can write and run Blink code.
56m 51s logged
#Devlog 4
Today’s session was probably one of the biggest milestones so far!
-Added support for the say statement in Blink.
-Built a SayNode in the AST.
-Updated the interpreter so it can actually execute say statements.
Spent some time understanding how the whole project flows, which made everything much clearer.
Started working on arithmetic expressions.
Created a new BinaryOperationNode for expression trees. Added a parse_expression() function that can understand expressions like 10 + 20.
The parser can now understand arithmetic expressions, and next session I’ll make the interpreter actually calculate them.
In short i worked on the interpreter today!
Successfully made Blink print - “Arpitaa”:
43m 15s logged
Devlog #3
Today’s session was mostly about moving Blink from just reading code to actually understanding it.
What I worked on:
-Finished setting up the Parser for Blink.
-Created the basic AST (Abstract Syntax Tree) nodes:
-Connected the Lexer and Parser together.
So,
Made Blink recognize simple assignment statements like:
name = “Arpitaa”
And successfully generated Blink’s first AST (Abstract Syntax Tree which is a tree-like structure created by the parser that represents the meaning and structure of a program.) , which means the language can now understand the structure of code instead of just reading characters.
Challenges faced:
Spent some time debugging Python indentation errors.
Accidentally mixed up code between parser.py and ast_nodes.py, so I reorganized the project files properly.
Now next, I have to build the Interpreter, so Blink can actually execute code. The code i ran and the results i got on executing the code today :
22m 43s logged
#Devlog 2 Hi! So, basically i mainly continued working on the lexer. The best part of today was finally running Blink. Blink was able to read it and print tokens for variables, strings, operators and keywords one by one. Seein my own programming lang successfully read a source file! Today’s work made me understand that the lexer doesn’t execute the program. Its only job is to read the code and break it into meaningful pieces that the next stage can understand. Anddd now i have will start working on building the Parser. After running a code, i was able to see this:
41m 2s logged
Devlog 1 Today I finally started working on Blink, my own programming language. I had no idea how programming languages actually worked, so I first learned the basic flow. I worked on the Token system. Basically, Blink now knows the different types of things it can see, like strings, variables, keywords etc. I also made a Token class that stores those values. After that, I started working on the lexer. Rn, it can move through the code one character at a time, skip spaces, read strings, and identify blink’s keywords.
