Vehicles are evolving from distributed electronic control units (ECUs) toward software-defined architectures that support portable applications running on centralized computing platforms. Vehicle motion control, however, remains distributed across engine, transmission, electrification, and braking systems, with integration traditionally dependent on proprietary interfaces and supplier-specific implementations.
The Vehicle Adaptive Motion Unification System (VAMUS) was initiated to address this challenge by defining reusable application frameworks and standardized interfaces for cross-domain vehicle motion coordination, while preserving independent subsystem protection and allowing suppliers to retain proprietary control algorithms.
The project originated as a Cummins Inc. initiative and has an existing private GitHub repository containing requirements, architecture documentation, Rust application frameworks, simulation scaffolds, and development tools. The proposed Eclipse project will establish a vendor-neutral home for continued development and industry collaboration within the Eclipse Software Defined Vehicle ecosystem.
Eclipse VAMUS provides open-source software frameworks, interfaces, and reference implementations for coordinating vehicle longitudinal motion across propulsion, transmission, electrification, and braking systems.
The project develops reusable application infrastructure, domain-specific profiles, standardized communication and control interfaces, ECU integration extension mechanisms, vehicle motion orchestration, simulation environments, and validation tools. Its initial reference implementation targets heavy-duty commercial vehicles using Rust applications, DDS-based communication, and containerized deployment.
The project supports integration with relevant automotive software standards and open-source technologies while allowing vehicle manufacturers and suppliers to implement proprietary domain-specific algorithms and ECU integrations through defined extension interfaces.
The project does not provide production-certified vehicle control, proprietary ECU algorithms or calibrations, or replacements for independent embedded safety supervision. Production deployment, real-time guarantees, and functional safety qualification require separate system-level engineering and validation.
Eclipse VAMUS (Vehicle Adaptive Motion Unification System) is an open-source framework for developing portable vehicle motion-control applications that coordinate multiple vehicle subsystems through standardized interfaces.
VAMUS introduces a shared application framework for vehicle-level motion orchestration and domain applications, including engine, transmission, hybrid-electric propulsion, and braking. The framework separates common functionality—such as application lifecycle, motion requests, capability negotiation, domain recommendations, command execution reporting, and fallback coordination—from supplier-specific controller implementations.
ECU Integration Extensions (ECU-IXs) allow equipment manufacturers and suppliers to connect the common framework to their respective controllers without exposing proprietary algorithms, calibration data, or internal implementation details.
The initial implementation uses Rust and defines Eclipse Cyclone DDS over UDP as its Phase 1 communication architecture. The project includes reference simulators, application scaffolds, machine-readable interface definitions, OCI deployment artifacts, requirements, architecture documentation, and validation tooling. The software is currently experimental and intended for architecture development and prototype validation, not production vehicle control.
By providing a common, reusable foundation, Eclipse VAMUS aims to reduce duplicated software development, simplify integration between vehicle manufacturers and suppliers, and support industry collaboration on portable software-defined vehicle applications.
The initial contribution is maintained in a private GitHub repository and identifies Cummins Inc. as the initial contributor and copyright holder. The project currently uses Apache License 2.0.
Before transferring the repository or publishing its contents through the Eclipse Foundation, Cummins will confirm authorization to contribute the relevant source code, documentation, and associated intellectual property. This review will include applicable employee and contributor rights, patent considerations, third-party dependencies, and any material requiring exclusion from the public repository.
The proposed project name, VAMUS, will be reviewed with the Eclipse Management Organization for trademark clearance and any necessary assignment of existing rights. No trademark transfer authority is asserted by this proposal.
The project is designed to separate its open-source framework and interfaces from proprietary ECU implementations, control algorithms, calibrations, and supplier-specific integration details. Such proprietary materials are not intended to be included in the initial contribution.
Any identified intellectual property or licensing issues will be resolved through the Eclipse Foundation's established legal and intellectual property review processes before the affected material is included in an official release.
Over the next 12 to 18 months, Eclipse VAMUS intends to progress from its initial framework and interface scaffolds toward an executable, distributed vehicle motion-control reference implementation.
Planned activities include:
- Implementing the shared application framework and end-to-end motion orchestration between engine, transmission, hybrid-electric, and braking domain applications.
- Completing and validating DDS interface definitions and implementing communication between Rust applications using Eclipse Cyclone DDS.
- Developing reference ECU Integration Extensions and deterministic simulation scenarios covering acceleration, deceleration, braking allocation, domain capability limitations, and coordination of multiple powertrain subsystems.
- Implementing and validating control authority, feedback, command freshness, fault handling, and independent ECU fallback behavior.
- Expanding automated conformance testing, performance measurement, and OCI deployment validation.
- Advancing the architecture for plug-in motion-control features, domain advisory optimization, and additional vehicle configurations.
- Evaluating optional interoperability with other relevant Eclipse SDV projects and industry interface standards.
Community development will include open technical discussions, publicly accessible requirements and architectural decisions, contribution guidelines, collaborative implementation tasks, and engagement with the Eclipse SDV Working Group. The project will seek participation from vehicle manufacturers, suppliers, software developers, and research organizations.
The project will begin with the existing VAMUS codebase and documentation as its initial contribution.
Following Eclipse project approval and provisioning:
- Months 0–3: Complete the repository migration, initial intellectual property review, project governance transition, and public development setup.
- Months 3–6: Complete the initial executable in-memory reference application framework, reference ECU integration extensions, and deterministic simulation tests.
- Months 6–12: Implement and validate distributed Cyclone DDS communication between the motion orchestrator and domain applications, including OCI deployment and fault-handling tests.
- Months 12–18: Expand system-level demonstration scenarios, conformance testing, interoperability evaluations, documentation, and community participation.
Initial project releases will be scheduled according to implementation maturity, validation results, and completion of Eclipse Foundation intellectual property requirements. The project will follow the Eclipse development and release processes.
The initial contribution will be based on the existing VAMUS repository, currently hosted privately at https://github.com/carltonbale-cmi/VAMUS.
The repository contains an experimental Rust implementation of the VAMUS Shared Application Framework, including application core libraries, domain and orchestrator frameworks, domain profiles for engine, transmission, hybrid-electric propulsion, and braking, and reference ECU Integration Extension scaffolds. It also includes application scaffolds for motion orchestration, domain simulation, vehicle composition, and vehicle health, together with reference configurations, interface schemas, and test utilities.
Supporting artifacts include system and application requirements, architecture documentation, architectural decision records, draft DDS interface definitions, historical protobuf interface definitions, ECU-IX manifest schemas, simulation scenarios, CI workflows, Docker/Podman deployment files, and contribution and governance documentation.
The initial codebase is at version 0.1.0-alpha.5 and is experimental. Rust scaffold compilation, selected tests, repository validation, and container startup checks have been exercised. Functional DDS communication, complete motion-control behavior, and safety qualification have not yet been established.
Ownership and community: Cummins Inc. is identified as the initial copyright holder and contributor. Carlton Bale is the initial technical maintainer. The project is currently maintained in a private repository and will transition to publicly accessible, vendor-neutral development following Eclipse project approval and completion of the applicable contribution requirements.
Third-party dependencies: The current Rust workspace contains no external third-party crate dependencies or vendored third-party source code. Development and validation tools include Python jsonschema (MIT), PyYAML (MIT), the Protocol Buffers compiler (BSD-3-Clause), Rust tooling, and Docker/Podman. OCI image builds currently use official Rust and Debian base images, which contain separately licensed components. Eclipse Cyclone DDS (EPL-2.0 OR BSD-3-Clause) is the selected future runtime middleware but is not yet integrated into the current Rust application scaffolds. A complete versioned dependency and license inventory will be reviewed with the Eclipse IP Team before the initial official release.
The contribution will be transferred to an Eclipse Foundation-managed repository following project creation and appropriate intellectual property review. Existing repository history will be preserved where feasible and appropriate.
- Log in to post comments