Welcome to the RAMMP (Robotic Assistive Mobility and Manipulation Platform) GitHub organization! This organization hosts the open-source software for next-generation assistive robotics.

Our mission is to dramatically lower the barrier to creating advanced, reliable, robust, and cost-effective next-generation medical robotics by providing free, open-source tools and middleware that enable developers worldwide to build innovative assistive technology.

RAMMP consists of two major open-source systems:

A cross-platform middleware framework that provides abstractions, drivers, and services for building assistive technology applications across diverse hardware platforms—from low-power microcontrollers to high-performance computing systems, mobile devices, and wearables.

Key Features:

• Platform-agnostic (ESP32, Jetson, iOS, Android, WatchOS, Windows, macOS, Linux)
• Real-time capable for time-critical control
• Built-in security and safety mechanisms
• Modular, composable architecture
• ROS2 interoperability (via bridge)

A comprehensive simulation platform for developing, testing, and validating assistive robotics systems before deploying to physical hardware.

Key Features:

• High-fidelity physics simulation (rigid body, soft body, specialized biomechanics)
• Hardware-in-the-loop (HIL) capabilities
• Digital twin framework
• AI/ML training data generation
• ATOS integration for seamless sim-to-hardware workflows

Our GitHub organization is organized into logical groupings for ease of navigation and contribution:

Note: Some repositories may be private or access-controlled for regulatory compliance:

RAMMP is a collaborative effort involving multiple partner organizations across academia, industry, and the open-source community:

• Firmware/Electronics Teams: Embedded systems, motor control, sensor integration
• Robotics Engineering Teams: SLAM, sensor fusion, control algorithms
• Software Engineering Teams: Middleware, mobile apps, web dashboards
• Systems Engineering Teams: Integration, testing, regulatory compliance
• Design Teams: UX/UI, industrial design, accessibility
• Simulation Teams: Physics modeling, virtual environments, HIL systems

We operate as a distributed, multi-organization team with:

• Clear module ownership and responsibilities
• Well-defined APIs and interfaces
• Regular cross-team synchronization
• Shared development infrastructure
• Open contribution guidelines

1. Explore the Documentation: Visit [docs-site TBD] for architecture overviews and technical specifications
2. Set Up Your Environment: Follow platform-specific setup guides in [tutorials TBD].
3. Find an Issue: Check our project boards for "good first issue" tags
4. Read Contributing Guidelines: Each repository has a CONTRIBUTING.md with specific guidelines
5. Join the Community: Connect with us via our communication channels (see below)

1. Choose Your Platform: ATOS supports embedded systems, Linux, mobile, and desktop
2. Install Dependencies: See platform-specific documentation
3. Run Examples: Start with tutorials in the tutorials repository
4. Build Your Application: Use ATOS APIs to develop your assistive technology solution

1. Use RAMMS: Set up the simulation environment for your research
2. Generate Synthetic Data: Leverage RAMMS for AI/ML training datasets
3. Hardware-in-the-Loop: Test algorithms before physical deployment
4. Contribute Models: Share your component models and physics implementations

Create a new repository when:

• You're developing a new platform HAL (e.g., atos-hal-stm32)
• You're adding a major new component library (e.g., ramms-humanoid-models)
• You're building a standalone tool that serves the ecosystem
• You're contributing a significant feature that's independently versioned

Add to an existing repository when:

• Fixing bugs or improving existing functionality
• Adding new device drivers to an existing HAL
• Extending existing APIs or adding new examples
• Improving documentation or tests

• ATOS repositories: atos-{component} (e.g., atos-hal-esp32, atos-security)
• RAMMS repositories: ramms-{component} (e.g., ramms-physics, ramms-tools)
• Documentation: docs-{topic} or just docs-site for the main site
• Tools: {purpose}-tools or dev-{purpose} (e.g., ci-tools, dev-scripts)

Every repository should include:

• README.md: Clear description, quick start, and links to full docs
• LICENSE: MIT license (or as specified for the project)
• CONTRIBUTING.md: How to contribute, coding standards, PR process
• CODE_OF_CONDUCT.md: Our community standards (linked from main org)
• .github/workflows/: CI/CD automation
• docs/: API documentation, architecture decisions
• examples/: Working code examples and tutorials
• tests/: Unit tests, integration tests, and test documentation

• main: Production-ready code, always stable
• develop: Integration branch for ongoing development
• feature/* or feat/*: Feature branches (e.g., feature/motor-control-foc)
• bug/* or fix/*: Bug fix branches
• release/*: Release preparation branches

1. Fork the repository or create a feature branch
2. Develop your changes with tests and documentation
3. Commit with clear, descriptive messages (follow conventional commits)
4. Test locally and ensure CI passes
5. Submit PR with detailed description and link to related issues
6. Code Review: Address feedback from maintainers
7. Merge: Once approved, your PR will be merged

• 2-week sprints (subject to team preference)
• Sprint Planning: First Monday of sprint
• Standups: Quick async updates (15 min sync for critical items). Can be daily, bi-weekly, or weekly based on team preference.
• Sprint Review: Last Friday of sprint
• Retrospective: Once per month, quarter, or sprint-end based on team preference.

• Wrike: Wrike High level project tracking, timelines for overall RAMMP program
• JIRA: JIRA for Issue tracking, kanban boards, milestones for each subsystem
• GitHub Actions: CI/CD automation, testing, releases
• Slack and GitHub Discussions: Design discussions, Q&A, community support

Use labels to categorize issues:

• Type: bug, feature, documentation, question
• Priority: critical, high, medium, low
• Status: triage, todo, in-progress, blocked, ready-for-review, done, cancelled
• Component: atos-core, ramms-sim, hal-esp32, etc.
• Difficulty: good-first-issue, intermediate, advanced

All code contributions should include:

• Unit tests: Test individual functions and classes
• Integration tests: Test component interactions
• Documentation: Update API docs and examples
• CI passing: All automated tests must pass

Every repository has automated CI/CD that runs:

• Build checks: Multi-platform compilation
• Unit tests: Fast, isolated tests
• Integration tests: End-to-end scenarios
• Code quality: Linting, formatting, static analysis
• Security scanning: Dependency vulnerabilities
• Documentation: Automated doc generation

As medical device software, RAMMP follows:

• ISO 62304: Medical device software lifecycle processes, including requirements, documentation, traceability, verification, and validation
• ISO 13485: Quality management systems, using a risk-based approach
• ISO 14971: Risk management, focused on production and post-production activities for medical devices
• IEC 62366: Usability engineering

• No secrets in code: Use environment variables and secure vaults
• Dependency scanning: Automated vulnerability detection
• Code review: All PRs require approval from maintainers
• External PR Security: Do not allow external contributors to run workflows with secrets without review
• Signed commits: Recommended for core contributors
• Security advisories: Report vulnerabilities privately via GitHub Security

Regulatory compliance documentation (Design History File, risk management) is maintained in controlled repositories with restricted access. See the regulatory-docs repository if you are a partner organization with compliance responsibilities.

• Slack: RAMMP Slack - Daily discussions, quick questions
• Zoom/GoogleMeet: Weekly sync meetings, design reviews

• GitHub Discussions: Technical design discussions, RFCs
• GitHub Issues / JIRA: Bug reports, feature requests
• Email Lists: [Link TBD] - Announcements, community updates

• Documentation Site: [Link TBD] - Comprehensive technical docs
• Wiki: Architecture decisions, meeting notes
• Blog: Project updates, technical deep-dives

• Lower Barriers: Free tools enable innovation globally
• Accelerate Development: Shared solutions prevent duplication
• Improve Quality: Community review improves security and reliability
• Enable Research: Researchers can validate and extend our work
• Foster Ecosystem: Compatible tools and hardware emerge organically

• Code: MIT License (permissive, commercial-friendly)
• Documentation: Creative Commons CC-BY-4.0
• Assets/Models: Specified per-asset (typically CC-BY-4.0 or CC0)

We are committed to fostering an inclusive, respectful, and collaborative community:

• Be welcoming to newcomers
• Assume good intent
• Provide constructive feedback
• Respect different perspectives and experiences
• Focus on what's best for the community

See our Code of Conduct for details.

• [ATOS HAL Architecture TBD]
• [ESP32 Quick Start TBD]
  • NOTE: see esp-cpp/espp for a C++ framework for ESP32 development created by the ATOS authors that can be used as a starting point for ATOS HAL development on ESP32.
• [Motor Control with ATOS TBD]
  • NOTE: see esp-cpp/espp BLDC FOC Motor control documentation for an example of how to structure a HAL module for FOC motor control on ESP32, which can be used as a starting point for ATOS HAL development in this area.

• [ATOS Middleware Overview TBD]
• [SLAM Integration Guide TBD]
• [Sensor Fusion Examples TBD]

• [ATOS Mobile SDK TBD]
• [Building iOS Apps TBD]
• [Building Android Apps TBD]

• [RAMMS Getting Started TBD]
  • NOTE: See Unreal Engine 5 documentation for getting started with Unreal Engine development
• [Custom Physics Modules TBD]
  • NOTE: see others' work on integrating physics simulation like MuJoCo, as well as the official Unreal Engine reference for integrating JSBSim for custom flight dynamics, for examples of how to structure custom physics modules in RAMMS.
• [Hardware-in-the-Loop Setup TBD]

Yes! ATOS is MIT licensed, which permits commercial use. You can build and sell products using ATOS without royalty fees.

No. ATOS is designed for portability and security across embedded to mobile platforms. It provides a ROS2 bridge for interoperability with the ROS ecosystem. ATOS is not a ROS2 implementation, but rather a complementary middleware for assistive technology.

RAMMS is built on Unreal Engine 5 for high-fidelity physics and graphics supporting multiple platforms and use cases.

All contributions are welcome! Follow our contributing guidelines, start with "good first issue" tags, and engage in discussions.

A next-generation powered wheelchair with BLDC motors, advanced sensors, and advanced compute. See [Reference Platform Spec TBD] for details.

Partner organizations involved in medical device deployment maintain controlled regulatory documentation. Open-source code includes traceability mechanisms for compliance.

• Embedded: No special requirements; runs on ESP32 and similar MCUs
• Linux/Edge: No special requirements; runs on Jetson, RPi, x86
• Simulation: GPU with 8GB+ VRAM, 16GB+ system RAM. 16GB+ VRAM recommended for complex scenes and use of 3D Gaussian Splat assets.

Contact [email TBD] or join our community discussions to explore partnership opportunities.

RAMMP is funded in part by ARPA-H (Advanced Research Projects Agency for Health). Any opinions, findings, conclusions, or recommendations expressed in this material are those of the authors and do not necessarily reflect the views of ARPA-H.

We thank our partner organizations, contributors, and the open-source community for making this work possible.

Unless otherwise noted, all software in this organization is licensed under the MIT License. See individual repositories for specific licensing details.

Documentation and tutorials are licensed under Creative Commons CC-BY-4.0.

• Technical Questions: GitHub Discussions
• Security Issues: [Security Contact Link TBD]
• General Inquiries: [email TBD]
• Community Chat: [Slack Link TBD]

Built with ❤️ by the RAMMP community

🚀 Let's build the future of assistive robotics together!