3D renderer with turtle (GitHub)

May, 2020

As the pandemic set in and almost every country went into lockdown, I got to stay at home more often. That's when I discovered Discord servers (and that is also when The Coding Train made one). That is where I met a lot of very cool people who I still talk to today. One of those cool peeps was Simon, with whom I worked on this project.

This small python program takes in a 3D model as a simple OBJ file and uses pythons turtle graphics to render it edge-by-edge.

As you can see in the GIF, it also has some controls implemented with Tkinter.

It's funny to me now that the run.py and saferun.py are basic shell commands run through Python's os package

import os
os.system('python src')

import os
os.system('cls')
os.system('start run.py')

I clearly didn't know that .sh/.bat files existed and I was still using Windows.

turing-assembly (GitHub)

May, 2020

After learning about assembly, I thought to myself, how fun would it be if I were to write my own interpreter for a custom instruction set. So I did it.

The instruction set, as expected from a 15-year-old with practically no understanding of computer architecture, was very simple but still turing complete (hence the name). There was only one register, a program counter and 256 words of memory. The coolest thing about it was that I clearly struggled with jumps (I didn't implement labels for some reason) so I had to implement both relative and absolute jumps to make writing using this instruction set easier. I also implemented I/O as by having a print instruction and having special registers TERMINAL_WIDTH and TERMINAL_HEIGHT.

Just the interpreter of an instruction set is nothing cool to see so I also wrote a couple test programs. One was a renderer of the mandelbrot set

Simple Raytracer (GitHub)

September, 2020

If you've seen Sebastian Lague's video, then you must have also wanted to implement a simple raytracer. I did it. It was fun.

wave-function-collapse-p5 (GitHub)

October-December, 2020

Probably the coolest computer graphics/game dev things I've seen all come from Oskar Stålberg. Both of his major releases (Bad North Townscaper), his talks (1, 2, 3), and posts. Most of it is about the Wave Function Collapse algorithm.

Me and my friend Max got interested and implemented Gumin's version in p5.js. And that is before The Coding Train did a coding challenge about it!

rocket-sim (GitHub)

January, 2021

After seeing the absolutely awestriking footage of huge rockets landing on barges and on landing sites, I've had a drive to build something similar. Due to my limited exposure to the hardware side of engineering, it was only natural for me to find ways of doing it all in software.

In the winter of 2021, I set to implement a simple, just one dimensional version of what to my mind is one of the coolest videos depicting human ingenuity SpaceX's Grasshopper, Starhopper and early starship flight tests.

The goal was simple: have a model of a rocket, with parameteres (engine thrust, vihicle wet/dry weight) estimated from the publically available data, obeying neutonian physics and a control system that would take the rocket to hover and then safely land it back on the ground.

I started building this simulation without having any knowledge of control systems. I didn't really know they were a thing, even. This ignorance led me to reinvent the PD control scheme (PID controller but with $P_I=0$) for maintaining hover. After some time, I started researching different control schemes for such a task and learned about the classical and elegant PID controller.

After fiddling with the simulation and looking at the number in the terminal, it came time to visualize the results. Even though I had quite a lot of experience with p5.js by this point, I chose to create a static visualization for this project (which, in hindsight, was nicer for presenting it in this format).

These graphs all depict different variables of a single flight. I still feel happy looking at this image :)

The fun in doing this project was amplified by the fact that I did it with a friend Max

Cxrili (Website)

February-May, 2021

In the 11th grade, the frustration caused by poor management of teachers and everchanging class schedule has one solution that I could be a part of — a centralized calendar system for the whole school. You might say "yes, CalDAV exists basically for just that" and you'd be right, but I had no idea it did at that time.

So I did what was only natural — I built a calendar app for my class. I used some proprietary services to add an account system and then the ability to make comments on each period with the purpose of sharing what we had for homework. And centralization meant that if the schedule were to change, I would update it and everyone would have the most recent version immediately.

At some point, about 4 of my 25 classmates were using the app, which was about as much as I could ask for in retrospect. However, as they say "it's the journey, not the destination". I have a very fun memory of finding a critical bug at school and fixing it from my phone and using GitHub web editor.

Math explainer with Manim (GitHub)

November, 2021

When I learned that the author of my favorite mathematics related Youtube channel, 3Blue1Brown, had made a python library which he uses for creating the videos, I took a deep dive and made a video of my own.

Tunable Rocket Landing Simulation (GitHub)

November-December, 2021

Later in 2021, inspired by Thomas Godden's article about Starship Landing Trajectory Optimization which was in turn (as the title says) based on SpaceX's Starship test flights, I set out to implement a two dimensional version of my one dimensional rocket simulation.

Thomas Godden's article was my introduction to the idea of mathematical optimization. Even though this project doesn't use any of the technics that optimization theory studies, my awareness of the whole field later enforced my motivation to go to KIU.

The secondary goal of this project was to make it tunable, so that you could input parameters (rocket size, weight, starting position, ...) and the simulation would just calculate the flight trajectory that would safely land your rocket.

I had already been familiar with the beautifuly simple API of olc::PixelGameEngine and therefore I knew my way around C++. To spice things up a bit, I wanted to learn something new, so I went with Raylib.

What I ended up implementing is a simple Model Predictive Control scheme without konwing it. The idea is simple:

1. Simulate every possible sequence of controls for some $n$ steps,
2. score each possible outcome based on a cost function,
3. and then pick the first action from the sequence of actions which had the best score.

A traditional MPC scheme would use a clever optimization algorithm which doesn't require exhaustive, brute-force simulation of all possible outcomes.

Enveloper (GitHub)

December, 2021

As 2022 was approaching, I made a collage of pictures of key moments of the year as new year's gifts for my friends. To wrap it, I wanted to put my coding skills to use and make something cool. So I made this small tool.

Enveloper uses two pictures and some parameters to create a printable page which when printed and cut out, folds into an envelope of predetermined size. You can Try it out here.

Newton Fractal Renderer (GitHub)

January, 2022

This simple multithreaded C++ program renders the Newton fractal, nothing special.

Linguistic tree renderer (GitHub)

October, 2022

In the first semester of my bachelors, I had to draw a derivation tree of a couple lines of code. I didn't want to do it by hand so I tried using LaTeX, but it didn't do for me so I wrote a renderer of my own. I would give it the tree in a simple format and it would produce a PNG.

Input	Output
[ This-is-a-tree [ A-child-node [ Leaf ] ] [ Leaf ] ]

Repr (GitHub)

May, 2025

One day, when chatting with my friend Ischa, We came up with this fun piece of mathematics. After a long discussion, we finally landed on a question: what is the minimual subset of natural numbers can you take to be able to express any natural number greater than 1 with writing $a$ in base $b$ and reading it in base $c$. Where $a$, $b$, and $c$ are from the set

Later that day, I decided to formalize the concepts and put all of our itty-bitty discoveries in one neat PDF.

Deep Reinforcement Learning in Rust (GitHub)

January, 2026

As a final project for the deep learning course at my uni, we had the freedom of choice as to what I would do. So I chose to build a small Deep Q-learning with Convolutional layers. I had a friend Giorgi Bakradze who was willing to do this as a group project. Then implemented the classic game of Pong as the environment where the model would train through self-play.