OpenAMASE: Mission-Level UAV Simulation for Autonomous Systems

Overview

OpenAMASE (Air Mission Autonomous Systems Environment) is an open-source, Java-based simulation framework developed by the Air Force Research Laboratory (AFRL) to support the development and testing of autonomous multi-vehicle mission systems. Unlike high-fidelity flight dynamics simulators, OpenAMASE operates at the mission level, providing a lightweight yet powerful environment for evaluating autonomy algorithms, multi-agent coordination, and task assignment logic across fleets of unmanned aerial vehicles (UAVs).

For defense engineers and autonomy researchers, OpenAMASE fills a critical gap: it enables rapid prototyping and validation of autonomous behaviors without the computational overhead of full physics-based simulation, making it ideal for algorithm-in-the-loop (AIL) and software-in-the-loop (SIL) testing workflows.

Architecture and Core Components

OpenAMASE is built around a publish-subscribe messaging architecture using the Lightweight Communications and Marshalling (LCM) protocol, which allows modular components to communicate asynchronously. The simulation is driven by a configurable XML scenario file that defines:

Vehicle entities: Fixed-wing UAVs, rotorcraft, or custom platforms with simplified kinematic models
Waypoint and task assignments: Pre-planned routes or dynamically assigned via an external autonomy service
Sensor footprints: Camera and sensor coverage zones rendered in the 2D/3D visualization
Terrain and airspace: Configurable operating areas with keep-in/keep-out zones

The framework integrates natively with AFRL's OpenUxAS (Unmanned Autonomous Systems) autonomy engine, enabling closed-loop testing where OpenUxAS generates task assignments and OpenAMASE executes and visualizes the resulting vehicle behaviors in real time.

Key Capabilities for Defense Applications

Multi-Vehicle Coordination Testing

OpenAMASE supports simultaneous simulation of dozens of UAVs, making it well-suited for evaluating swarm coordination algorithms, convoy escort scenarios, and distributed ISR (Intelligence, Surveillance, and Reconnaissance) coverage. Engineers can inject task requests mid-mission to test dynamic re-tasking and conflict resolution logic.

Multi-UAV ISR coverage simulation showing 5 vehicles with sensor footprints and keep-out zones

Sensor and Coverage Modeling

Each vehicle can be equipped with configurable sensor footprints that project onto the terrain surface. This allows analysts to evaluate area coverage efficiency, sensor overlap, and gap analysis for multi-UAV ISR missions — critical metrics for persistent surveillance planning.

Plug-in Autonomy Services

Because OpenAMASE communicates over LCM, any external process that speaks the same message schema can act as an autonomy service. This architecture supports hardware-in-the-loop (HIL) integration, where a physical mission computer or ground control station can be connected to the simulation without code changes.

Scenario Scripting and Repeatability

Scenarios are fully defined in XML, enabling version-controlled, repeatable test cases. Combined with headless (no-GUI) execution mode, OpenAMASE supports automated regression testing of autonomy software — a practice increasingly required under DoD software acquisition frameworks such as DevSecOps and Agile acquisition pathways.

Integration with OpenUxAS

The most powerful use of OpenAMASE is as the simulation back-end for OpenUxAS, AFRL's open-source autonomous systems framework. In this configuration:

OpenUxAS services (e.g., Route Planner, Task Manager, Assignment Tree Branch-Bound) publish task assignments over LCM.
OpenAMASE receives assignments, moves vehicles along computed routes, and publishes state updates back to OpenUxAS.
The loop continues in real time, allowing full end-to-end validation of the autonomy stack.

This closed-loop workflow is used in AFRL research programs and has been demonstrated in multi-vehicle collaborative autonomy experiments, including the Collaborative Operations in Denied Environment (CODE) program.

OpenAMASE typical workflow for multi-UAV ISR mission setup

Practical Workflow: Setting Up a Multi-UAV ISR Scenario

A typical OpenAMASE workflow for an ISR coverage mission involves:

Define the scenario XML: Specify the operating area boundary, initial vehicle positions, fuel/endurance limits, and sensor parameters.
Configure task requests: Add AreaSearchTask or PointSearchTask elements targeting regions of interest.
Launch OpenUxAS (optional): Start the autonomy engine to handle dynamic task assignment.
Run OpenAMASE: Execute the simulation and observe vehicle routing, sensor coverage, and task completion in the built-in visualizer.
Analyze logs: Post-process LCM log files to extract coverage metrics, task latency, and vehicle utilization statistics.

The entire setup can be containerized using Docker, and AFRL provides reference Docker Compose configurations that bring up both OpenAMASE and OpenUxAS with a single command — significantly reducing integration friction for new users.

Limitations and Considerations

OpenAMASE uses simplified kinematic vehicle models (point-mass with speed and turn-rate constraints), not full aerodynamic models. It is not appropriate for:

High-fidelity flight performance analysis
Structural or aerodynamic load assessment
Sensor physics modeling (e.g., radar cross-section, electro-optical detection probability)

For those requirements, integration with tools such as MATLAB/Simulink Aerospace Blockset or JSBSim is recommended, with OpenAMASE serving as the mission-level orchestration layer.

Getting Started

OpenAMASE and OpenUxAS are both available on GitHub under open-source licenses:

OpenAMASE: https://github.com/afrl-rq/OpenAMASE
OpenUxAS: https://github.com/afrl-rq/OpenUxAS
AFRL Autonomy Technology: https://www.afrl.af.mil/RI/

AFRL also publishes tutorial scenarios and documentation in the repository wikis, providing a practical starting point for teams integrating OpenAMASE into their autonomy development pipelines.

Conclusion

OpenAMASE occupies a unique and valuable niche in the defense simulation ecosystem: a lightweight, open-source, mission-level simulator purpose-built for autonomous multi-vehicle systems. Its tight integration with OpenUxAS, LCM-based extensibility, and support for automated testing workflows make it an essential tool for autonomy engineers working on UAV coordination, ISR mission planning, and DoD software development programs. For teams building the next generation of autonomous air systems, OpenAMASE provides a proven, accessible foundation for algorithm development and validation.