A project and version manager for Godot

• Important links:
  • CLI usage
  • Installation instructions
  • Build instructions

Download the latest release zip from the releases section, extract it, and run godl.exe (might be just godl if you've got file extensions turned off). If you want, you can then also right-click the executable, select "Create Shortcut," and then copy it to C:\ProgramData\Microsoft\Windows\Start Menu\Programs (you'll need administrator rights to do this).

flatpak install io.github.sockeye_d.godl

Get it from the AUR (Arch User Repository): https://aur.archlinux.org/packages/godl, or use a helper like yay:

yay -S godl

Note: Most package repositories don't have these packages. Mint, for example, doesn't have KF6 packages. Your mileage may vary.

You'll need to install these dependencies:

• kdeclarative
• kirigami-addons
• breeze-icons
• kirigami
• qqc2-desktop-style
• kconfigwidgets

Then, you should be able to download, extract, and run the executable.

...your projects:

...your versions:

...including first-class support for forks:

...even custom builds from a file

...your local versions:

...and unlike other managers, it's built in 100% native AOT-compiled C++ and Qt Quick, offering a fast, responsive, and native look-and-feel across all desktops.

godl includes a CLI which you can use to do things without opening the GUI. Examples:

# Show help (contextual, works on subcommands too)
godl --help
godl edit --help
godl edit configure tags --help

# List release assets given a tag name
godl remote list 4.5-beta3
# List release tags
godl remote list tag # (yeah they're sorted alphabetically, this is GitHub being stupid)
# List release assets given a tag name and a repository
godl remote list 4.5-beta3 -r /godotengine/godot-builds
# Download a version
godl install /godotengine/godot-builds 4.5-beta3 Godot_v4.5-beta3_linux.x86_64.zip

# Open the editor for a project (run in the project directory)
godl edit
# Bind an editor to a project
godl edit bind "filter-terms"
godl edit bind 4.5-beta3 # bind 4.5-beta3
godl edit bind 4.5-beta3 --repo /godotengine/godot-builds # bind 4.5-beta3, specifying the official godot-builds repository
godl edit bind 4.5-beta3,mono # bind 4.5-beta3-mono (the comma separates terms which must all be matched in the asset name)
# Get the name of a project
godl edit configure --name
# Set the name, description, and favorite status of a project
godl edit configure --name "new_name" --description "new_description" --favorite true
# List, add, and remove tags of a project
godl edit configure tags
godl edit configure tags add new_tag
godl edit configure tags remove old_tag

# Edit global configuration
godl g-config godot-location ~/Documents/godot/versions
# List, add, and remove download filters (used for remote list commands, etc.)
godl g-config download filter
godl g-config download filter add "new_filter"
godl g-config download filter remove "new_filter"
# no command to list, add, and remove work on most (should be all) list types
# like filters, sources, tags, and more
# Get, set default source
godl g-config download source default
godl g-config download source default /godotengine/godot-builds

# Create a new project using the template called "default"
godl create default
# Create a new project with a specific name, description, and renderer
godl create default --name new-project --t-description "new-project's description" --t-renderer gl_compatibility

--help, -h, and -? all show a contextual help menu which you can also use to find shorthand notations for most of these commands. Color can also be disabled with the NO_COLOR=1 environment variable.

The create project page operates on templates, which you can find in ~/.local/share/fishy/godl/templates (Linux) %AppData%\fishy\godl\templates (Windows). You'll find the default template there, which if deleted will be regenerated on app startup, but you can also create a new template by creating a new folder and including a metatemplate.json file in it.

The metatemplate file defines which keys are available for replacement and how they should be shown to the user. The basic structure is

{
  "replacements": [
    // ...
  ]
}

A replacement key is an object that contains the following keys:

{
  "type": /* ... */,
  "label": /* ... */
}

The available types are header, string, multistring, and enum. All the types except header get another key called template; this is the key that will get replaced in the source files of the template. For example, if you had this file:

extends Node

func _ready() -> void:
  print("{node_name}")

and a metatemplate like this:

{
  "replacements": [
    {
      "type": "string",
      "label": "Node name",
      "template": "node_name"
    }
  ]
}

when the template gets generated, the {node_name} in the script will be replaced with whatever the user typed into the field labeled "Node name".

multistring is like string, except it gets a TextArea instead of a TextField so you can enter multi-line strings.

enum allows you to define a ComboBox. It has a structure like this:

{
  "type": "enum",
  "label": /* ... */,
  "template": /* ... */,
  "values": [
    {
      "label": /* the text that will be shown to the user */,
      "key": /* the value that will be inserted when the template gets generated */
    }
  ]
}

For example, a widget for selecting the renderer of a Godot 4 project:

{
    "type": "enum",
    "label": "Renderer",
    "template": "renderer",
    "values": [
        {
            "label": "Forward+",
            "key": "forward_plus"
        },
        {
            "label": "Mobile",
            "key": "mobile"
        },
        {
            "label": "Compatibility",
            "key": "gl_compatibility"
        }
    ]
}

You can look at the default templates at src/templates.

pre-build requisites:

• git
• Qt Creator, installed through the Qt Online installer
  • It does ask for you to make an account, it's really annoying, but QtC is the easiest way I've found 😔
• CMake & Ninja, which you can also install through the Qt Online installer
  • I'm pretty sure you don't actually need any Qt binaries from the installer, since we'll be building those ourselves with Craft
• rcedit, which you can get through winget: winget install rcedit

To be honest I'm not entirely sure how I got it building on Windows. But basically,

1. Install KDE Craft
2. Make sure you've activated the craft environment!
3. Set the Qt version to 6.9.1 if it's still at 6.8.3 with craft --set version=6.9.1 libs/qt6
4. Install libs/qt6 and dependencies with craft libs/qt6 kirigami kirigami-addons extra-cmake-modules karchive kiconthemes kconfigwidgets qqc2-desktop-style qqc2-breeze-style, and make sure to set MinGW as the default compiler, not MSVC
5. Open Qt Creator, go to Preferences > Kits > Compilers, click add, then set up the C compiler path to be the one you installed through Craft. It's normally at "C:\CraftRoot\mingw64\bin\gcc.exe". Then, set the target triple to "x86_64-w64-mingw32" (probably — I have no idea what this is/does).
6. Go to Qt Versions, click add, name it "Qt %{Qt:Version} (CraftRoot)", and set the qmake path to the Craft qmake path (normally "C:\CraftRoot\bin\qmake.exe").
7. Go to Kits (the tab), click add, name it "Craft Qt", and set the Qt version to be the Craft version you just added. Set the name to be "Craft Qt"
8. Clone the repository with git: git clone https://github.com/sockeye-d/godl
9. Open the CMakeLists.txt file with Qt Creator. Once you're at the configuration screen, select the new Craft Qt kit we just made. Check Minimum Size Release and uncheck Debug.
10. Wait for the 'configuring "godl"' progress bar to complete, then press Ctrl+R to run the project. With any luck, after 30 seconds, it should open. If it looks like it didn't open but there weren't any errors, it might have just opened behind other windows.
11. The build artifacts are copied to the build/<target>/bin. You can just copy them from there, and zip them up, and distribute your freshly minted binaries.

Note: all of the package names are for Arch.

You'll need to install

• extra-cmake-modules
• qt6
• kdeclarative
• breeze-icons
• kirigami
• qtcreator
• qqc2-desktop-style
• kconfigwidgets

(I think)

If you get configure errors you probably need to install more stuff. Then, it's basically the same thing, except Qt Creator should auto-detect the qmake on your path and it should automatically set up the kit for you. You shouldn't need to install QtC through the Qt Online installer — I did this and it broke a bunch of stuff and I ended up uninstalling it and just installing it through the package manager like I should have done to begin with.

Linux builds are just a single executable in the build/<target>/deploy path.

If you want the full experience, make a desktop entry like this one:

[Desktop Entry]
Name=godl
Exec={the executable}
Icon=godl
Type=Application
Terminal=false
Categories=Utility

and put it in ~/.local/share/applications/, and also copy godl.svg to /usr/share/icons/hicolor/scalable/apps/godl.svg or similar.

"No" dariacore was harmed in the making of this software