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 #

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 #

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 #

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 #

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.