Projects sharing features with Arduino Cli

Crab is a memory-safe systems programming language and ahead-of-time compiler designed for high-performance software. It utilizes a type system based on strict ownership and borrowing rules to prevent memory access errors at compile time. The toolchain includes an automated documentation generator that produces technical reference manuals and API guides by parsing structured source code annotations. It also features a dependency management tool to resolve external library graphs and ensure consistent project builds. The project covers software build automation, static type checking, and mult

CircuitPython is a specialized derivative of the MicroPython runtime designed as an embedded Python interpreter for microcontrollers. It provides a high-level language environment that allows for direct hardware access through a dedicated hardware abstraction layer and a Python microcontroller runtime. The project is distinguished by firmware that exposes the microcontroller as a native USB mass storage device. This allows users to edit code directly on the device as if it were a removable drive, eliminating the need for specialized flashing tools and enabling filesystem-triggered code reload

Cargo is the official build system and package manager for the Rust programming language. It provides a unified command-line interface that orchestrates the entire development lifecycle, including compiling source code, managing complex dependency graphs, running tests, and distributing packages through a centralized registry. By utilizing declarative manifest files, it ensures that builds remain reproducible and consistent across different environments. The tool distinguishes itself through its deep integration with the Rust compiler and its sophisticated approach to project management. It f

Theos is a cross-platform mobile development toolchain and build system designed for compiling and packaging software for mobile operating systems. It functions as a system tweak kit and runtime hooking framework, allowing developers to create modifications that alter the internal behavior of mobile OS environments. The project distinguishes itself by providing specialized preprocessor syntax that generates low-level API calls, removing the boilerplate code typically required for function and method hooking. It enables dynamic runtime method swizzling and class extensions, allowing developers

PlatformIO Core is a toolset for embedded software development that manages the compilation, flashing, and debugging of firmware for various microcontroller targets. It provides a cross-platform build system that automates the process of transforming source code into binaries and transferring them to hardware via serial protocols. The system uses a plugin-based architecture to extend hardware platform support and incorporates a manifest-driven approach to resolve and install the specific toolchains, frameworks, and libraries required for different board definitions. Capabilities cover the fu

c3c is the compiler for the C3 programming language, transforming source code into executable binaries, static libraries, or dynamic libraries using an LLVM backend. It implements a system based on result-based error handling, scoped memory pooling, and a semantic macro system. The compiler provides first-class support for hardware-backed SIMD vectors that map directly to processor instructions and enables runtime polymorphism through interface-based dynamic dispatch. The project covers a broad set of low-level capabilities, including manual and pooled memory management, inline assembly inte

Blackmagic is a GDB server for embedded hardware that translates GDB remote protocol messages into JTAG and SWD commands. It functions as an ARM and RISC-V debugger and hardware debug probe manager, enabling users to inspect memory, control execution, and manage registers on ARM Cortex and RISC-V cores. The project distinguishes itself by acting as a remote hardware debugging bridge that can stream GDB server traffic over TCP/IP to control physical hardware from a remote machine. It also provides a JTAG and SWD interface to connect host computers to target hardware and serves as an embedded f

TinyGo is a specialized compiler and development toolkit designed to bring the Go programming language to resource-constrained microcontrollers and WebAssembly environments. It provides a bare-metal runtime environment that enables high-level code execution without the need for a traditional operating system, utilizing an LLVM-based backend to generate efficient machine instructions. The project distinguishes itself through aggressive optimization techniques tailored for small hardware, including a static memory allocation strategy and whole-program dead code elimination that significantly re

NuttX is a POSIX-compliant real-time operating system designed for microcontrollers ranging from 8-bit to 64-bit architectures. It provides a deterministic execution environment with a real-time task scheduler and a POSIX embedded kernel to ensure portable code execution across diverse hardware targets. The project distinguishes itself through a comprehensive hardware abstraction layer that provides standardized drivers for I2C, SPI, CAN, and USB across various semiconductor chipsets. It also features an embedded networking stack supporting TCP, UDP, IPv4, and IPv6, alongside industrial proto

Vimspector is a visual debugger integration for Vim that enables developers to step through code and inspect program state without leaving the editor. It utilizes the Debug Adapter Protocol to provide a unified interface for debugging multiple programming languages through various debug adapters. The project distinguishes itself by supporting low-level analysis and specialized environments, including bare metal hardware debugging for microcontrollers and the ability to perform disassembly analysis and process memory dumping. It also provides remote debugging capabilities by proxying requests

stlink is a toolset for ARM Cortex-M flashing, firmware management, and debug server operations, with specific support for STM32 microcontrollers. It provides an ARM Cortex-M flash programmer for writing binary and hex files, an ITM trace logger for real-time instrumentation data, and a SWD/JTAG debug server. The project includes a graphical user interface for managing MCU firmware and exporting memory, as well as a remote server that allows external debuggers to control execution and inspect registers on target hardware. The toolset covers microcontroller memory management through flash era

Johnny-Five is a JavaScript robotics framework and microcontroller hardware interface designed for programming robots and IoT devices. It provides a standardized library for managing pins, motors, and displays across various microcontroller platforms, allowing developers to control sensors and actuators using a consistent JavaScript API. The framework is distinguished by its use of a plugin-based hardware abstraction system, which enables communication with diverse hardware platforms and protocols. It supports real-time hardware manipulation and debugging through a read-eval-print loop that a

This project is an implementation of the Arduino framework for ESP32 microcontrollers, providing a core that enables firmware development using a familiar API. It functions as a microcontroller hardware abstraction layer and a firmware toolchain integration, bridging external development environments to the hardware for compilation and flashing. The system includes an embedded real-time operating system wrapper to manage multi-core execution and task scheduling, alongside a wireless communication suite for TCP/IP networking and Bluetooth Low Energy. It distinguishes itself by providing an obj

RubyGems is a package manager for the Ruby language, serving as a tool for packaging, distributing, and installing libraries and software extensions. It functions as a dependency resolver and registry client, managing the installation of required libraries and their recursive dependencies to ensure consistent environments across development and production. The system handles the complete package lifecycle, including the building of distributable archives, the compilation of native C extensions for high-performance system integration, and the publishing of stable or prerelease versions to regi

This project is a comprehensive, community-maintained knowledge base and toolkit designed for competitive programming. It serves as a centralized repository for algorithmic theory, data structures, and mathematical techniques, providing a structured reference for informatics and collegiate programming competitions. The project distinguishes itself by integrating educational content with a robust suite of automation utilities. It provides a complete workflow for competitive programming, including tools for automated test case generation, solution verification, and direct interaction with onlin

rustup is a programming language toolchain manager that automates the installation, versioning, and configuration of the Rust compiler and its associated build tools. It serves as a toolchain installer and version manager, enabling the deployment of the language ecosystem across different operating systems. The system manages multiple compiler versions across stable, beta, and nightly release channels, allowing users to switch between these versions to meet different environment requirements. It also functions as a cross-compilation manager by installing pre-compiled standard libraries to bui

This project is a multi-language compiler collection and cross-platform toolchain used to translate source code from various programming languages into optimized machine code for different hardware architectures. It provides a suite of tools including an optimizing compiler backend, a machine code generator, and a comprehensive runtime library suite that implements necessary execution environments and support functions. The system utilizes a multi-pass compilation pipeline and pluggable language front-ends to process source code into intermediate representations. It distinguishes itself throu

ChezScheme is a compiler and runtime environment for the Scheme programming language that transforms source code into optimized machine binaries. It serves as a high-performance implementation of the language, producing executable machine code for execution on physical hardware. The project features a native machine code compiler, a read-eval-print loop for executing and editing multi-line expressions in real time via a shell, and a generational garbage collected runtime for automatic memory management. It also includes a foreign function interface for integrating external C libraries and lan

STM32duino-bootloader is a firmware bootloader and microcontroller firmware flasher designed for STM32 microcontrollers. Operating as a low-level startup routine, it initializes microcontroller peripherals, handles USB communication routines, and launches user applications upon system reset. This enables direct USB programming and application execution on the hardware without requiring external hardware programmers. The bootloader supports firmware updates by presenting the microcontroller as a USB storage device that accepts binary drag-and-drop file transfers. It writes incoming firmware by

This project is a hardware core and board support package that integrates STM32 microcontrollers into the Arduino development environment. It functions as an embedded systems development tool, bridging high-level programming workflows with ARM Cortex-M microcontroller architectures. The core provides the necessary configuration files and libraries to enable the compilation and deployment of firmware directly onto STM32 hardware. By mapping standard programming functions to specific microcontroller register operations, it ensures consistent behavior across different hardware platforms while ut

pyserial is a cross-platform Python library for reading and writing binary data to serial ports and hardware devices. It provides a serial port enumeration tool for identifying available hardware and retrieving device path metadata. The project includes a network implementation for controlling remote serial port functions and signal lines over TCP/IP via the RFC 2217 standard. It also features a serial-to-TCP bridge for forwarding raw data between local ports and network sockets, as well as a specialized interface for managing half-duplex RS485 communication and RTS toggling. The library cov

Terminus is a multifunctional terminal emulator and connection manager designed for managing remote server shells and local hardware device connections. It functions as a customizable shell interface and a cross-platform serial client, supporting communication via SSH, Telnet, and serial ports. The application features an extensible system that allows the integration of third-party plugins, such as AI assistants and additional connectivity tools. It includes a dedicated SSH connection manager with support for jump hosts, port forwarding, and the storage of sensitive credentials within encrypt

Moon is a monorepo build system and task runner designed to orchestrate complex projects with multiple packages. It functions as a dependency graph orchestrator that executes build targets in topological order and utilizes input hashing to cache results and skip redundant work. The project features a polyglot toolchain manager that automates the installation and versioning of language runtimes and CLI tools to ensure environment consistency. It also includes a plugin framework based on WebAssembly, allowing developers to extend build logic and toolchain behavior using any supported language.

The .NET Compiler Platform is a collection of open-source APIs for C# and Visual Basic that provides deep code analysis, refactoring, and automated source code generation. It serves as the core infrastructure for building development tools, offering a platform to inspect, modify, and understand source code through immutable syntax trees and semantic models. The platform distinguishes itself by providing full-fidelity syntax trees that preserve every character of source code, including whitespace and comments, alongside an incremental compilation pipeline that enables near-instant feedback dur

MoonBit is a programming language compiler and build system designed to translate source code into high-performance binaries for web, browser, and native environments. It provides a unified toolchain that manages the entire development lifecycle, from source code compilation and dependency management to the final bundling of applications. The platform distinguishes itself through a modular architecture that enables cross-environment logic sharing, allowing developers to maintain a single codebase that targets both WebAssembly and native machine code. By utilizing a strongly-typed intermediate

F# is a strongly typed, functional programming language and compiler for the .NET ecosystem. It transforms functional source code into Common Intermediate Language for execution on the .NET runtime and provides a foundational core library of primitive types and functions. The language emphasizes immutability and uses a static, constraint-based type inference system to automatically determine variable types without requiring explicit user annotations. It also functions as a Language Server Protocol provider, exposing compiler logic through a service-based API to deliver real-time code analysis

Haste-compiler is a source-to-source compiler and web framework that translates Haskell source code into JavaScript programs for execution in web browsers and server environments. It enables the creation of unified web applications from a single type-safe codebase, automatically generating communicating client and server binaries while preserving static type guarantees across tiers. The system translates high-level code through an existing compiler infrastructure paired with custom code generators, supported by an AST-based optimization and minification pipeline for producing lean deployment