Artificial Intelligence
Custom OS installation now available on AWS DeepRacer devices
With the stock firmware and software, developers couldn’t modify their AWS DeepRacer devices to use the latest operating systems. Now, developers can upgrade or install a custom operating system (OS) by using a newly released bootloader, which extends the life of these hardware devices.
AWS DeepRacer devices are fully autonomous 1/18th scale race cars driven by models trained through reinforcement learning. These hardware devices, when paired with a cloud environment for training and evaluation of neural network models, provide an education and development environment intended to help developers get started with machine learning. As shipped, secure firmware on the AWS DeepRacer devices boots AWS-signed operating systems, including versions of Ubuntu 16.04 and 20.04. These versions of Ubuntu are no longer supported, making ongoing experimentation and research difficult. To keep these devices useful as long as possible, you need a way to authorize custom and modified software to run.
With our developer bootloader, you can install custom operating systems outside of those originally provided. You can also install modern Linux distributions, add custom hardware drivers, run custom and more modern software stacks, build novel educational projects, and develop prototypes for new vehicle algorithms. In this post, we introduce the bootloader, discuss how to use it, and share links to a community distribution that uses it.
Our solution
Our team developed a bootloader that provides self-service developer access. The bootloader is based on the open-source shim project. With this developer shim, you can install custom or third-party distributions onto your AWS DeepRacer device.
The developer shim targets developers familiar with Linux boot processes and certificate management. It’s particularly valuable for community members who want to create and distribute custom AWS DeepRacer installation distributions and media.
On bootup, the developer shim blinks “DEVELOPER MODE” in Morse code on the AWS DeepRacer device’s built-in lights. After completing this indicator, the shim transfers control to the installed OS. The intent is for transparency through clear visual indicators whenever developer mode is active. These indicators help you understand your device’s security posture.
Should you need to return to the original configuration, the process is completely reversible. You can follow the directions for Update Your Vehicle to return the device to stock configuration.
The developer shim works through three key elements:
1. Self-service certificate management
When built-in signature verification fails, the developer shim checks for developer certificates in /EFI/DEVELOPER/certs/
on the device’s boot partition. You can manage your own certificates using standard tools (OpenSSL, sbsign) while maintaining proper cryptographic verification.
2. Clear visual warnings
When developer certificates are in use, the system provides a clear indication:
- On-screen warning (through HDMI) – Informs you of developer mode.
- Hardware indication – Device lights blink “DEVELOPER MODE” in Morse code.
- Boot delay – Gives you time to observe the developer mode activation.
3. Standard verification workflow
The solution uses standard certificate-based signing tools, making it accessible to developers already working with secure boot processes. With this method, you can provide your own certificates while maintaining the cryptographic integrity of the boot chain and operating system.
Community impact
The open source AWS DeepRacer community at deepracing.io used this developer shim to create a new custom distribution for AWS DeepRacer devices, built on an Ubuntu 24.04 / ROS2 Jazzy software stack and featuring a Cloudscape-based user interface. As a practical demonstration of the self-service bootloader approach, it offers a ready-to-use solution for developers who want to get started quickly.
Pre-packaged and using an installation process very similar to the original AWS distribution, it comes ready to deploy out of the box. The community prioritized racing performance, removing non-essential packages, including the X Window System graphical interface. You can add the desktop experience back in yourself if needed. Refer to the README for installation instructions.
The developer shim allows the DeepRacing community to maintain and distribute updated software for AWS DeepRacer devices, extending their useful life well beyond the original distributions. The distribution can be found at https://github.com/aws-deepracer-community/deepracer-custom-car
How to use it
You can use the bootloader with your AWS DeepRacer device across multiple usage patterns. You can upgrade using a community distribution, use a standard third-party OS, or even create your own custom OS. The exact steps depend on your choice.
Option A: Install a community distribution
You can get started by installing a community distribution, such as the Ubuntu 24.04 Community Distribution. This option provides an installation method without requiring the developer to custom install Linux and reconfigure its boot processes.
Option B: Third-party distributions
You can use the developer shim when installing a third-party distribution such as Ubuntu. Choose this option if you want control over the installation process. After installing the OS, replace the BOOTX64.EFI
file with the developer shim and add the appropriate certificates. This might need to be done twice: once for the installation media, and again after installation. Consult the USAGE.md
file in the developer shim package for guidance.
Option C: Custom OS
If you’re building a custom OS for the AWS DeepRacer device, create a boot volume on the device. Place the developer shim under EFI/BOOT/BOOTX64.EFI
and your OS kernel or bootloader as EFI/BOOT/GRUBX64.EFI
. Then install your public certificate under the DEVELOPER/certs
path. Consult the USAGE.md
file in the developer shim package for guidance.
What to expect during early boot sequence
The device goes through several stages on boot. Upon power-on, the device firmware loads the developer shim (BOOTX64.EFI
) and transfers execution to it. The shim then displays a warning on the screen (when an HDMI monitor is attached) and blinks “DEVELOPER MODE” in Morse code on the device’s lights. This stage takes approximately 21 seconds. Much like the original firmware’s bootloader or a shim bootloader on a standard PC install, the developer bootloader then loads the operating system’s kernel. However, unlike the firmware, the developer bootloader checks the signature of this kernel against a local customizable certificate store kept in /EFI/DEVELOPER/certs
. If the signature matches, the developer shim transfers execution to this operating system kernel, and boot continues normally.
Pairing with self-managed AWS DeepRacer
With the bootloader shim and the self-managed solution released on January 26, 2026, you now have full control over both the cloud-based training environments and your physical devices. Developers can customize the on-device software stack, experiment with new ROS2 packages, and iterate on racing models with total end-to-end flexibility. Visit DeepRacer on AWS for details on the self-managed solution.
Getting started
To get started, first explore the DeepRacer on AWS Solution and then download the developer shim at deepracer-developer-shim.zip. To create or modify the boot medium for the new custom operating system, place the BOOTX64.EFI
shim file into the EFI/BOOT
directory. Store your chosen operating system kernel as GRUBX64.EFI
, and store the kernel’s public certificate in EFI/DEVELOPER/CERTS
in x509 DER format. This might need to be done for both the operating system installation media and again on the device itself after installing from media. For more detailed technical documentation, troubleshooting, and advanced usage, refer to the bootloader’s USAGE.md
file contained within the zip file.
Alternatively, download the community distribution linked in the preceding How to use it section and follow the directions for a fresh install with the developer bootloader already incorporated.
Conclusion
Using the bootloader, you can unlock your AWS DeepRacer device and continue to use it as an education and development environment with the latest modern operating systems, tools, and software stacks. You can also customize your own operating system install or use community distributions.
To get started, download the developer bootloader at deepracer-developer-shim.zip and follow the instructions in the USAGE.md
file. After that, check out the Community Distribution and continue your machine learning (ML) journey with the DeepRacer on AWS Solution.
With the flexibility introduced with the new bootloader, your imagination is the limit on what you can implement on the device. What will you build? Feel free to share on https://builder.aws.com/
Facts Only
AWS DeepRacer devices are 1/18th scale autonomous race cars.
Stock firmware boots AWS-signed operating systems, specifically Ubuntu 16.04 and 20.04.
A new developer bootloader, based on the open-source shim project, is now available.
The bootloader allows the installation of custom or third-party operating systems.
A community distribution featuring Ubuntu 24.04 and ROS2 Jazzy exists at deepracing.io.
Developer mode is signaled by a boot delay, an HDMI on-screen warning, and "DEVELOPER MODE" blinked in Morse code via device lights.
The bootloader verifies signatures against certificates stored in /EFI/DEVELOPER/certs/.
The process to return to stock configuration is reversible via the "Update Your Vehicle" directions.
A self-managed cloud training solution was released on January 26, 2026.
The developer shim is provided as a zip file containing BOOTX64.EFI and a USAGE.md file.
Executive Summary
AWS has released a developer bootloader for DeepRacer hardware to address the obsolescence of the stock Ubuntu 16.04 and 20.04 firmware. By utilizing a shim-based approach, developers can now bypass original signing restrictions to install modern Linux distributions, custom drivers, and updated software stacks. This transition is designed to extend the hardware's utility for machine learning research and education.
Users have three primary paths: deploying a pre-packaged community distribution (such as the Ubuntu 24.04/ROS2 Jazzy stack), installing a third-party OS with manual certificate management, or building a entirely custom OS. To maintain security transparency, the system implements visual and temporal indicators—including Morse code light signals—whenever developer mode is active. This hardware flexibility, paired with a recently released self-managed cloud solution, shifts the ecosystem from a locked vendor environment toward an open, end-to-end customizable development pipeline.
Full Take
The strongest version of this narrative is a victory for "Right to Repair" and hardware longevity. By releasing the developer shim, AWS is transforming a proprietary, locked-down appliance into a general-purpose robotics platform, effectively preventing thousands of devices from becoming e-waste due to outdated software.
However, this is a classic vendor-managed liberation. The narrative frames the "unlocking" as a gift of flexibility, while the mechanism (the shim) ensures the vendor still defines the parameters of the "developer mode" and its visual warnings. The push toward a "self-managed solution" suggests a strategic pivot: AWS is moving from providing a curated "black box" experience to providing the infrastructure for those capable of managing their own complexity. The load-bearing logic here is that the device's value is now derived from the community's labor (e.g., the deepracing.io distribution) rather than AWS's internal software updates.
Patterns detected: ARC-0048 Authority Game. The content functions as a vendor advertorial, citing the "DeepRacer on AWS Solution" as the primary path to achieving the promised flexibility, effectively using the "problem" of obsolete firmware to drive users toward a new self-managed service tier.
Root Cause: The shift reflects the tension between "Product-as-a-Service" (where the vendor controls the OS) and "Hardware-as-a-Tool" (where the user owns the stack).
Implications: Human agency is increased for the technically proficient, but a digital divide is created between those who can manage X.509 certificates and those who rely on the stock experience. The cost of maintenance is shifted from the vendor to the community.
Bridge Questions:
1. If the community ceases to maintain the Ubuntu 24.04 distribution, does the developer shim provide enough documentation for a non-expert to sustain the hardware?
2. How does the requirement for a "self-managed solution" change the cost structure for the end-user compared to the original integrated cloud environment?
Counterstrike Scan: A bad actor attempting to push this narrative would use "predatory liberation" rhetoric to lure users into a proprietary ecosystem by pretending to grant them "freedom." While the structure mimics this, the actual content provides a functional, reversible technical path and references open-source projects, making it a genuine technical release rather than a deceptive influence operation.