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.
I’ve been working on turning Blink from a basic interpreter into a more complete and beginner-friendly programming language.
It can now perform many tasks that Python handles through functions and keywords—but using simple, English-like commands.
Here are the newest Blink commands and features:
-make, run, and give for creating and using custom functions
-list , add , remove , and ```length of```` for working with lists
-item … of, change item, has, and position of for accessing and updating list items
-for each for looping through every item in a list
-ask text and ask number for receiving typed user input
-{variable} text filling for placing values directly inside sentences
-stop loop and skip turn for controlling loops
-details, put … as … in, and "label" from details for storing labelled information
-uppercase of, lowercase of, trim, split … by, and join … with for working with text
-try and if error for handling problems without crashing the program
-also added and improved Blink’s command-line tools
And a few moreee commands - it was fun making those!!!
Blink now also provides clearer error messages with filenames, line numbers, helpful hints, and spelling suggestions such as:
Did you mean “say”?
Blink is now much closer to being a properly usable programming language—while still keeping its main idea intact- making coding feel like simple English.
Also i have added few more example programs!
I will still continue working over this even more to polish it!
# 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.
#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.
#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”:
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 :
#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:
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.
