This repository is the complete open-source hardware and software stack for the Roboto Origin bipedal robot, formerly known as Atom01. It is a hybrid monorepo covering mechanical design (CAD files, 3D printing, BOMs), electronics (PCB designs, firmware for a USB2CAN board), low-level ROS2 control (motor drivers, IMU, camera, inference), simulation and reinforcement learning training (roboparty_train with Isaac Sim/MuJoCo and PPO/AMP algorithms), navigation (LiDAR localization, UWB, path planning), and XR teleoperation. The repository is organized into multiple modules, each with its own build system (CMake, Zephyr, Python). The dominant character is an application (a robot system), but it includes a substantial data_research component in the training module where RL policies are trained using motion capture data. The codebase is well-structured, actively maintained, and provides a complete recipe for building and deploying a humanoid robot from scratch.
Elevation Mapping CuPy is a GPU-accelerated elevation mapping system for legged robots, integrating point cloud registration, ray casting, multi-modal semantic fusion (geometry, RGB, semantics, deep features), and convex plane decomposition. It is built as a ROS Noetic package (ROS1) with a mixture of C++ (using pybind11) and Python (CuPy) nodes. The system ingests point clouds and images, processes them through configurable fusion algorithms, and outputs elevation maps with multiple layers (elevation, variance, traversability, semantic classes). It also includes a learning-based traversability filter supporting both Chainer and PyTorch backends, and a plane segmentation pipeline (CGAL/RANSAC) that converts elevation maps into planar terrain regions for motion planning. The architecture is modular with a plugin system for post-processing filters and a fusion manager for multiple data sources. While the core is tightly integrated with ROS1 and CUDA, several components (plugin manager, fusion framework, CuPy kernel compilation pattern, traversability filter) exhibit high craftsmanship and potential for reuse in other GPU-accelerated robotics projects. The codebase is well-tested and documented, but its dependency on ROS Noetic and specific CUDA versions limits portability and creates medium technical drift.
FluxVLA is a comprehensive, config-driven framework for training, evaluating, and deploying Vision-Language-Action (VLA) models for robotic manipulation. It supports multiple VLA architectures (OpenVLA, Pi0/Pi0.5, GR00T, Cosmos3, DreamZero, etc.) and robot platforms (LIBERO simulation, RoboCasa, Franka, UR3, ALOHA, Oli humanoid, Tron2). The codebase provides a modular pipeline with registries and builders for datasets, transforms, models (backbones, heads, projectors), optimizers, collators, and inference runners. Production capabilities include distributed training (FSDP/DDP), real-time ROS inference, custom CUDA/Triton kernels for performance, and evaluation with metrics reporting to Feishu. While primarily an engineering framework for applied robot learning, it also contains research contributions such as flow-matching action heads, reward models (ARM, SARM), and real-time chunking (RTC) guidance. The architecture is clean and extensible, though config proliferation and vendored third-party code introduce maintenance overhead.
The solo-cli is a command-line tool designed to deploy and manage Physical AI systems on local hardware. It integrates functionalities for serving large language models (via Ollama, vLLM, or llama.cpp), controlling robotic arms (through the LeRobot framework), authenticating with a custom model hub (Solo Hub), and fine-tuning models using external datasets. The application features a modular command structure with lazy-loaded dependencies to optimize startup time, cross-platform hardware detection for automated backend selection, and a layered configuration system. Additional utilities include Docker management, system information gathering, and filesystem-safe string handling for robotics data operations. The project also includes example implementations of Model Context Protocol (MCP) servers for various domains, demonstrating how to extend the CLI's capabilities for specialized AI workflows.
The repository implements LLaVA-VLA, a Vision-Language-Action model for robotic manipulation tasks. It extends the LLaVA framework to predict action sequences from visual inputs, proprioceptive state, and language instructions using a diffusion-based action head. The system includes training pipelines for fine-tuning on datasets like CALVIN, inference servers (Flask and Gradio) for real-time robot control, and evaluation tools for benchmarks. The architecture features modular vision encoders, projectors, and resamplers with factory patterns for flexibility, action tokenization for discrete action prediction, and integration with PEFT/DeepSpeed for efficient training.
This repository provides a comprehensive, production-grade Field-Oriented Control (FOC) library for Permanent Magnet Synchronous Motors (PMSM) targeting embedded microcontrollers (STM32G4, CH32V3). It is written in C and organized into modular algorithm files covering coordinate transforms (Clarke, Park), PWM modulation (SVPWM, SPWM), multiple control strategies (PID, LADRC, SMC, STA), sensor feedback (encoder, Hall, sensorless observers like HFI, SMO, NLFO), and advanced features (MTPA, field weakening, harmonic suppression, cogging calibration, dead-time compensation, feedforward, disturbance observer, parameter identification). The architecture is driven by interrupt-based control loops (high-frequency current loop, low-frequency state machine, and serial communication loop) with compile-time configuration via macro switches and user-supplied hardware abstraction layers. The repository also includes open-source hardware designs (schematic and PCB for a robot-joint motor driver), a QT-based host computer application, Simulink simulation models, and a complete STM32G4 example project. Although the library contains multiple coexisting versions and v4.0.0 is partially incomplete, the core modules are well-crafted, independently reusable, and demonstrate advanced control theory implementation suitable for robotics, drones, industrial servos, and electric tools.
OrbbecSDK is a cross-platform C/C++ software development kit for Orbbec 3D cameras, supporting depth, color, infrared, and IMU sensors. It provides both a high-level Pipeline API for easy stream management and a low-level Device/Sensor API for fine-grained control. The architecture is library-based with a C API (ObSensor.h) and a C++ wrapper (ObSensor.hpp), following a consistent pattern of context creation, device enumeration, stream configuration, frame acquisition, and post-processing via composable filters. Key entry points include Context (device discovery), Pipeline (streaming), Device (property control), and Filter (alignment, point cloud generation, noise removal, etc.). Data flows involve configuring stream profiles, starting the pipeline, receiving frames (depth, color, IR, IMU), applying filters (e.g., depth-to-color alignment, HDR merge, spatial/temporal filtering), and optionally recording or replaying streams. External dependencies include OpenCV for example visualizations, cJSON for multi-device synchronization configuration, and platform-specific USB drivers. The SDK is used in robotics, AR/VR, industrial inspection, and 3D scanning applications.
PythonRobotics is a large collection of robotics algorithms implemented in Python, designed primarily for educational purposes and as a companion to a textbook. It covers a wide range of robotics domains including localization (EKF, particle filter, histogram filter), mapping (grid maps, NDT, clustering), SLAM (EKF SLAM, FastSLAM, GraphSLAM), path planning (A*, Dijkstra, RRT variants, PRM, DWA, Frenet, etc.), path tracking (Stanley, LQR, MPC, pure pursuit), arm navigation (inverse kinematics, RRT for arms), aerial navigation (drone trajectory, rocket landing), bipedal walking, inverted pendulum control, and mission planning (state machines, behavior trees). Each algorithm is implemented as a standalone script with a main() function that runs a simulation and visualizes results using matplotlib. The code is not packaged as a library and is not intended for production use; it is a learning resource with clear, readable implementations that reference academic papers. The repository includes extensive documentation in Sphinx RST format, CI/CD pipelines, and a test suite that runs each demo without animation.
FarmBot Web App is the cloud-based control panel for FarmBot, an open-source CNC farming robot. It provides a full-stack web application (Rails API + React/TypeScript SPA) for managing devices, creating automated sequences via a visual CeleryScript AST editor, scheduling farm events, monitoring telemetry and logs, managing plants/weeds/tools, and viewing real-time 2D/3D garden maps. The backend is a monolithic Rails app with PostgreSQL, RabbitMQ/MQTT for device communication, and DelayedJob for background processing. The frontend is a complex Redux SPA with extensive 3D visualization using Three.js. The system supports multiple hardware variants and includes firmware update management, camera calibration, and AI-assisted feedback. The codebase is actively developed with a large test suite, but exhibits some technical debt like legacy AST storage paths, future-dated migrations, and heavy mocking in tests.
Despite being classified as application-oriented, henki_ros2_best_practices contains no executable software. It is a documentation/standards repository: a single, carefully authored Markdown document (henki_ros2_best_practices.md) codifying architecture and clean-code guidelines for ROS 2 development, plus a README explaining how to integrate the document into AI coding workflows (e.g., Claude Code via CLAUDE.md) and a pointer to a companion examples repo comparing agent-generated ROS 2 packages with and without the practices applied. The actual deliverable is a concise, opinionated standards document covering node single-responsibility, separation of application logic from ROS 2 communication, launch file conventions (XML preferred), YAML config-based parameter handling, throttled logging, semantic custom message interfaces in '_msgs' packages, service-vs-action selection with enum-style error codes, C++ for performance-critical loops, SingleThreadedExecutor preference, rosdep/vcs-tool dependency management, package documentation requirements, and unit-test-first strategies that avoid flaky ROS communication sleeps. In production, this repository functions as a knowledge artifact rather than a running system: humans read it as a reference, and AI coding agents consume it as an enforced standard when generating ROS 2 packages. There are no API endpoints, data flows, or runtime dependencies; its 'architecture' is the structure and specificity of the guidelines themselves. The document is self-contained and could be dropped into any ROS 2 team's repository or agent configuration with minimal adaptation, making it a genuinely reusable engineering asset despite the complete absence of code.
EasySpider is a visual, no-code web scraping tool that combines an Electron desktop application, a Chrome browser extension, and a Python execution engine. Users design scraping workflows via a flowchart-based UI (Vue.js) where they define steps like opening pages, clicking elements, extracting data, looping, and conditional branching. The task definitions are saved as JSON graphs. The Python backend (ExecuteStage) loads these graphs and drives Chrome using Selenium with an undetected-chromedriver fork to evade bot detection. Extracted data can be written to CSV, Excel, JSON, or MySQL. The tool also includes OCR support (ddddocr), custom JavaScript/Python execution, and Cloudflare bypass capabilities. The architecture is a hybrid desktop app with a local HTTP server (Express) that spawns executor processes and communicates via WebSocket. The Chrome extension assists in element selection and XPath generation. While the tool is functional and popular (44k+ stars), the codebase exhibits significant duplication (e.g., identical task files across platform directories, duplicated Bootstrap and content scripts), hardcoded paths, monolithic executor scripts, and mixed-language strings. Several experimental modules (LLM, federated learning) are present but not integrated. The project is actively maintained with recent commits and packaging scripts, but technical debt and drift (Bootstrap 4, Vue 2, pinned Python dependencies) are moderate.
Microsoft Magma is a research codebase for a single large multimodal vision-language-action (VLA) foundation model, as opposed to a general-purpose application. The core is an 8B-parameter model built on LLaMA-3-8B-Instruct with a ConvNeXt vision encoder, capable of understanding images/video and producing both textual responses and discretized robot/UI actions. The repository contains the full training stack: model definitions, data preprocessing, dataset-specific constructors, mixed RLDS/PyTorch data loaders, action tokenization, DeepSpeed training configs, and evaluation hooks for robotics benchmarks like LIBERO and SimplerEnv. It also ships FastAPI servers and demo agents for UI automation and robot trajectory planning, but these are secondary to the model training and data pipeline core, making this a hybrid repo with a dominant data-research character. The data lineage is central to the project. Raw heterogeneous datasets—Open X-Embodiment, Ego4D, EpicKitchen, SeeClick, LLaVA, and the in-house Magma-820K—are normalized into a unified multimodal conversation format via per-dataset Constructor subclasses. Visual point tracks from CoTracker2 are clustered, quantized, and rendered as 'Trace-of-Mark' overlays; bounding boxes and labels are rendered as 'Set-of-Mark' overlays. Continuous robot actions are discretized into token IDs aligned with the LLM vocabulary, allowing a standard causal LM objective to train action prediction alongside visual understanding. The resulting model can be deployed via the included FastAPI server for interactive inference. Reproducing the full pipeline requires access to gated or proprietary datasets, CoTracker2 checkpoints, a custom transformers fork, and significant GPU resources, so end-to-end reproduction is not turnkey, though inference on the released HuggingFace checkpoint is more accessible.
IBM TJBot is a Raspberry Pi-based robotics application that interacts with IBM Watson AI services through various 'recipes'. Each recipe demonstrates a different AI capability: conversation (chatbot using Watson Assistant, Speech to Text, and Text to Speech), sentiment analysis (monitoring Twitter tone and changing LED color), speech to text (voice-controlled LED), and translation (speech-to-speech language translation). The architecture consists of a core TJBot library that abstracts hardware and service interactions, with each recipe being a standalone Node.js application. Key entry points are the recipe-specific JavaScript files (conversation.js, sentiment.js, stt.js, translator.js) and the bootstrap script for Raspberry Pi setup. Data flows involve capturing input (audio, Twitter stream), processing through Watson services, and triggering hardware actions (LED, servo, speaker) based on results.
The devoxx4kids/materials repository is a collection of educational resources designed for conducting workshops that teach children and teenagers about programming, robotics, electronics, and game development. It includes a wide variety of workshop materials such as slide presentations (in PowerPoint, PDF, and Key formats), lesson plans, code examples, and hands-on activity guides. The workshops cover topics ranging from basic programming with Scratch and Arduino to more advanced subjects like Minecraft modding, Android app development, and Internet of Things projects using platforms like Tinkerforge and Raspberry Pi. While the repository does not represent a single software application, it contains numerous runnable code examples that are used as teaching aids during the workshops. These include complete Android projects, Arduino sketches, Minecraft mods (using Forge), and Scratch projects. The materials are organized by workshop topic and often include translations in multiple languages (English, Dutch, French, German, etc.), reflecting the international nature of the Devoxx4Kids initiative. One notable reusable component is the Android project structure found in the workshops/Android directory, which demonstrates a well-organized Gradle-based build setup with proper source organization, resource management, and unit testing. This component can serve as a template for creating new Android applications. The repository also shows reuse of the Reveal.js HTML presentation framework across multiple workshops (such as Calliope and Flappybird), indicating a pattern for creating consistent, web-based slide decks. The repository appears to be actively maintained, with a recent commit (as of the provided data) and ongoing community interest (as evidenced by stars and forks). Technical dependencies appear to be up to date, and the materials are generally functional and suitable for their educational purpose, though they prioritize simplicity and clarity over advanced software engineering practices.
Caesar.jl is a comprehensive Julia library for non-Gaussian, multimodal factor graph inference primarily targeting SLAM (Simultaneous Localization and Mapping) and robot perception. It implements the mm-iSAMv2 algorithm, supporting both parametric and non-parametric belief representations (KDE), incremental smoothing and mapping, multi-hypothesis data association, and on-manifold inference. The library provides a rich set of variable and factor types (e.g., Pose2, Point2, BearingRange, Pose2Pose2) and integrates with various sensor modalities via weak extensions: AprilTags, image features, point clouds (PCL), beamforming (synthetic aperture sonar), and ZMQ-based multi-language services. The architecture is a monolithic Julia package with a clear public API (ExportAPI.jl) and a factor graph construction pattern (initfg, addVariable!, addFactor!, solveTree!). It relies heavily on the external IncrementalInference.jl, RoME.jl, and DistributedFactorGraphs.jl packages. While the core framework is production-caliber, the repository includes a large number of experimental and research examples (marine, wheeled, aerial) that are often unmaintained, resulting in moderate technical drift. The library is actively maintained (CI, CompatHelper, TagBot) but contains deprecated APIs and Julia version sensitivity.
This repository implements a hierarchical controller for quadruped locomotion that combines a high-level reinforcement learning policy with a low-level model predictive controller (MPC). The RL policy dynamically predicts weight parameters for the MPC, which computes optimal ground reaction forces and joint torques. The codebase includes Isaac Gym training environments for the Unitree A1, Go1, and Aliengo robots, along with a custom C++ MPC solver (OSQP-based) and a finite state machine for robust transient handling. While primarily a research project that bridges RL and MPC for legged robots, it also provides reusable robotics components such as state estimators, leg controllers, gait pattern generators, and foot swing trajectory planners. The work is based on the MIT Cheetah software and includes detailed development logs and configuration files for reproducible experiments.
This repository contains the open-source hardware design for the DEV-G2-NANO development board, created by Theta Machines LLC. It is a KiCad v10 project (rev 0.1) targeting an NXP i.MX RT1171 dual-core MCU (Cortex-M7/M4) with a companion Kinetis KL26 for DAPLink debug. The board integrates a MAYA-W166-00B Wi-Fi/BT module, an LSM6DSV IMU, an LIS2MDL magnetometer, and an RTMC-G2-4IQ48 motion controller, making it suitable for robotics and real-time control applications. The design is organized into hierarchical schematics (power, configuration, user I/O) with custom symbols and footprints. It is licensed under CERN-OHL-P-2.0, allowing commercial use. Note: This is a hardware design repository, not software; the analysis criteria have been adapted accordingly.
This repository is the public release of the SLAM Handbook, a comprehensive book on Simultaneous Localization and Mapping (SLAM) to be published by Cambridge University Press. It contains the book manuscript (main.pdf), LaTeX style files for acronyms and bibliography strings, and a bug report template. The repository is primarily a document project rather than a software application, but the LaTeX infrastructure (SH_acronyms.sty and SH_string.bib) serves as a reusable library for typesetting SLAM-related documents. The book covers foundations, practical implementations, and spatial AI, with contributions from numerous experts. The repository is actively maintained with incremental releases and community feedback mechanisms via issues and discussions.
SimART is an open-source simulation platform for wireless communication and sensing research, integrating ray-tracing (Sionna RT), 3D visualization (VTK/Qt), drone simulation (AirSim/Unreal Engine), and ROS1 for data streaming. The system provides a desktop GUI (C++/Qt5) that loads 3D scenes from files, OpenStreetMap, or AirSim, and orchestrates real-time or offline radio propagation simulations. It generates channel knowledge maps (CKMs), beam codebooks, and system-level metrics (SINR, BLER, MCS), and supports machine learning-based beam selection via a DeepSense predictor. The platform is designed for researchers prototyping algorithms for UAV communications, beamforming, and link adaptation. While the codebase is functionally rich and modular in parts (scene providers, transform manager, socket workers), it suffers from significant technical drift: it depends on ROS1 (end-of-life), Unreal Engine 4.27 (discontinued), Qt5, and legacy VTK APIs. The C++ code contains large monolithic files (e.g., OsmSceneProvider.cpp ~1100 lines) and duplication between C++ and Python transform logic. There are no automated tests, and many configuration files lack schema validation. Despite these issues, several components (blender scripts, beam codebook utilities, scene provider interface) are well-isolated and could be reused in other projects with minimal adaptation.
This repository provides two LiDAR degeneracy datasets (tunnel and fog) in ROS bag format, hosted on Hugging Face. It includes detailed metadata about the sensors (IMU, LiDAR, radar), their extrinsics, topics, and rates. The datasets are intended for research in LiDAR-radar-inertial fusion for challenging environments. The repository contains no code for processing the data, only documentation and links to the raw data.