The game turns the Uranium-238 decay chain into a roguelike survival journey. Players master mechanics inspired by alpha and beta decay while protecting each isotope long enough to progress toward a stable state.

• Gameplay inspired by real radioactive decay paths and isotopic equilibrium.
• A global online leaderboard for comparing final decay scores.
• A focused sci-fi presentation with atmospheric visuals and sound.
• Released for Windows and created with Godot.

Build and study reproducible PPO policies for quadruped locomotion in Isaac Lab, including rough-terrain traversal, disturbance recovery, controlled gait evaluation, and robustness beyond nominal training conditions.

• Direct Isaac Lab environments with velocity tracking, terrain curricula, external pushes, and interactive keyboard control.
• Nominal, domain-randomized, and held-out physics configurations for robustness studies.
• Phase-conditioned gait experiments with controlled foot-contact evaluation.
• Paired policy comparisons with experiment data and bootstrap confidence intervals.
• Selected checkpoints, exported policies, evaluation reports, and reproducible training tools.

Develop a bounded real-time autonomy pipeline that converts sparse range measurements into safe acceleration commands while navigating a dynamic game environment through ROS 2.

• Rolling local occupancy grid with deterministic laser-ray integration.
• Exact Euclidean distance field and conservative obstacle inflation.
• Receding-horizon CEM-MPC with warm starts and hard collision checks.
• Bounded planning budget for 30 Hz control.
• RViz visualization, unit tests, benchmarks, and reproducible objective-weight experiments.

The goal was to create a complete end-to-end IoT system for voice notifications. Use the mobile app to record 1-5 second clips, which are then uploaded to a private Firebase Storage bucket. A Cloud Function is triggered to generate a short-lived signed URL and notify the ESP32-S3 device via MQTT over TLS.

• Serverless architecture with Firebase.
• IoT security best practices (TLS, signed URLs, ACLs).
• Hardware-software integration with ESP-IDF.
• Flutter mobile development and permissions management.
• MQTT messaging protocol.
• Fully agentic AI development workflows.

The project demonstrates high-performance simulation kernels for heat diffusion and Navier-Stokes fluid dynamics. By using CUDA-OpenGL interoperability (Pixel Buffer Objects), the simulation data stays on the GPU for both calculation and rendering, avoiding costly CPU-GPU memory transfers.

• CUDA kernel development and optimization.
• OpenGL interoperability with CUDA.
• Numerical methods for partial differential equations.
• Real-time visualization techniques.
• GPGPU programming patterns.

• End-to-end game development pipeline.
• Initial design and ideation.
• Prototyping and iteration.
• Implementation and production.
• Playtesting and balancing.
• Marketing and store presence.
• Game art, VFX, and SFX.

In this project, we developed a pipeline to scan objects in-hand. Roughly, speaking, we had to stream raw point cloud data from the Hololens, send them to PC via TCP, process them (clipping, denoising, hand removal, register and reconstruct the point cloud), while visualizing the intermediate results by sending data back to the Hololens. When the scanning is over, we post-process the obtained point cloud to obtain a corresponding mesh. More details can be found in our report.

• Team work.
• Hands-on experience with Mixed Reality.
• Computer vision algorithms.
• Point cloud/mesh reconstruction.
• Outlier filtering.
• System architecture.
• User experience.

I implemented support for both homogeneous and heterogeneous media, as well as textures, environment maps, textured area emitters, anisotropic phase functions and camera blur.

• Path tracing.
• Volume Rendering.
• Environment maps.
• Multiple importance sampling.
• Texturing.
• Modeling with blender.
• Scene layout.
• Lighting.
• And much more...

The Goal was to create a 1 minute animation of a supernovae explosion and get some practice with Unity.

• Team work.
• More C# and Unity experience.
• Camera path with Bezier curves.
• Animation skills.
• Working with multiple shaders.
• Screen-space post-processing.
• L-Systems.
• Procedural mesh generation.
• Many more...

The goal of this project was to get more expertise in image segmentation and Deep Learning architectures in general. The paper accompanying this project can be found here.

• More experience with Pytorch and Tensorflow.
• Better mastery of Python.
• Good understanding of deep learning techniques.
• Team work.
• Preparing and organizing experiments.
• Writing a scientific report.
• Dealing with reproducibility challenges.

Typically in computer animation, when we create a specific animation sequence for some rig, we want the deformations to be automatically computed for any mesh controlled by the said rig. Indeed, manually modifying vertex-by-vertex is just unfeasible. This is solved by an algorithm known as "skinning". In a nutshell, each vertex is moved according to the underlying joints of the rig. This implies that each vertex needs to know which joint it belongs. Again, this can be computed automatically, and to have smooth transformations, we assign to each vertex a set of harmonically interpolated weights. Various skinning techniques are implemented such as 'Per-vertex Linear Blend Skinning', 'Dual-Quaternion Blend Skinning', 'Per-face Linear Blend Skinning'. To have even more compelling results, we also implement 'Context-aware Blend-Skinning', where using example poses helps give more realistic transformations.

More Geometry Processing algorithms can be found here

• Understand and implement skinning techniques.
• More hands-on numerical optimization.
• The 'substitution' method for solving constrained linear systems.
• Poisson stitching.
• Further experience in C++ and libigl.

While not technically challenging, this small project was a great way to get some hands-on experience with various integration schemes (explicit/implicit/symplectic Euler etc.), as well as their respective (un-)stability.

More Computational motion algorithms can be found here.

• Better knowledge of integration schemes.
• Some C++ practice.
• Collision handling.

The Goal was to develop an enjoyable complete game in a short time frame. We managed to created an RPG/Dungeon crawler with a very special mechanic: In order to cast spells, the player has to draw symbols on the ground. The symbol is recognized and the corresponding spell is cast.

• Develop a large project in a team.
• More C# experience.
• Story writing.
• Sound Engineering.
• Playtesting.
• Image recognition.
• Forward Kinematics.
• Good learning experience on how to create games that are enjoyable and keep the player hooked.

I wanted to get some hands-on experience in RL algorithms. This was a good opportunity as I got to implement DQN in the multi-agent setting to automatically infer zombie pandemic mitigation strategies.

• Python/PyTorch practice.
• Hands-on experience with Reinforcement Learning.

One of the common architectures for image segmentation is the U-Net. We trained this neural network architecture on a few dozens of labeled (segmented) images in order to segment complete videos in a test set. As the number of parameters was of the order of tens of millions, we had to use Google Colab hosted GPUs in order to accelerate training and to have enough RAM to fit the batches of images in memeory. The preprocessing includes histogram equalization, data augmentation (crucially important to prevent overfitting to the very limited original dataset), reshaping, rescaling etc. The post-processing includes various filtering operations as well as as a final ensembling operation to reduce variance in predictions and increase robustness.

• Work with medical video segmentation.
• Use new neural network architectures (U-Net, Attention U-Net).
• Develop a data analysis pipeline including preprocessing, neural network training and postprocessing.
• Hands-on experience with Tensorflow.

The goal of this project was to build a DeepPoly verifier that provably certifies a given network is robust against any L-infinity perturbation attack for some input images (MNIST). The idea is instead of propagating the input values through the network, we propagate a whole convex shape around the given image. The key challenge is to maintain soundness (never certify the network if it is actually not robust), while being as precise as possible (being able to prove the robustness property when it actually holds). To this end, the verifier network (The network verifying the original neural network) is contiuously optimized for precision using backprop/gradient descent on its parameters.
For more details about DeepPoly, have a look at the DeepPoly original paper.

• Learning about program verification in general, and neural network verification in particular.
• Using Pytorch to perform backpropagation on non-standard neural network code.
• Testing different verification approaches, gauging their pros, cons and performance.

The goal of these mini-projects was to discover ray-tracing algorithms and acceleration datastructures, as well as getting familiar with writing shaders.

• Camera transformations
• GLSL shaders.
• Ray tracing techniques
• Acceleration datastructures.
• Procedural generation.

Learn how to design a database as well as get familiar with the impact of query optimization using indexes. The detailed report can be found here.

• SQL hands-on experience
• Database design
• Analyze and optimize query plans using indexes

The goal of this project was to develop the software necessary to enable a rover to safely navigate in an unknown mars-like terrain, having as only source of information a Lidar-generated map of the environment.
The detailed report can be found here.

• Using the ROS (Robot Operating System) middleware and work in a distributed system environment.
• Use the Gazebo and RViz simulation tools.
• Gain more expertise working in a Linux environment.
• A panoply of path planning algorithms, their pros and cons.
• Working in a team.

Gain some insight into the implementation details of different path-planning algorithms and setup a framework to quickly prototype, test and compare different solutions.

• Building a GUI Python application
• Have a better understanding of path planning-algorithms

The goal was to have a first contact with the programming universe by developing a simple 2D game. I went beyond and spent hundreds of hours working on this project because I couldn't get enough of it. The result is still quite modest but it allowed me to have some solid experience in Java, designing special effects and even music composition :)
The project report can be found here (in french).

• Learn Java.
• Design a simply UI and handle different screens (game, inventory, options, ...).
• Overall game development and design.
• Compose simple soundtracks for the game.

The goal was to create a strategy game with a background story and have to deal with databases to store all the data of the generated stellar systems. The LibGDX was chosen for its interesting features in UI design, but also for the ability to deploy on many platforms, mainly Windows, Android and iOS. However, due to time constraints, the game ended up only targeting Windows.

• Get more experience with Java
• Learn how to use a database in a real application
• Integrate 3D aspects in a 2D UI
• Discover the challenges of creating a user experience that keeps the player interested
• One very fun part was working on generating the galaxy that you can see on the right. This is a fractal called the 'Dragon curve', and each vertex corresponds to a visitable, unique stellar system

• Develop a GUI application in C++
• Discover and implement the Dijkstra algorithm
• Find efficient methods to decide if a rectangle (drawn in black in the image above) intersects the brown areas

The goal was to write a clean, easily maintainable, tested and robust GUI application using JavaFX, and have performance and usability.

• Practice unit testing for almost every aspect of the application with JUnit.
• Write modular and clean code.
• Practice conversions between different frames of reference.
• Learn to properly decouple the model from the view.
• Have an efficient implementation of all algorithmic aspects, particularly efficient 2d queries with KD-Trees.

Write a simple RPG game in a clean fashion, especially regarding collision detection and interaction between different actors

• Write an engaging story.
• Use of the visitor pattern for modeling the interactions.
• Practice doing simple 2D animations.
• Write a clean inventory system.

The goal was to get familiarity and hands-on practice with fundamental elements of computer graphics (projections, perspectives, UI design), as well as implement various image processing techniques seen in the introduction to visual computing course.

• Physics of a rolling ball.
• Use of projections.
• Image processing techniques like, filtering, convolution, blurring (e.g. gaussian kernel), using a Sobel filter for image differentiation and edge detection
• The Hough transform (for detecting the position of the vertices of the board).
• The two-pass algorithm (for connected components detection (the board)).
• The Kalman filter (for continuous tracking of the board).

• Code modularisation.
• Get hands-on experience with error-correcting codes (Reed Solomon).
• Unit testing.

• Learn how to write and organize code in Assembly.
• See how simple instructions can be used to produce very complex behaviours such as collision checking.
• Load software to a physical board.

• Practice VHDL
• Use the Modelsim simulator to test the processor.
• Learn the workings and components of a multi-cycle processor.