A new year of Capstones: A Recap of the last Projects

As part of the AdaCore GNAT Academic Program, Capstones offers senior higher education students the opportunity to take on challenging and exciting engineering projects within a high-integrity technology and culture framework.

As we begin a new academic year, with everyone back and ready to face new challenges, it’s the perfect time to reflect on the high-quality projects completed over the past year.

If you want to start or discuss a Capstone idea with us, please contact henley@adacore.com. We have a few spots left, but they will only be available for a short time!

Clearing Landmines: Autonomous Robot in Senegal

Joseph Binyoum returned to Senegal after studying engineering in France to apply his expertise to the areas that mattered most. One of his most ambitious projects is an autonomous demining robot called Midero, built to clear landmines left in the Casamance region, a legacy of past conflicts.

When Joseph first came to me with the idea for his Capstone project, it was immediately apparent how important this was—it wasn’t just about engineering but saving lives. The technical challenges were critical: precise navigation, accurate detection, and autonomous decision-making. Safely detecting landmines introduces profound engineering complexity, even at the prototyping stage.

AdaCore supported Joseph throughout, providing materials and opportunities to brainstorm solutions. Dr. Pat Rogers' RCCarDemo offered many reference implementation ideas and great insights into structuring this type of project. Joseph’s dedication never wavered, and he turned this concept into a working prototype, powered by the GNAT toolchain and its strengths in embedded systems.

You can explore his codebase on GitHub and watch his detailed presentation from the GAP workshop.

Developing an In-Application Bootloader for the STM32F746

Inspired by an STM32 bootloader course on Udemy written in C, I saw an opportunity for an Ada Capstone project. An "in-application bootloader" handles firmware transfer using a remote native command line interface, verification, and memory management and smoothly switches to the new firmware. Its main advantage is allowing direct updates without special programming hardware, potentially minimizing downtime, and providing a fail-safe mechanism in case of failure. The trade-off is that the bootloader itself consumes some of the available flash memory.

A group of students from Penn State Behrend, Alan Everett, Joseph Smith, and Xavier Zhang, took on the challenge. Over two academic semesters, they steadily advanced in understanding Ada, Alire, and the complexities of bootloaders in a bare-metal environment.

Working with the STM32F746 Discovery board, they ran into some gaps in the BSP support but managed to enhance UART functionality and develop a custom flash driver. The result is a functional and reliable bootloader. They even 3D-printed a custom case for the board!

Their GAP workshop presentation covers the process, and the project’s code is available on GitHub. It all builds quickly with Alire.

Oh, and I almost forgot! The VP of Google's Fuchsia operating system personally attended their presentation!

Core RINA Stack on Embedded

This project holds a special significance for me. We’ve all been taught that the OSI model was the gold standard for network architecture. Still, an ARPANET pioneer, John Day), challenged that idea in his 2007 book Patterns in Network Architecture: A Return to Fundamentals. In it, Day breaks down the politics, tradeoffs, and missed opportunities that shaped today’s standard protocol stacks. As we push networks to be faster and more capable, the cracks in these designs are becoming more evident. Day’s solution? RINA - Recursive Internetwork Architecture - a model built to scale seamlessly from OS-level resource management to global backbone networks.

Day’s central argument is that most of today’s protocols result from mixing mechanisms and policy. RINA simplifies this with recursive IPC processes across distributed layers, using a single protocol (mechanism) and customizable policies like QoS and retransmission. It also introduces an elegant solution to handle multi-homing, redefining addressing in the process.

Once again, students from Penn State Behrend, Anthony Immekus, Keian Kaserman, Robert Myers, and Mason Ticehurst took on the challenge of implementing an experimental RINA setup. They started with a Linux implementation of RINA, rlite, and then extended it to communicate with a bare-metal STM32F746 Discovery board. The students developed an Ada binding to rlite, ported RINA's core model to Ada, adapted Stephane Carrez’s ada-enet for his STM32 Ethernet support, built a bare-metal touch-based GUI with a file manager, and managed to establish communication over Ethernet with the Linux machine using core RINA principles.

I recall when they were deep in rlite’s Linux driver code—there were moments when they questioned whether this was just a wild idea. But they stuck with it and delivered an impressive demo. You can check out their code on GitHub and catch their detailed walkthrough at the GAP workshop.

Building a Machine Learning Library in Ada

A few years back, during an AI project at Autodesk, I stumbled across an article about building a deep learning library from scratch in Python. It outlined the core components: Operators, Optimizers, Loss functions, Regularizers, and Initializers. The Python code was minimal but functional. With all the buzz around AI, I thought it would make an excellent challenge for senior students—to take that same library and convert it to Ada.

Many people don’t realize that Ada offers the power of C++ (which drives most Python AI libraries) but with a much stricter type system and near Python-level expressiveness. This project would highlight Ada’s strengths in performance and robustness.

A team from Penn State Behrend, Owen Wienczkowski, Samuel Leonetti, Garrett Glowacki, and Stefan Milinkovic took up the challenge. We quickly realized that while Python relies heavily on NumPy for linear algebra, the Ada version demanded more hands-on work. To handle the math, the students turned to the orka_numerics library by Onox, which uses Ada’s generics to adapt to different hardware like CPUs, SIMDs, and GPUs. Navigating the advanced Ada code posed a learning curve, and with some missing features, the students had to unroll loops and dive into low-level linear algebra computation manually.

Python’s flexibility in resource management doesn’t carry over to Ada, so the team had to rethink handling resources in a more rigid but reliable Ada mindset; it was a great learning experience in disciplined design.

In the end, the students managed to port a basic, working version of the ML engine to Ada. You can check their progress and catch more details during the GAP workshop.

Flexbox "Liquid Layout" on Bare Metal

Anyone who’s worked with GUI programming knows it’s a love-hate affair. Seeing things move and interact on screen is rewarding, but getting there often means dealing with complex and frequently heavy architectures.

When HTML5 emerged, it needed CSS3 to realize its full potential, and introducing the flexbox layout was a game-changer. Before Flexbox, creating portable, liquid layouts was a painful process. Developers had to rely on hacks like overusing “float: right” or third-party libraries that manipulated the Document Object Model (DOM) in clunky ways. Flexbox changed all that by introducing a system specifically designed for dynamic, responsive, and flexible interfaces. It’s no surprise that modern frameworks like Flutter have adopted flexbox concepts at their core.

This project began as a proof of concept, using Ada’s multiway tree container to mirror the DOM and create a minimal flexbox implementation with an X11 binding. While it worked, it needed more functionality, so I turned it into a Capstone project at Penn State Behrend.

Penn State Behrend students Dominick Carlucci, Kien Nguyen, John Shimer, and Stuart Walters took it on, adding event handling, touch support, buttons, resizable images, and essentially the full flexbox semantics. Now, you can organize visual components into flexible rows and columns, manage dynamic resizing, wrap content, control child-parent size relationships, and align elements in all directions. To push the concept further, the students ported it to bare metal on the STM32F746 Discovery board, achieving a real-time, responsive liquid layout on an embedded system without the need for an OS. The board’s large LCD screen is the perfect showcase for what this system can do.

You can build their code using Alire and run it on the STM32 in under a minute. Check out the project on GitHub and catch their live demo at the GAP workshop.

Min Protocol Implementation for MCU Data Transfer

Last year, the University of Ottawa ran into trouble while working on a multi-channel embedded oscilloscope - reliably transferring sampled data from the oscilloscope to a PC became an issue. It could have been any number of things: noise interfering with parity bits, bad cables, buffer overflows, baud rate mismatches, or framing errors.

We found the Min protocol, designed by Ken Tindell, which offers framing, CRC, and optional retransmission - all in a lightweight library built for microcontrollers. The Ottawa team started porting it to Ada to address their data transfer problems. I later turned this into a single-student, Samuel Dion, Capstone project at the University. Over the semester, Samuel enhanced the prototype, created a clean UART testbench for retransmission, and delivered a proper Alire package.

You can check out the latest work on GitHub and hear Samuel present the project during the GAP workshop.

RSA in Action

Public key cryptography embedded in production systems has always been a bit frustrating for me. It’s tricky to separate what’s truly fundamental from what’s just an arbitrary technical decision. When I met Guy Juslain and Rony-Steve Ymele Kagho, students from the University of Ottawa who felt the same way, we decided to dive deeper together.

A critical resource that got us started was an article by Maxim Reznik on LearnAda. It introduced Ada 2022’s Big Integer and explained key parts of the RSA algorithm). Combined with a multithreaded echo server example in Ada from Rosetta Code, we had the foundation to define the students’ capstone project: simulating RSA public key cryptography between Alice and Bob.

The students built algorithms to generate short public and private keys and set up three processes: a server, Alice, and Bob. Once both clients connect, the server exchanges their public keys, enabling Alice and Bob to send encrypted messages. The server, acting as a middleman, logs everything, but all it sees is encrypted gibberish. Alice and Bob use their private keys to decrypt each other’s messages. The whole system runs smoothly, and while it doesn't attempt to meet the highest levels of security assurance, it’s a clear demonstration of the core mechanics of RSA.

It’s genuinely cool to see it in action. You can run the code on a native platform.