Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro jazzy showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro kilted showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro rolling showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro iron showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file

No version for distro noetic showing humble. Known supported distros are highlighted in the buttons above.

Repository Summary

Checkout URI https://github.com/tier4/nebula.git
VCS Type git
VCS Version main
Last Updated 2026-01-13
Dev Status DEVELOPED
Released UNRELEASED
Contributing Help Wanted (-)
Good First Issues (-)
Pull Requests to Review (-)

README

Nebula

build-and-test documentation codecov

Welcome to Nebula, the universal sensor driver

Nebula is a sensor driver platform that is designed to provide a unified framework for as wide a variety of devices as possible. While it primarily targets Ethernet-based LiDAR sensors, it aims to be easily extendable to support new sensors and interfaces. Nebula works with ROS 2 and is the recommended sensor driver for the Autoware project.

Table of Contents

Documentation

We recommend you get started with the Nebula Documention. Here you will find information about the background of the project, how to install and use with ROS 2, and also how to add new sensors to the Nebula driver.

To build and serve the documentation locally, see the build steps further below.

Quick start

Nebula builds with ROS 2 Galactic and Humble.

Note

Boost version 1.74.0 or later is required. A manual install may be required in Ubuntu versions earlier than 22.04.

To build Nebula run the following commands in your workspace:

# In workspace
git clone https://github.com/tier4/nebula.git
cd nebula
# Import dependencies
vcs import < build_depends.repos
rosdep install --from-paths . --ignore-src -y -r
# Build Nebula
colcon build --symlink-install --cmake-args -DCMAKE_BUILD_TYPE=Release -DCMAKE_EXPORT_COMPILE_COMMANDS=1

To build with support for Agnocast, TIER IV’s zero-copy middleware, refer to the Agnocast section below.

(optional) To build and serve the documentation locally (including API reference), run:

# Install system dependencies
sudo apt install doxygen

# Install Python dependencies
pip3 install -r docs/requirements.txt

# Generate API reference from C++ sources
mkdocs build --config-file scripts/mkdoxy_gen.yml

# Preprocess docs (expands macros, merges API reference)
python3 scripts/preprocess_zensical_docs.py

# Serve locally at http://localhost:8000
zensical serve --config-file .zensical.toml

To launch Nebula as a ROS 2 node with default parameters for your sensor model:

ros2 launch nebula nebula_launch.py sensor_model:=*sensor_model_name*

For example, for a Hesai Pandar40P sensor:

ros2 launch nebula nebula_launch.py sensor_model:=Pandar40P

Agnocast

Nebula supports the Agnocast zero-copy middleware for pointcloud and blockage mask outputs.

Note

File truncated at 100 lines see the full file