I’ve organized these into 10 categories, with a short explanation of what each project is useful for. The selection focuses on skills that are highly relevant to modern embedded engineering: RTOS, MCU firmware, ESP32/IoT, Embedded AI, Embedded Linux, robotics, automotive, debugging, security and FPGA/ASIC development. GitHub’s current topic pages show particularly large ecosystems around ESP32 and STM32, while projects such as Zephyr, LVGL and Meshtastic continue to see active development.

🧠 RTOS & Embedded Firmware

1. Zephyr RTOS

Zephyr is a modern open-source RTOS designed for resource-constrained embedded and IoT devices. It is excellent for learning multitasking, device trees, device drivers, interrupts, networking, Bluetooth, power management and multi-board development. It is one of the strongest projects to study if you want modern embedded firmware experience.
GitHub: https://github.com/zephyrproject-rtos/zephyr

2. FreeRTOS Kernel

FreeRTOS is one of the most widely used real-time operating systems in embedded products. You can use it to learn tasks, queues, semaphores, mutexes, timers, scheduling and interrupt-driven applications, making it particularly useful for developing production-style MCU firmware.
GitHub: https://github.com/FreeRTOS/FreeRTOS-Kernel

3. Apache NuttX

Apache NuttX is a real-time operating system designed for microcontrollers with a POSIX-like environment. It is useful for learning RTOS architecture, peripheral drivers, networking, filesystems and embedded applications while working with constrained hardware.
GitHub: https://github.com/apache/nuttx

4. RIOT OS

RIOT is an operating system focused on low-power IoT and embedded devices. It can help you understand networking, wireless communication, sensor systems, power-efficient applications and distributed embedded systems.
GitHub: https://github.com/RIOT-OS/RIOT

5. ChibiOS

ChibiOS combines a compact RTOS with a hardware abstraction layer for microcontrollers. It is a good project for learning real-time scheduling, peripheral access, interrupt handling and efficient embedded C development.
GitHub: https://github.com/ChibiOS/ChibiOS

6. RT-Thread

RT-Thread is an RTOS ecosystem containing scheduling, drivers, networking, filesystems and middleware. It is useful for building connected MCU products and understanding how a complete embedded software ecosystem is structured.
GitHub: https://github.com/RT-Thread/rt-thread

7. Embassy

Embassy is an asynchronous embedded framework written in Rust. It is useful for engineers who want to explore modern memory-safe firmware, asynchronous tasks, concurrency and efficient embedded development.
GitHub: https://github.com/embassy-rs/embassy

8. TinyGo

TinyGo brings the Go programming language to microcontrollers and embedded targets. It is useful for experimenting with alternative programming approaches while working with boards such as ESP32, RP2040 and other microcontrollers.
GitHub: https://github.com/tinygo-org/tinygo

9. Apache Mynewt

Apache Mynewt is an RTOS designed for connected embedded systems, particularly resource-constrained devices. It includes support for Bluetooth, networking, storage and MCU development, making it useful for IoT firmware development.
GitHub: https://github.com/apache/mynewt-core

10. CMSIS

CMSIS provides standardized software interfaces and components for Arm Cortex-M processors. It is useful for understanding Cortex-M architecture, startup code, DSP, RTOS integration and common software interfaces used across Arm-based MCUs.
GitHub: https://github.com/ARM-software/CMSIS_5

11. libopencm3

libopencm3 is an open-source hardware abstraction library for ARM Cortex-M microcontrollers. It is useful for engineers who want to understand low-level peripheral programming without depending heavily on vendor-specific frameworks.
GitHub: https://github.com/libopencm3/libopencm3

12. LittleFS

LittleFS is a small filesystem designed specifically for embedded flash memory. It is useful for products that need reliable storage of configuration, logs, calibration data or other files on microcontrollers.
GitHub: https://github.com/littlefs-project/littlefs

13. PlatformIO

PlatformIO provides an embedded development environment with build management, library management, debugging and testing support. It is useful for managing projects across different boards and microcontroller platforms.
GitHub: https://github.com/platformio/platformio-core

14. OpenBLT

OpenBLT is an open-source bootloader designed for microcontrollers. It is useful for learning firmware updates, bootloader architecture, application launching and in-field software update mechanisms.
GitHub: https://github.com/feaser/openblt

15. Mongoose

Mongoose is an embedded networking library supporting protocols such as HTTP, MQTT and WebSocket. It is useful for building connected embedded products with web interfaces, cloud connectivity and remote device management.
GitHub: https://github.com/cesanta/mongoose

⚡ ESP32, MCU & IoT

16. ESP-IDF

ESP-IDF is Espressif’s official development framework for ESP32-family chips. It provides access to Wi-Fi, Bluetooth, FreeRTOS, GPIO, ADC, SPI, I2C, networking and many other peripherals, making it an excellent platform for production-oriented ESP32 development.
GitHub: https://github.com/espressif/esp-idf

17. Arduino ESP32

Arduino-ESP32 provides an Arduino programming environment for ESP32 devices. It is useful for rapidly developing IoT prototypes involving sensors, displays, motors, Wi-Fi, Bluetooth and other peripherals.
GitHub: https://github.com/espressif/arduino-esp32

18. Xiaozhi ESP32

Xiaozhi ESP32 is an AI voice-assistant project designed around ESP32 hardware. It is particularly interesting for learning how MCU firmware, audio processing, connectivity and AI-powered applications can be combined in a small embedded device.
GitHub: https://github.com/78/xiaozhi-esp32

19. RuView

RuView explores Wi-Fi-based sensing for applications such as presence and spatial intelligence. It is an interesting project for engineers interested in wireless sensing, signal processing, IoT and Edge AI.
GitHub: https://github.com/ruvnet/RuView

20. Tasmota

Tasmota is open-source firmware for ESP8266 and ESP32-based IoT devices. It provides a practical way to learn MQTT, sensors, networking, automation, configuration and OTA firmware updates.
GitHub: https://github.com/arendst/Tasmota

21. ESPHome

ESPHome makes it easy to build ESP32/ESP8266-based connected devices using configuration rather than writing every component from scratch. It is useful for sensor networks, home automation, MQTT and rapid IoT prototyping.
GitHub: https://github.com/esphome/esphome

22. WLED

WLED turns ESP-based boards into network-controlled LED systems. Although simple to start with, it provides practical exposure to networking, real-time control, web interfaces and embedded configuration.
GitHub: https://github.com/Aircoookie/WLED

23. Meshtastic

Meshtastic creates long-range, off-grid mesh communication systems using technologies such as LoRa. It is an excellent project for learning wireless communication, mesh networking, GPS, power management and distributed embedded systems.
GitHub: https://github.com/meshtastic/firmware

24. ESP-IDF Components

ESP-IDF Components provides reusable components for ESP32 development. It is useful for learning how embedded software can be modularized and reused across multiple firmware projects.
GitHub: https://github.com/espressif/esp-idf-components

25. ArduinoJson

ArduinoJson is a lightweight JSON library designed for embedded C++. It is useful when microcontrollers need to exchange structured data with cloud services, APIs, MQTT brokers or other devices.
GitHub: https://github.com/bblanchon/ArduinoJson

26. ESP32 WebSockets

This WebSocket library enables real-time two-way communication between ESP32 devices and web clients. It is useful for dashboards, remote control, live sensor monitoring and connected-device interfaces.
GitHub: https://github.com/Links2004/arduinoWebSockets

27. ESP-NOW

ESP-NOW is a connectionless wireless communication technology from Espressif. It is useful for building fast, low-overhead communication between ESP32 devices without requiring a traditional Wi-Fi network.
GitHub: https://github.com/espressif/esp-now

28. ESP-IDF-lib

ESP-IDF-lib contains reusable drivers and components for sensors and peripherals. It is useful for engineers developing ESP32 projects involving displays, sensors, GPIO expanders and other external hardware.
GitHub: https://github.com/UncleRus/esp-idf-lib

29. NodeMCU

NodeMCU is an open-source firmware ecosystem for ESP8266-based development. It is useful for learning Wi-Fi-enabled embedded devices and rapid IoT experimentation.
GitHub: https://github.com/nodemcu/nodemcu-firmware

30. ESP32 Camera

The ESP32 Camera component provides camera support for ESP32-based systems. It can be used to build low-cost embedded vision, streaming, image-capture and Edge AI prototypes.
GitHub: https://github.com/espressif/esp32-camera

🤖 Embedded AI & TinyML

31. TensorFlow Lite Micro

TensorFlow Lite Micro enables machine-learning inference on microcontrollers and other resource-constrained embedded targets. It is one of the most important projects for learning TinyML, keyword spotting, sensor classification and on-device AI.
GitHub: https://github.com/tensorflow/tflite-micro

32. MCUNet

MCUNet focuses on designing and deploying deep-learning models for microcontrollers with limited memory and compute resources. It is useful for understanding neural-network optimization and efficient MCU inference.
GitHub: https://github.com/mit-han-lab/mcunet

33. CMSIS-NN

CMSIS-NN provides optimized neural-network kernels for Arm Cortex-M processors. It is useful for engineers who want to understand how low-level optimized kernels can improve AI inference performance on MCUs.
GitHub: https://github.com/ARM-software/CMSIS-NN

34. Edge Impulse SDK

The Edge Impulse SDK allows trained machine-learning models to be deployed into embedded applications. It is useful for practical applications such as anomaly detection, keyword spotting, gesture recognition and sensor classification.
GitHub: https://github.com/edgeimpulse/inference-sdk-cpp

35. emlearn

emlearn converts machine-learning models into portable C code for embedded systems. It is particularly useful when you need very small models with low memory requirements on constrained microcontrollers.
GitHub: https://github.com/emlearn/emlearn

36. OnnxStream

OnnxStream focuses on running ONNX models with very limited memory resources. It is useful for exploring highly constrained Edge AI inference and model deployment.
GitHub: https://github.com/vitoplantamura/OnnxStream

37. BitNetMCU

BitNetMCU explores extremely low-bit neural-network inference on microcontrollers. It is useful for learning about quantization and reducing the memory and computational requirements of AI models.
GitHub: https://github.com/cpldcpu/BitNetMCU

38. Z-Ant

Z-Ant focuses on neural-network deployment and optimization for embedded processors. It is useful for engineers exploring AI runtimes, model optimization and efficient embedded inference.
GitHub: https://github.com/ZantFoundation/Z-Ant

39. TinyML Courseware

TinyML Courseware provides educational resources and practical exercises for deploying machine learning on embedded devices. It is useful for engineers who want a structured introduction to TinyML.
GitHub: https://github.com/tinyMLx/courseware

40. Apache TVM

Apache TVM is a machine-learning compiler stack that can optimize models for different hardware targets. It is useful for understanding model compilation, quantization and hardware-aware AI deployment.
GitHub: https://github.com/apache/tvm

👁️ Computer Vision & Edge AI

41. OpenCV

OpenCV is one of the most widely used computer-vision frameworks. Embedded engineers can use it for image processing, object detection, tracking, camera calibration, robotics and real-time vision applications.
GitHub: https://github.com/opencv/opencv

42. Open3D

Open3D provides tools for processing 3D data, point clouds and 3D reconstruction. It is useful for robotics, autonomous vehicles, depth cameras and 3D perception systems.
GitHub: https://github.com/isl-org/Open3D

43. ORB-SLAM3

ORB-SLAM3 is a visual SLAM system that combines camera and inertial information for localization and mapping. It is useful for autonomous robots, drones and navigation systems.
GitHub: https://github.com/UZ-SLAMLab/ORB_SLAM3

44. OpenVINO

OpenVINO provides tools for optimizing and deploying AI models on Intel hardware. It is useful for Edge AI engineers working on real-time inference and hardware-aware model optimization.
GitHub: https://github.com/openvinotoolkit/openvino

45. Ultralytics

Ultralytics provides popular YOLO-based computer-vision models and tools. It is useful for building object-detection, segmentation and tracking applications that can later be optimized for edge hardware.
GitHub: https://github.com/ultralytics/ultralytics

46. MediaPipe

MediaPipe provides real-time perception solutions such as hand tracking, pose estimation and face detection. It is useful for embedded vision, gesture recognition and human-machine interfaces.
GitHub: https://github.com/google-ai-edge/mediapipe

47. GStreamer

GStreamer is a multimedia framework used for building camera and video pipelines. It is particularly valuable in embedded vision systems where camera capture, processing, encoding and streaming need to operate together.
GitHub: https://github.com/GStreamer/gstreamer

48. DeepStream

NVIDIA DeepStream provides tools for building real-time AI video analytics pipelines. It is useful for Jetson and other NVIDIA-based edge systems handling multiple cameras and AI inference.
GitHub: https://github.com/NVIDIA-AI-IOT/deepstream_python_apps

49. CHaiDNN

CHaiDNN is designed for deep-neural-network acceleration on Xilinx FPGA/SoC platforms. It is useful for engineers interested in hardware acceleration and FPGA-based Edge AI.
GitHub: https://github.com/Xilinx/CHaiDNN

50. TensorFlow Lite Micro on Zephyr

Zephyr provides examples integrating TensorFlow Lite Micro with embedded boards, including gesture recognition and optimized inference using CMSIS-NN. This is a particularly useful combination for engineers learning both RTOS and TinyML.
GitHub: https://github.com/zephyrproject-rtos/zephyr

🐧 Embedded Linux

51. Buildroot

Buildroot helps engineers create complete customized Embedded Linux systems for their target hardware. It is useful for learning cross-compilation, root filesystems, package configuration and embedded Linux deployment.
GitHub: https://github.com/buildroot/buildroot

52. OpenEmbedded Core

OpenEmbedded Core forms an important foundation for building customized Linux distributions. It is particularly useful for engineers working with complex embedded products and SoCs.
GitHub: https://github.com/openembedded/openembedded-core

53. U-Boot

U-Boot is one of the most widely used embedded bootloaders. Studying it helps engineers understand boot sequences, hardware initialization, device trees, memory setup and Linux kernel loading.
GitHub: https://github.com/u-boot/u-boot

54. Linux Kernel

The Linux kernel is essential for advanced Embedded Linux development. Studying its driver, scheduling, memory-management and networking subsystems provides deep insight into modern embedded platforms.
GitHub: https://github.com/torvalds/linux

55. BusyBox

BusyBox combines many standard Linux utilities into a small executable suitable for embedded systems. It is useful for building lightweight Linux root filesystems and understanding embedded user-space design.
GitHub: https://github.com/mirror/busybox

56. OpenWrt

OpenWrt is an Embedded Linux distribution focused on networking devices. It is useful for learning network interfaces, routing, firewalling, package management and embedded networking.
GitHub: https://github.com/openwrt/openwrt

57. systemd

systemd manages services and system initialization on many Linux systems. It is useful for understanding boot-time services, dependencies and application management on Embedded Linux devices.
GitHub: https://github.com/systemd/systemd

58. libcamera

libcamera provides a modern camera framework for Linux. It is useful for embedded camera products, robotics, computer vision and hardware-accelerated image pipelines.
GitHub: https://github.com/libcamera-org/libcamera

59. Raspberry Pi Linux

The Raspberry Pi Linux kernel is a practical platform for studying Linux on real hardware. It provides exposure to GPIO, camera, display, networking and peripheral drivers.
GitHub: https://github.com/raspberrypi/linux

60. Raspberry Pi Pico SDK

The Pico SDK provides low-level development support for RP2040 and RP2350 microcontrollers. It is useful for learning embedded C/C++, peripherals, multicore programming and hardware-level control.
GitHub: https://github.com/raspberrypi/pico-sdk

🚗 Automotive & CAN

61. openpilot

openpilot is an open-source driver-assistance system and one of the most interesting large-scale automotive software projects available publicly. It provides exposure to CAN communication, vehicle interfaces, perception, controls and ADAS concepts.
GitHub: https://github.com/commaai/openpilot

62. OpenDBC

OpenDBC contains automotive CAN database information used by open-source automotive projects. It is useful for learning CAN messages, signals, vehicle data and automotive network analysis.
GitHub: https://github.com/commaai/opendbc

63. can-utils

can-utils provides Linux command-line tools for working with CAN interfaces. It is extremely useful for monitoring, logging, sending, receiving and testing CAN traffic.
GitHub: https://github.com/linux-can/can-utils

64. SavvyCAN

SavvyCAN is a CAN-bus analysis application designed for working with automotive and other CAN networks. It is useful for CAN debugging, visualization, analysis and reverse engineering.
GitHub: https://github.com/collin80/SavvyCAN

65. OpenCyphal

OpenCyphal provides communication infrastructure for distributed embedded systems. It is useful for robotics, aerospace and vehicle systems where multiple embedded nodes need reliable communication.
GitHub: https://github.com/OpenCyphal/cyphal

66. libcanard

libcanard is a lightweight implementation of the Cyphal protocol for embedded systems. It is useful for implementing efficient CAN-based communication on resource-constrained microcontrollers.
GitHub: https://github.com/OpenCyphal/libcanard

67. Automotive Grade Linux

Automotive Grade Linux is an open-source platform for automotive Linux systems. It is useful for engineers interested in connected vehicles, infotainment, middleware and Software-Defined Vehicle architectures.
GitHub: https://github.com/automotive-grade-linux/AGL-repo

68. Eclipse uProtocol

uProtocol is designed for communication between software components in distributed automotive and IoT environments. It is useful for understanding modern vehicle middleware and service-oriented architectures.
GitHub: https://github.com/eclipse-uprotocol/up-core-api

69. COVESA

COVESA hosts open-source projects focused on connected vehicles, vehicle data and automotive software architectures. It is useful for engineers exploring modern automotive connectivity and SDV ecosystems.
GitHub: https://github.com/COVESA

70. SocketCAN

SocketCAN is the Linux networking implementation for CAN. It is useful for understanding how CAN controllers and interfaces are integrated into Embedded Linux systems.
GitHub: https://github.com/linux-can

🤖 Robotics & Autonomous Systems

71. ROS 2

ROS 2 is a major robotics middleware platform used for distributed robotic applications. It is useful for learning sensors, perception, communication, control, navigation and autonomous-system architectures.
GitHub: https://github.com/ros2/ros2

72. micro-ROS

micro-ROS brings ROS 2 capabilities to microcontrollers. It is useful for connecting real-time MCU firmware with higher-level robotic systems running on Linux computers.
GitHub: https://github.com/micro-ROS/micro_ros_setup

73. Navigation2

Navigation2 provides navigation capabilities for ROS 2 robots. It is useful for learning localization, path planning, obstacle avoidance and autonomous mobile-robot development.
GitHub: https://github.com/ros-navigation/navigation2

74. PX4 Autopilot

PX4 is an open-source flight-control platform for drones and autonomous vehicles. It provides practical exposure to sensor fusion, IMUs, GPS, control algorithms, real-time software and autonomous flight.
GitHub: https://github.com/PX4/PX4-Autopilot

75. ArduPilot

ArduPilot is a large open-source autopilot platform supporting drones, rovers, boats and other autonomous vehicles. It is an excellent real-world codebase for studying embedded C++, sensors and control systems.
GitHub: https://github.com/ArduPilot/ardupilot

76. Open-RMF

Open-RMF focuses on coordinating multiple robots and the infrastructure around them. It is useful for engineers interested in autonomous warehouses, fleets and multi-robot systems.
GitHub: https://github.com/open-rmf/rmf

77. SLAM Toolbox

SLAM Toolbox provides mapping and localization functionality for ROS 2 robots. It is useful for learning how robots estimate their position while constructing maps of their environment.
GitHub: https://github.com/SteveMacenski/slam_toolbox

78. MoveIt 2

MoveIt 2 provides motion-planning capabilities for robotic arms. It is useful for learning robot kinematics, trajectory planning, manipulation and integration with ROS 2.
GitHub: https://github.com/moveit/moveit2

79. Gazebo

Gazebo is a robotics simulation platform that allows engineers to test robots and sensors before deploying them on physical hardware. It is useful for simulation-based development and autonomous-system testing.
GitHub: https://github.com/gazebosim/gz-sim

80. OpenVINS

OpenVINS implements visual-inertial navigation using cameras and IMUs. It is useful for learning sensor fusion, state estimation and navigation for drones and autonomous robots.
GitHub: https://github.com/rpng/open_vins

🛠️ Debugging, Testing & Simulation

81. OpenOCD

OpenOCD provides debugging and programming support through interfaces such as JTAG and SWD. It is essential for learning professional embedded debugging, firmware flashing and target inspection.
GitHub: https://github.com/openocd-org/openocd

82. GDB

GDB is one of the most important debugging tools for C/C++ and embedded development. It allows engineers to investigate registers, memory, stack traces, breakpoints, watchpoints and runtime behavior.
GitHub: https://github.com/bminor/binutils-gdb

83. Renode

Renode allows engineers to simulate complete embedded systems and execute firmware without always requiring physical boards. It is particularly useful for automated testing, CI/CD and hardware-independent firmware development.
GitHub: https://github.com/renode/renode

84. QEMU

QEMU provides processor and complete-system emulation. It is useful for testing Embedded Linux, operating systems, bootloaders and firmware in virtual environments before deploying to hardware.
GitHub: https://github.com/qemu/qemu

85. Black Magic Debug

Black Magic Debug provides debugging capabilities for embedded targets and ARM microcontrollers. It is useful for learning low-level JTAG/SWD debugging and firmware development workflows.
GitHub: https://github.com/blackmagic-debug/blackmagic

86. Sigrok

Sigrok is an open-source ecosystem for digital measurement equipment. It is useful for embedded engineers analyzing UART, SPI, I2C, CAN and other digital signals with logic analyzers.
GitHub: https://github.com/sigrokproject/sigrok

87. PulseView

PulseView provides a graphical interface for logic-analyzer data. It is useful for visually inspecting digital protocols and debugging communication between an MCU and external peripherals.
GitHub: https://github.com/sigrokproject/pulseview

88. Flashrom

Flashrom provides tools for reading, writing, verifying and identifying flash memory devices. It is useful for firmware engineers and hardware engineers working with low-level flash programming.
GitHub: https://github.com/flashrom/flashrom

89. CppUTest

CppUTest is a unit-testing framework for C and C++. It is useful for creating automated tests for embedded drivers, algorithms and application modules before they reach hardware.
GitHub: https://github.com/cpputest/cpputest

90. Unity Test Framework

Unity is a lightweight unit-testing framework designed for C projects. It is particularly useful for embedded firmware because it has a small footprint and can be integrated into automated testing workflows.
GitHub: https://github.com/ThrowTheSwitch/Unity

⚙️ FPGA, RTL & Hardware Acceleration

91. LiteX

LiteX is a framework for building FPGA-based systems-on-chip. It is useful for learning FPGA CPUs, buses, peripherals, memory systems and hardware/software co-design.
GitHub: https://github.com/enjoy-digital/litex

92. LitePCIe

LitePCIe provides PCI Express functionality for FPGA systems. It is useful for engineers working on high-speed FPGA data transfer and hardware accelerator applications.
GitHub: https://github.com/enjoy-digital/litepcie

93. LiteEth

LiteEth provides Ethernet functionality for FPGA-based systems. It is useful for learning FPGA networking, packet processing and high-speed embedded communication.
GitHub: https://github.com/enjoy-digital/liteeth

94. Verilator

Verilator is a high-performance Verilog/SystemVerilog simulator. It is widely useful for RTL verification, FPGA development and hardware/software co-simulation.
GitHub: https://github.com/verilator/verilator

95. Yosys

Yosys is an open-source RTL synthesis framework. It allows engineers to explore how HDL designs are synthesized and optimized for hardware implementation.
GitHub: https://github.com/YosysHQ/yosys

96. nextpnr

nextpnr performs FPGA place-and-route after synthesis. It is useful for understanding how RTL designs are mapped onto actual FPGA resources.
GitHub: https://github.com/YosysHQ/nextpnr

97. OpenLane

OpenLane provides an automated RTL-to-GDSII ASIC design flow. It is useful for engineers interested in open-source semiconductor design and digital chip implementation.
GitHub: https://github.com/efabless/openlane2

98. OpenROAD

OpenROAD provides an open-source digital physical-design flow. It is useful for learning how synthesized digital designs progress through placement, routing and physical implementation.
GitHub: https://github.com/The-OpenROAD-Project/OpenROAD

99. Chisel

Chisel is a hardware-construction language used to generate digital hardware designs. It is useful for learning modern RTL development, parameterized hardware and hardware generators.
GitHub: https://github.com/chipsalliance/chisel

100. Embedded Rust Book

The Embedded Rust Book provides a practical introduction to developing firmware using Rust. It is useful for engineers exploring memory safety, concurrency and modern alternatives to traditional embedded C/C++ development.
GitHub: https://github.com/rust-embedded/book

101. LVGL

LVGL (Light and Versatile Graphics Library) is an open-source embedded GUI framework for creating professional displays, dashboards, touch-screen HMIs, gauges, charts and control panels on MCUs and MPUs. It supports multiple display types and input devices and can be integrated with platforms such as ESP-IDF, Zephyr, NuttX and RT-Thread.
GitHub: https://github.com/lvgl/lvgl

Best 10 to start with

Zephyr RTOS → FreeRTOS → ESP-IDF → Xiaozhi ESP32 → TensorFlow Lite Micro → LVGL → openpilot → Buildroot → Renode → PX4

This combination gives you exposure to RTOS + MCU + drivers + AI + IoT + Embedded Linux + automotive + robotics + testing, which is a very strong portfolio combination for modern embedded engineering. The Zephyr ecosystem also has direct examples combining RTOS development with TFLite Micro and optimized CMSIS-NN inference, making the RTOS + Edge AI combination particularly relevant.

Also, read: