Blendkit for Godot

A simple yet effective add-on that lets you import models from the Blendkit library to Godot Engine.

About

Search the Blendkit.com library right inside the Godot editor: open the Blendkit workspace, find an asset, click Download, and it lands in your project, organized and ready to use.

Rely on Godot's native import, or build your own custom workflow on top of the downloaded files.

See User Guide for an overview, screenshots, and getting started guide.

This project is Free and Open Source Software under GPLv2.

Contributions are highly encouraged and welcome 🤝

⭐ Star this repo to show support and interest in continued development, thanks!

Status

alpha

Fundamentals are done: building, testing, integration, distribution and installation work reliably, and the Blendkit workspace offers decent usability and ergonomics. The remaining bottleneck is getting assets into Godot cleanly.

IMPORTANT: Godot's Blender import is relatively young, and many .blend files import incorrectly or not at all, with plenty of warnings and errors in the Godot Output. Blender Import in Blendkit Settings shows whether Godot can import .blend files and helps you find Blender. This plugin gets more useful as native Blender → Godot import improves.

Set Model Format to glTF (.glb) to download glTF instead of the original .blend file. Blendkit's glTF files are exported automatically and far from perfect, but they work better for some assets and don't need Blender installed.

More testing and polish are needed before reaching beta quality, so please consider this software experimental 🧪 for now. It's a great time to test and contribute so that the plugin is useful for you and everyone else.

Requirements

Blendkit Godot Plugin requires:

• Godot Engine: 4 (4.4+ tested in CI)
• OS: Linux, Windows, macOS (untested, reports welcome)
• Architectures: x86_64, arm64

Recommended

• Blender, the newer the better. Without it, the plugin is severely limited.

Installation

See User Guide for a visual overview of installation and usage.

The Plugin needs to be installed for each Godot project.

From the Godot Asset Store (recommended)

In Godot 4.7 and newer, use the built-in Asset Store tab:

1. Search for Blendkit, click the plugin and press Download.
2. Go to Project → Project Settings... → Plugins tab.
3. Check Enabled for Blendkit.

It takes some time for a new version to reach the store due to validation. You can always install the latest version manually from a ZIP archive.

You can also browse the plugin on the Godot Asset Store website.

From a ZIP archive

Download the blendkit-godot_vX.Y.Z.zip archive from GitHub Releases (or build your own from sources), then:

1. Extract the ZIP into your Godot project root directory (where project.godot is located)
   • DO NOT copy addons/ or addons/blendkit/ from this repo without building Client binaries first.
2. Open your project in Godot Editor, go to Project → Project Settings... → Plugins tab
3. Check Enabled for Blendkit

If installation succeeded, you should see a new Blendkit workspace in the editor's top bar (next to Asset Store) as well as Blendkit: messages in editor Output.

Upgrading

Always do a clean install when upgrading to a new version:

1. Delete the addons/blendkit/ directory from your Godot project.
2. Install the new version as usual (see above).

This avoids stale files left over from the previous version.

Usage

After Blendkit Godot plugin is installed and enabled in your Godot project, open the new Blendkit workspace in the top bar (next to Asset Store) of the Godot Editor.

Search and download

• Search by text, sort the results, and filter by type (Models, Materials, HDRs, Scenes, Printables), category, polygon count, Free only and more. Hide procedural leaves out procedural materials and models, whose materials become a flat color in Godot. It is on for materials by default. Models can be limited to Animated or Rigged ones. For models, the Format dropdown is the Model Format setting: glTF (.glb) shows only models with glTF and downloads it, Blender (.blend) shows all.
• Click an asset to see its details. Choose a file and click Download to get it into bk_assets/. The file defaults to the Model Format and Resolution settings. A thin bar along the bottom of the asset's thumbnail shows the download progress, and a check mark in its corner shows the asset is in the project (or an error icon when the download failed).
• Godot can't read the EXR files of Blendkit HDRs as they are, so Blender re-saves them in a lossless form Godot imports before they move into the project. This uses the Blender from Blender Import in Settings, or one found on your computer. Without Blender, HDRs download but Godot shows them as failed imports.
• Materials download as Godot materials (.tres) with their textures, which Blender converts the material .blend into, also with the Blender from Blender Import or one found on your computer. Drop one on a mesh in the 3D view to use it. Materials map their textures triplanar at their real size, so they fit any mesh without UVs, like CSG shapes. Turn off UV1 › Triplanar to use the mesh's UVs instead, and turn on Height for the height map, which Godot doesn't do with triplanar mapping. Procedural materials have no textures to convert, so they become a flat color. Without Blender, materials download as .blend files, which Godot can't use.
• Logging in is optional. Free assets download without an account. To download Full Plan assets, click Log In… in the Blendkit menu at the end of the search bar and log in with a Full Plan account in the browser that opens.

Downloaded assets are organized by type and asset. For example, after downloading two models and one material:

bk_assets
├── materials
│   └── stylized-wooden-_42daf872-0c07-4f9f-bd51-2d741043096b
│       ├── stylized-wooden-floor_2K_724059e9-51b8-4d19-8088-3a11745347a2.tres
│       └── textures_2K
└── models
    ├── 19th-century-pap_6c28bfad-6678-4e85-abbc-41b36c436c96
    │   └── 19th-century-paper-clutter-waste_2K_2e96ac1b-aae0-4c49-b352-6553f693f841.blend
    └── wooden-lamp_84286bab-7077-4bb8-a83f-f035c71e9885
        └── wooden-lamp_e6458d96-fe9f-4b4d-a164-c7d61974be86.blend

Project assets

The download toggle next to the search bar switches the Blendkit workspace to the assets downloaded to this project, with a local search and Show in FileSystem. Switch back with the toggle or Browse Blendkit below the assets.

Blendkit menu

The Blendkit menu at the end of the search bar (the Blendkit logo with ⋮) gathers the Client, the account and settings. The dot in the logo's corner shows the Blendkit Client status: green when connected, yellow while connecting, red when it failed and gray when it's off. The menu has:

• The Client status in full and Enable Blendkit Client to turn the Client on and off.
• Settings with the download directory (res://bk_assets/ by default), Blender Import, Model Format (Blender (.blend) by default, or glTF (.glb)), Resolution, UUIDs in Names (Strip by default, Short or Full), the Client Port and the plugin's Log Level.
• Restart Client when it failed.
• The account: your avatar, name and email once you're logged in (click them for your profile), and your plan (click it for the plans). Log In… and Sign Up… open the browser and turn the Client on if it's off, as logging in goes through it. Log Out when logged in.
• Links to blendkit.com, User Guide, README & Sources and the issue tracker.
• The plugin and Client versions.

The login is shared through the Blendkit Client, so logging in or out in another Blendkit add-on (e.g. Blender's) does the same here while both run. The login is stored in the editor's data directory, outside your projects.

Details

Thumbnails are cached in ~/blenderkit_data/godot_temp/, outside your project.

Downloads in progress go to bk_assets/.downloads/ first. Godot doesn't scan hidden folders and git ignores it, so partial files are never imported or committed. Each file moves to its folder once complete, replacing an older copy, and Godot imports it. Downloads left there when the editor closed are deleted on the next start.

You don't need a credit card to get free assets, but you can access paid assets should you decide to support artists with a Blendkit.com Full Plan.

You can create an empty .gdignore file in bk_assets/ to prevent Godot auto-import.

Architecture

     local machine                                          internet

┌──────────────────────┐
│    Blendkit Godot    │
│      (GDScript)      │
└──────────────────────┘
           ▲
           │
     HTTP  │  connects to existing Blendkit Client
           │  or spawns a new one
           │
           ▼
┌──────────────────────┐            HTTPS             ┌────────────────────┐
│   Blendkit Client    │◄────────────────────────────►│    blendkit.com    │
│        (Go)          │     search/download/auth     │       server       |
└──────────────────────┘                              └────────────────────┘
           ▲
           │
     HTTP  │  optional login
           │
           ▼
┌──────────────────────┐
│     Web browser      │
└──────────────────────┘

Weak points

• Godot ↔ Client connection may be lost if Godot doesn't send heartbeat for too long, this leads to Client auto (re)start

Directory Structure

• addons/blendkit/ - Godot plugin sources (standard Godot addon path)
• bk_client/ - Blendkit Client sources (cloned on demand by ./dev.py build --from-source)
• tests/ - pytest test suite
• out/ - Build output directory (generated)
• project.godot - Godot project file for development and testing

Building

You need the following requirements:

• Python 3 for running the dev.py build script

Clone the repo and do a full build:

git clone https://github.com/BlenderKit/bk_godot.git
cd bk_godot
python dev.py build

By default this builds from a published client release:

• downloads the latest stable patch in the supported Blendkit Client series as bk_client.zip into client-dist/vX.Y.Z/ and verifies its version and manifest binary hashes (./dev.py get-client-release)
• stages all six platform binaries before replacing the installed client, and records the exact version in addons/blendkit/client/RESOLVED_VERSION
• creates a distributable ZIP archive (./dev.py build-archive)

Pin an exact supported client release with ./dev.py build --tag vX.Y.Z. The API series is defined once in client_binary.gd as CLIENT_API_VERSION.

Use an already downloaded bundle with ./dev.py build --client-bundle /path/to/bk_client.zip. Published Windows binaries are signed; macOS binaries are signed and notarized; Linux binaries are unsigned. Local builds and draft/testing workflow artifacts are unsigned. Manifest hashes check integrity; they do not independently authenticate the publisher.

The distributable ZIP will be at out/blendkit-godot_vX.Y.Z.zip.

Building the client from source

To compile the client yourself instead of using a release (requires Go and git):

./dev.py build --from-source

This clones Blendkit Client into bk_client/, builds an unsigned host-platform out/vX.Y.Z/bk_client.zip, and assembles a _local-<os>-<arch>.zip development archive. Current client sources use CGO and require a native C toolchain plus the platform libraries required by bk_client. The source version must belong to the supported API series.

Use an existing sibling checkout with:

./dev.py build --client-dir ../bk_client

An explicit --client-dir implies --from-source. Existing checkouts are reused without pulling or changing branches, including local uncommitted changes. Without either option, build continues to use published client binaries.

To install its previously built bundle without recompiling: ./dev.py build-plugin --client-dir ../bk_client. Follow with ./dev.py build-archive --allow-partial-client for a local archive. The default archive command requires all six platforms for distribution.

At runtime Godot uses the resolved version and bk_client-<os>-<arch> executable. It normally copies that executable into ~/blenderkit_data/client/bin/vX.Y.Z/, falling back to the bundled copy if the shared directory is unavailable. Discovery requires the supported API series and at least the bundled patch. Godot keeps its versioned /godot/report contract and unsubscribes without terminating a shared client.

Development

This repository is set up as a Godot project, so you can open it directly in Godot Editor for development and testing.

1. Clone this repository
2. Build (downloads the client release and assembles the plugin):

   ./dev.py build

3. Open the project in Godot Editor
4. Make changes to the plugin in addons/blendkit/
5. Test your changes directly in the editor

Run python dev.py for a list of all available commands.

Command	Description
build	Full build from a published client release: download + plugin + archive
get-client-release	Download a published client release and install its binaries
get-client-src	Clone/update Blendkit Client repository
build-client	Build only the Go client
build-plugin	Copy client binaries into plugin directory
build-archive	Create filtered ZIP archive of the plugin
clean	Remove build artifacts (out/ and client binaries)
set-version	Set plugin version in plugin.cfg
test	Run pytest tests
test-e2e	Run the live gallery and browser-to-Godot end-to-end tests

Run ./dev.py <command> --help for command-specific options.

Testing

Install the development dependencies, build the plugin with its Client binaries, and make sure Godot 4 is available as godot or godot4 (or through the GODOT/GODOT4 environment variable):

pip install -r requirements-dev.txt
./dev.py build

Normal tests

Run the default test suite with:

./dev.py test

These tests use pytest and run Godot in headless editor mode, in parallel when pytest-xdist is installed. They do not access the live Blendkit website, and the live E2E tests are excluded by default. Use -v for verbose output or -k <pattern> to select tests:

./dev.py test -v
./dev.py test -k plugin_enables

Live E2E tests

Install Playwright's Chromium browser once, then run the E2E suite:

playwright install chromium
./dev.py test-e2e -v

On a fresh Linux system, playwright install --with-deps chromium also installs the required system packages.

Each E2E test starts Godot with the bundled Client in a temporary project, so nothing is downloaded into this one. They require internet access:

• The gallery test searches from the gallery, waits for the thumbnails, and downloads a free glTF model from the details dialog. The model must end up imported in the project, marked as downloaded and indexed.
• The browser test opens a real asset page on Blendkit.com in Chromium, clicks Send to Godot, and waits for the gallery to show the download, move it into bk_assets/, and look the asset up for its name and thumbnail. The request goes to the test's editor, even when other Godot editors are open.

Use --headed to watch the browser, or -k <pattern> to select E2E tests:

./dev.py test-e2e --headed

BLENDERKIT_API_KEY is optional and only needed when overriding the default free asset with one that requires authentication. BLENDERKIT_E2E_SITE and BLENDERKIT_E2E_ASSET can point the test at another deployment or asset.

If Cloudflare serves its human-verification page to an automated runner, the browser test is reported as skipped and saves tests/e2e_failure.png for diagnostics. Other unexpected pages and failures in the browser-to-Client download flow still fail the test.

Releasing

Releases are automated via GitHub Actions. To create a new release:

git tag v1.0.0
git push origin v1.0.0

This will:

1. Update the version in plugin.cfg to match the tag
2. Build the plugin with the Blendkit Client
3. Create a GitHub release with the ZIP attached

Contributing

This project is Free and Open Source Software under GPLv2.

Contributions are highly encouraged and welcome 🤝

If you hit a bug or you wish something worked better, simply open a GitHub Issue.

The better you describe the problem, the easier it will be to fix.