AdaCore Blog

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

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

by Olivier Henley

As part of the Ada­Core GNAT Aca­d­e­m­ic Pro­gram, Cap­stones offers senior high­er edu­ca­tion stu­dents the oppor­tu­ni­ty to take on chal­leng­ing and excit­ing engi­neer­ing projects with­in a high-integri­ty tech­nol­o­gy and cul­ture framework.

As we begin a new aca­d­e­m­ic year, with every­one back and ready to face new chal­lenges, it’s the per­fect time to reflect on the high-qual­i­ty projects com­plet­ed over the past year.

If you want to start or dis­cuss a Cap­stone idea with us, please con­tact henley@​adacore.​com. We have a few spots left, but they will only be avail­able 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’ RC_Car_Demo 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.

Build­ing a Machine Learn­ing Library in Ada #


A few years back, dur­ing an AI project at Autodesk, I stum­bled across an arti­cle about build­ing a deep learn­ing library from scratch in Python. It out­lined the core com­po­nents: Oper­a­tors, Opti­miz­ers, Loss func­tions, Reg­u­lar­iz­ers, and Ini­tial­iz­ers. The Python code was min­i­mal but func­tion­al. With all the buzz around AI, I thought it would make an excel­lent chal­lenge for senior stu­dents — to take that same library and con­vert it to Ada.

Many peo­ple don’t real­ize that Ada offers the pow­er of C++ (which dri­ves most Python AI libraries) but with a much stricter type sys­tem and near Python-lev­el expres­sive­ness. This project would high­light Ada’s strengths in per­for­mance and robustness.

A team from Penn State Behrend, Owen Wienczkows­ki, Samuel Leonet­ti, Gar­rett Glowac­ki, and Ste­fan Milinkovic took up the chal­lenge. We quick­ly real­ized that while Python relies heav­i­ly on NumPy for lin­ear alge­bra, the Ada ver­sion demand­ed more hands-on work. To han­dle the math, the stu­dents turned to the orka_​numerics library by Onox, which uses Ada’s gener­ics to adapt to dif­fer­ent hard­ware like CPUs, SIMDs, and GPUs. Nav­i­gat­ing the advanced Ada code posed a learn­ing curve, and with some miss­ing fea­tures, the stu­dents had to unroll loops and dive into low-lev­el lin­ear alge­bra com­pu­ta­tion manually.

Python’s flex­i­bil­i­ty in resource man­age­ment doesn’t car­ry over to Ada, so the team had to rethink han­dling resources in a more rigid but reli­able Ada mind­set; it was a great learn­ing expe­ri­ence in dis­ci­plined design.

In the end, the stu­dents man­aged to port a basic, work­ing ver­sion of the ML engine to Ada. You can check their progress and catch more details dur­ing 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 Pro­to­col Imple­men­ta­tion for MCU Data Trans­fer #


Last year, the Uni­ver­si­ty of Ottawa ran into trou­ble while work­ing on a mul­ti-chan­nel embed­ded oscil­lo­scope — reli­ably trans­fer­ring sam­pled data from the oscil­lo­scope to a PC became an issue. It could have been any num­ber of things: noise inter­fer­ing with par­i­ty bits, bad cables, buffer over­flows, baud rate mis­match­es, or fram­ing errors.

We found the Min pro­to­col, designed by Ken Tin­dell, which offers fram­ing, CRC, and option­al retrans­mis­sion — all in a light­weight library built for micro­con­trollers. The Ottawa team start­ed port­ing it to Ada to address their data trans­fer prob­lems. I lat­er turned this into a sin­gle-stu­dent, Samuel Dion, Cap­stone project at the Uni­ver­si­ty. Over the semes­ter, Samuel enhanced the pro­to­type, cre­at­ed a clean UART test­bench for retrans­mis­sion, and deliv­ered a prop­er Alire package.

You can check out the lat­est work on GitHub and hear Samuel present the project dur­ing 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 Gustavo A. Hoffmann 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.

Posted in #Capstone   

About Olivier Henley

Olivier Henley

The author, Olivier Henley, is a UX Engineer at AdaCore. His role is exploring new markets through technical stories. Prior to joining AdaCore, Olivier was a consultant software engineer for Autodesk. Prior to that, Olivier worked on AAA game titles such as For Honor and Rainbow Six Siege in addition to many R&D gaming endeavors at Ubisoft Montreal. Olivier graduated from the Electrical Engineering program at Polytechnique Montreal. He is a co-author of patent US8884949B1, describing the invention of a novel temporal filter implicating NI technology. An Ada advocate, Olivier actively curates GitHub’s Awesome-Ada list