Godust

Godust is a CLI tool that generates Godot Engine project templates in Rust, specifically using the godot-rust library (GDExtension bindings for Rust).

The godot-rust library is a pure Rust implementation of the GDExtension bindings. This means you can write code in Rust that's equivalent to what you'd typically use GDScript or C# for in Godot.

A key advantage is that because your game project is fundamentally a Rust project, you can easily integrate other Rust tools and libraries. For example, you can incorporate Bevy Engine packages, or use Vulkano and Ash for Vulkan graphics code. We're planning future templates that will include pre-built scripts for common features, incorporating Bevy ECS templates, among others.

Where to Find Help?

If you encounter problems or have suggestions for the CLI itself, including ideas for new templates, changes, or bug fixes, please open an issue. Feel free to submit pull requests (PRs) for any changes or improvements you'd like to contribute.

However, if you need assistance with programming your game using Godot and Rust, here are some excellent resources:

• godot-rust Official Book: The official book is your primary guide for learning Godot with Rust.

• godot-rust API Documentation: For detailed information on the available functions and modules, consult the API documentation.

• godot-rust GitHub: If you encounter bugs specifically related to godot-rust, you can check their GitHub repository here.

• godot-rust Demo Projects: Remember that godot-rust also maintains its own repository of demo projects. While our templates don't strictly adhere to these examples (we aim for more dynamic generation), you can still extract useful content and insights from them.

• Community Communication Channels: For further community engagement for godot-rust, you can find links to communication groups like Discord and Mastodon on the godot-rust main website.

• Godot Engine Official Documentation: You will likely also want to consult the Godot Engine official documentation. It's arguably the best source for understanding the engine's core concepts and inner workings. If you're learning, adapting the GDScript and C# samples and tutorials to Rust can be an extremely helpful exercise.

Disclaimer: Please note that this CLI and its templates are an independent project and are not associated with godot-rust or its development team.

Templates Roadmap

Basic Templates

Full Templates

Mobile Templates

CI/CD & Deployment Templates

Status Legend:

• ✅ Complete - Ready to use
• 🚧 In Progress - Currently being developed
• 📋 Planned - Scheduled for future development

Pre-requisites

Before getting started, please ensure you have the following installed:

• The Rust package manager, Cargo (which comes with a standard Rust installation) - To install Rust and Cargo click here.

How to use it

To generate the template:

To use the blank template you need to define the engine version, render method and the project name:

godust --name my_project_name --engine 4.5 --rendering-method "forward_plus"

You can also explicitly specify the template (optional, since it defaults to "blank" when not provided a template):

godust --name my_project_name --engine 4.5 --rendering-method "forward_plus" --template blank

Or using the short form:

godust -n my_project_name -e 4.5 -r "forward_plus" -t blank

Godust help:

Godust - CLI tool for Godot Engine template generation

Usage: godust --name <NAME> --engine <ENGINE> --rendering-method <RENDERING_METHOD> [OPTIONS]

Options:
  -n, --name <NAME>                          Project name
  -e, --engine <ENGINE>                      Engine version
  -r, --rendering-method <RENDERING_METHOD>  Render method (forward_plus, gl_compatibility, mobile)
  -t, --template <TEMPLATE>                  Template (available: blank, blank_ecs) [default: blank]
  -h, --help                                 Print help
  -V, --version                              Print version

Everything works well if you see something like this:

✅ Successfully created project structure for 'my_project_name'...
🔨 Building template context...
📝 Generating project files from 'blank_ecs' template...
🔨 Building Rust library (this may take a moment)...
✅ Rust library built successfully!

✅ Successfully generated 'my_project_name' from template 'blank_ecs'!

📁 Project structure:
   my-project-name/
   ├── my-project-name/          (Godot project)
   └── my_project_name_core/     (Rust library)

💡 Next steps:
   cd my-project-name
   cd my_project_name_core && cargo build
   Open my-project-name in Godot Editor

Running Your Project

After generating your Godot-Rust project with Godust, the Rust library is automatically built during project creation. You can immediately open your project in the Godot editor:

Open in Godot Engine: The Godot project file (project.godot) is located in my_project_name/my_project_name/project.godot. Open the Godot editor and import this project.

Note: The initial Rust build (debug mode) is performed automatically when you create the project. If you make changes to the Rust code later, you'll need to rebuild:

• For development: cd my_project_name_core && cargo build
• For production/release: cd my_project_name_core && cargo build --release

Even though the template generation process customizes the name of the core project (the Rust part of the project), which is different from the default defined in the godot-rust book HelloWorld tutorial, the overall structure still needs to respect the same layout.

License

This project is licensed under the MIT License.