Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Ozuba/rclgd.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-07-17 |
| Dev Status | UNMAINTAINED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| colcon_rclgd | 2.1.0 |
| rclgd | 2.1.0 |
| rclgd_cli | 2.1.0 |
README
Features
As for now only the basic set of the rclcpp api are implemented, keep in mind this is highly experimental and not suited yet for production. But it serves as the groundbase for implementing awesome simulation environments and visualizers using the powerful features of the godot engine.
- rclgd Singleton
- Dynamic Msg Type Support
- Nodes
- Publishers
- Subscribers
- Service Clients
- Service Servers
- Timers
- Action Clients & Servers
- Parameters
- TF2 Publishers and Listeners
- TF2 Listeners And Broadcasters as 3D Nodes in godot (Will be deprecated in future update)
- Node and TF Namespacing
- ROS Graph Inspection
- QoS -> Through QoS RosQoS resource
- Godot template project
- Godot Editor Support -> Pseudo-Static Type Wrappers
-
Simulation Time ->
-p publish_sim_time:=truepublishes the Godot physics clock on/clock; the standard-p use_sim_time:=truemakes clocks and timers follow/clock - Native RCLGD packages in colcon
Repository layout
The suite is split into independently releasable ROS 2 packages:
| Package | Type | Contents |
|---|---|---|
rclgd |
ament_cmake | the GDExtension (librclgd.so), godot launcher, runtime manifest |
colcon_rclgd |
ament_python | the build_type: rclgd colcon extension |
rclgd_cli |
ament_python | the ros2 rclgd command and the editor addon template |
The system-test suite (rclgd_tests, itself a native rclgd package) is
maintained separately so this repository contains only the releasable
packages.
Installation
Clone this repository into your workspace and install dependencies, build it and source it.
The build downloads the pinned Godot editor binary (SHA-512 verified against
the official release sums) and installs it as lib/rclgd/godot-bin, next to
librclgd.so — the install is complete out of the box, no extra step.
rosdep install --from-paths src --ignore-src -y -r
colcon build --packages-up-to rclgd
source install/setup.bash
To run the system tests, put the rclgd_tests package in your workspace and
build it (it dogfoods the whole build_type: rclgd pipeline — it needs the
suite above built and sourced first), then run it like any other rclgd
package:
colcon build --packages-select rclgd_tests && source install/setup.bash
ros2 run rclgd_tests rclgd_tests --headless # exits 0 only if all tests pass
The build installs exactly the Godot version librclgd was compiled against
(the version of the godot-cpp bindings; recorded in
share/rclgd/godot_version). To use a different Godot version, retarget the
godot-cpp submodule to the corresponding branch, edit GODOT_VERSION and
the GODOT_SHA512_* pins in rclgd/CMakeLists.txt, and rebuild.
Command line tools
rclgd ships a ros2 rclgd command:
| Verb | Purpose |
|---|---|
ros2 rclgd create <name> |
Scaffold a new rclgd package (package.xml, project, addon, demo pub/sub) |
ros2 rclgd editor [pkg] |
Open the Godot editor on a package’s source project (no argument: current directory, or the project selection screen) |
ros2 rclgd list |
List built rclgd packages |
ros2 rclgd doctor |
Diagnose broken setups (versions, extension wiring, imports) |
Typed GDScript wrappers (shadow classes) are generated automatically: when a
project opens in the editor, the rclgd plugin reads the dependencies declared
in the project’s package.xml and (re)generates wrappers for their message
types into res://addons/rclgd/gen. Add a <depend> to package.xml, reopen
the editor (or use Project > Tools > Regenerate ROS2 Types), and the typed
classes appear. The generated wrappers are plain GDScript files meant to be
committed with the project — they regenerate automatically whenever the
dependency set changes.
File truncated at 100 lines see the full file