Julio Zenelaj

[Bachelor's thesis project] MPI is a commonly used standard for programming collective communication algorithms in distributed computing. However, designing collective communication algorithms natively requires expertise and significant attention to implementation details, and might potentially lead to erroneous algorithms and unsafe programs.

Thus, our goal was to implement a way to enable users to focus on the design of algorithms instead of implementation details. Microsoft's MSCCL++ already does that for NVIDIA's NCCL standard, so we decided to keep the same simple Python frontend and create an interpreter that runs on MPI. This project required making a modular and abstract system that can interpret any algorithm, while being efficient. It required a lot of iteration in order to simplify the implementation as much as possible and make it compact and efficient.

In the end, the resulting interpreter was not only able to run any algorithm generated by MSCCL++, but we also added some optimization options for considerably better runtime. Our goal was to get to the same runtime as native OpenMPI. Often we were able to outdo it, and optimizations offer multiplicative scale speedup. But the base case still had some overhead which, in the end, we did not have enough time to find and optimize.

This was the project of the Multicore Programming course. Given a linear algorithm for finding DNA subsequences in a long DNA string, the task was the implementation of a multithreaded version in 3 different multicore programming models: local multithreading using OpenMPI, distributed computing using MPI, and GPU multithreading using CUDA.

Through this course and this project I learned how substantial it is to think of programming in terms of data layout and organization and how important it is to take as much advantage as possible of the memory cache, and specific hardware in general, in order to achieve good efficiency.

This project was implemented in one week as part of a test for a job application. The goal of this task was the creation of a graph node editor tool using Unity's UI Toolkit. The types of nodes are: Single Node, which has a text input field and one output and Binary Node which has two outputs. There is one root node(denoted with a star in the video). Nodes can be moved around but holding a button should move all nodes directly connected to the given node. Nodes can be added and deleted. In addition, the layout of a graph should be saved to and loaded from a JSON file.

The challenge of this task relied in making use of Unity's UI Toolkit, which was relatively new at the time, and using its API to fulfill the task. It is a decievingly complicated task as it requires the interaction of many elements which might not be obvious at first, however the result functions well and offers an appealing UI. In hindsight, as I was too used to OOP and Unity's programming mindset, there was more coupling of elements than necessary as connection data was held on the nodes but a global tree representation would have probably been a better and simpler approach.

Reaction Diffusion is the simulation of the process of diffusion, which in nature can be found in many forms such as heat diffusion, pressure diffusion, chemical components diffusion etc. This implementation is a shader that simulates the Diffusion Equations. The goal of this simulation is the procedural generation of organic-looking patterns.
Further reading on the algorithm: http://karlsims.com/rd.html

This project was a challenge on 3 different levels: new programming language, new game engine, new algorithm. After hearing a lot of buzz about it, I decided to learn Rust. I used the official book and once I was done with the basics, I decided to try making a real program in it.
At the time, the Wave Function Collapse algorithm had caught my attention as a method for procedurally making interesting and dynamic content (in this case, map generation).
Finally, Bevy is the most popular Rust game engine and it uses an ECS system, which is a data-driven design approach to game development.

As a result of all these factors, implementing WFC in Bevy turned out to be very interesting, and I especially enjoyed the ECS approach to programming, even though at the time I attributed this new programming mentality to Rust. I did find Rust's forced styling bothersome but now I appreciate this design is a result of their focus on programming safety.

In this project I tried to replicate some of the stylized rendering effects of the Spider-Punk character from the animated motion picture "Spider-Man: Across the Spider-Verse", using the Unity engine. The artistic effects present in this movie, as well as its predecessor have me in awe every time I watch them, which is why I tried to emulate one of them in order to try to understand better how it is achieved.

At the time I was not aware of how stylized rendering works so this project helped me learn about the rendering pipeline and how to create custom rendering effects/passes along this pipeline. It was both a technical and artistic challenge which made me appreaciate even more the work that goes into making these high quality animated movies.

A ray tracer made in C++ following the Cherno's RayTracing tutorial series. Features: sphere rendering, emissive materials, diffuse and specular reflections.
This project was an introduction to basic ray tracing techniques such as primitive generation, materials, reflections. Unfortunately, the series did not go on so this project was prematurely abandoned.

The goal of this project was the replication of the procedural level generation of the Spelunky game by Derek Yu. I chose to work on this project in order to get introduced to procedural generation techniques and to challenge myself to implement such a system on my own.
The way in which this system works is by laying out rooms in a 4x4 level, ensuring a path from start to exit exists. Many of the rooms have modular pieces which add variety to the generation. Then, traps and treasure is generated based on predefined constraints and fixed probabilities. Finally, enemies are placed accordingly.
Despite its simplicity, this system succeeds in generating new and interesting levels each time, indicating a solid original design.

This was my first full project using the Unity Game Engine and the C# programming language. It is a simple replication of the FIFA Mobile game menu navigation and interaction. Making a clone of (part) of my favourite game at the time was very motivating and helped me get accostumed to both the Unity game engine and to programming an actual project (rather than small exercises). The hands-on experience was very helpful in solidifying my Object-Oriented Programming fundamentals, as well as forced me to consider project organisation and management.

Simple game made in 3 days for the GMTK Game Jam 2024.

A challenge to implement one game mechanic every day for a week. In the end, this turned out to be a good collection of programming exercises as I implemented some common game mechanics which I had not tried before, without any tutorial and in one day (in reality 2-4 hours).
The mechanics are: Cards Drag & Drop, Topdown Shooter Controller, Dialogue System, Inventory System, Quest System and Enemy State Machine.

Project of the Programming 2 course. A multi-threaded, Java-based simulation of a blockchain network system, based on the Bitcoin whitepaper.
This system consists of several user nodes and miner nodes. Each node has a balance and can add new transactions to the transaction queue. Miners, then, validate a set of transactions from the queue and create a new block which is added to the blockchain. Each miner works in parallel on a separate thread. A live visualisation of the system is available.

A simple platforming, gravity-manipulation game made in the Unity Game Engine and using the C# language.