The commercial toolkit for studios using Godot engine
Give your game faster scripts, protect the code behind it, and let your players build safely.
Built for Godot. Compiled locally. Performant.
Pre-bake at export
Build for your target.
Keep your Godot workflow. Add the performance and protection befitting a commercial release.
Compile scripts into native code at export time. Get better performance without JIT warm-up, including on platforms where JIT isn't available.
JIT available for dynamically loaded scripts. For exported scripts, use native AOT for 2-100x performance.
Performance depends on workload and engine calls.Compile supported game scripts into stripped machine code and obfuscate their implementation. Make your game's logic harder to inspect and copy.
Your project stays on your machine always.
Code protection raises the cost of reverse engineering.Support real, player-written gameplay logic inside an isolated runtime. Set memory and execution limits, and choose what a mod can reach.
Traits-based modding APIs are easy to use and encourage modders.
Explore the boundariesThe SafeGDScript language
SafeGDScript extends GDScript with reusable behavior and more expressive types. A few small examples show what that looks like in your scripts.
Share state and behavior across scripts. Declare a trait, then bring its members into your script with 'uses Trait'.
uses Damageable
trait Damageable:
var health: int = 100
func take_damage(amount: int) -> void:
health -= amountUse T? for a value that can be null. A null check narrows the type so you can safely work with the value that remains.
func bonus_points(bonus: int?) -> int:
if bonus == null:
return 0
return bonus + 10Group related variables of different types together under a single name. Construct a value directly and access its fields by name.
struct Item:
var name: String
var value: int
func starting_item() -> Item:
var item := Item("Potion", 25)
item.value += 5
return itemBind a non-null value and use it inside the branch in one step. It's only a null check. 0, false, and empty strings still pass.
func score_label(score: int?) -> String:
if var points := score:
return str(points) + " points"
return "No score yet"Accept a specific set of types with |. Test with is to narrow the value and handle each case with the right operations.
func item_label(item: int | String) -> String:
if item is int:
return "Item #" + str(item)
return item + " (named)"Modding, built to be shipped
New mechanics, custom worlds, entire game modes. Give your community a real scripting surface without giving their scripts unrestricted access to a player’s machine.
Godot Sandbox brings an isolated runtime and explicit permissions together in a Godot addon.
Try the live demoStudio module add-on
Studio customers can purchase the engine module with source, priced per conversation. Build the sandbox directly into your own engine, with AOT-compiled scripts and no JIT dependency. The module loads the same artifacts as the BSD extension.
*Console builds require your own approved platform access, SDKs, and Godot port or export templates. We hold no console SDK and have not tested console builds. Your studio owns platform certification and testing; we fix reported defects from a reproduction.
Introductory pricing
Compile locally. Ship native code. Keep using every version released during your update term.
Start with the free compatibility scanner, interpreter and desktop JIT.
Explore Godot Sandbox Community
One named project. Unlimited seats.
One-time purchase, including 12 months of updates. Optional updates: $49 / year after that. Taxes calculated at checkout.
Sales opening after terms are finalized.
Key delivered by email within one business day.
One legal entity. Unlimited projects and seats.
Annual update term. Taxes calculated at checkout.
Sales opening after terms are finalized.
Contact Studio salesKey delivered by email the same business day.
Introductory prices will be reviewed after ten sales or three months. Read the EULA, module addendum and threat model before purchasing.
Yes, if you want. Ahead-of-time compilation can be fully native (2-5x performance for regular GDScript), or sandboxed (costlier, but matching GDScript). Keep the restricted configuration for untrusted mods.
The runtime and AOT approach span desktop, mobile, web, and console targets, including systems without JIT. Your export needs the matching target toolchain and integration. The separately priced Studio module loads the same artifacts as the BSD extension. Console builds are untested by us; SDK access and console ports are separate.
A scripting language alone is not a security boundary. A Lua integration needs carefully restricted host bindings, libraries, and resource limits to handle untrusted code. Godot Sandbox provides a dedicated isolated runtime with a zero-outside-access restriction mode and an explicit game API.
No. Compilation runs locally. Commercial tooling is licensed for development and export. The shipped runtime does not ask players for a license key.
I'm seeing more and more threads about people having their games repackaged and resold, presumably via semi-automated processes using LLMs. I want to make it harder for casual attackers to reverse engineer released games.
Supported scripts ship as stripped machine code rather than tokenized source, making casual recovery much harder. Engine-visible names, some strings, scenes, and assets may remain inspectable. Obfuscation does not make code impossible to reverse engineer. Check your export report for scripts that remain as source.
Godot's PCK encryption protects files on disk. The game ships with the key and decrypts scripts when loading them, exposing their source text or tokenized representation in memory for an analyst to recover. Encryption does not turn GDScript into machine code.
Godot Sandbox Plus compiles supported scripts into RISC-V machine code and can execute AOT native machine code. The shipped game never needs to reconstruct those scripts' source or tokens, even at load time. Obfuscation further removes eligible internal names and obscures selected strings, so recovering the implementation requires reverse engineering compiled code. Engine-visible names and some strings can still be inspected.