Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/automatika-robotics/kompass.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-03-20 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| kompass | 0.4.1 |
| kompass_interfaces | 0.4.1 |
README
Part of the [EMOS](https://github.com/automatika-robotics/emos) ecosystem [](https://opensource.org/licenses/MIT) [](https://www.python.org/downloads/) [](https://docs.ros.org/en/humble/index.html) [](https://discord.gg/B9ZU6qjzND) **High-Performance, Event-Driven Navigation Stack for ROS2** [**EMOS Documentation**](https://emos.automatikarobotics.com) | [**Developer Docs**](https://automatika-robotics.github.io/kompass/) | [**Discord**](https://discord.gg/B9ZU6qjzND) 🇨🇳 [ç®€ä½“ä¸æ–‡](docs/README.zh.md) | 🇯🇵 [日本語](docs/README.ja.md)
What is Kompass?
Kompass is the navigation layer of EMOS (Embodied Operating System) and a framework for building robust, event-driven navigation stacks for autonomous mobile robots. It is built to be customizable, extendable and hardware-agnostic.
Kompass includes highly optimized, GPU-powered navigation algorithms in C++ that make full use of available hardware resources. It supports multi-process parallelism on CPUs and highly parallelized execution on any GPU (Nvidia, AMD, etc.) without vendor lock-in. And most importantly, Kompass makes it straightforward to create and deploy sophisticated navigation capabilities for any mobile robot within a single Python script, without sacrificing performance or flexibility.
For full documentation, tutorials, and recipes, visit emos.automatikarobotics.com.
- Key Features
- Components
- Installation
- Benchmarking Results
- Dynamic Web UI
- Robot Plugins
- EMOS Ecosystem
Key Features
-
Adaptive Event-Driven Design: Responsive to real-world events, robot state changes, and task updates. Define event-action pairs to reconfigure the navigation stack at runtime, or seamlessly switch planning or control strategies based on environment context.
-
Engineered for Speed: All core algorithms are written in modern C++ (kompass-core). First navigation framework to explicitly support GPU-based execution via GPGPU, unlocking high performance on any hardware without vendor lock-in.
-
ML Models as First-Class Citizens: External events can be driven by ML model outputs interpreting sensor data or user commands. The entire stack becomes reconfigurable based on ML inference, going beyond well-established visual navigation scenarios.
-
Pythonic API with Native Speed: While the heavy lifting is done in optimized C++, Kompass provides an intuitive Python API. Prototype quickly and deploy high-performance systems without rewriting code.
Components
Kompass is divided into several interacting components, each responsible for a navigation subtask:
Each component runs as a ROS 2 lifecycle node and communicates using topics, services, or action servers:
Learn more about each component in the EMOS Documentation: Planner | Controller | Local Mapper | Map Server | Drive Manager | Motion Server
Installation
For detailed installation instructions, see the EMOS Documentation.
Install kompass-core
With GPU support (recommended):
curl -sSL https://raw.githubusercontent.com/automatika-robotics/kompass-core/refs/heads/main/build_dependencies/install_gpu.sh | bash
File truncated at 100 lines see the full file