DEV Community: Ziva

AI assistant for a large Godot project: Ziva and Claude Code tested on Pixelorama

Ziva — Sat, 07 Nov 2026 15:23:20 +0000

Can an AI assistant work in a large Godot project without losing track? We gave Ziva and Claude Code the same feature to build in Pixelorama, an open-source pixel art editor written in Godot 4 with 249 GDScript files (about 60,000 lines) and 120 scenes. Both used Claude Opus 5.5. The feature touched 8 files: a shader, a new dialog scene and script, the menu code, the shortcut list, the layer effects list, project settings and the translation template.

All four runs, two per tool, passed the same independent check in the running app. Ziva finished in 6 and 13 minutes; Claude Code took about 16 minutes both times. Claude Code tested its own work more thoroughly. Ziva's game runner could not screenshot Pixelorama while it sat idle, and Ziva left stray files in the project root. Details below.

Ziva.sh makes Ziva and wrote this test. We ran it on 7 November 2026 with Godot 4.7.2 on Linux, on Pixelorama commit 5b2ebf5 (MIT license), using a development build of Ziva from that day and Claude Code 2.1.318. Each tool used its default reasoning setting. The first runs of the two tools overlapped in time and the second runs started together on the same machine, so they shared its CPU. Claude Opus 5.5 in Ziva needs the Pro plan ($50/month).

The task

Both tools got this prompt, word for word, in a fresh copy of the project:

Add a Sepia color effect to this project (Pixelorama). It should work like the existing color effects:

1. Effects > Color > Sepia opens a dialog with an Intensity slider (0 to 100%, default 100%) and a live preview. Applying it works on the same targets as Desaturation (selected cels, current frame, all frames, all projects, and only the selection when that option is checked), with undo.
2. Sepia gets its own shortcut entry in Preferences > Shortcuts like the other effects (no default key).
3. Sepia is also available as a non-destructive layer effect in the Layer Effects dialog, with the same Intensity parameter.

Follow the project's existing patterns for effects. When you are done, make sure the project still opens and runs without new errors.

This is the kind of change where an assistant "loses track" in a big project. Nothing in the prompt says where effects are registered. Pixelorama wires each effect in five places, and missing one gives a menu item that does nothing, a shortcut that never appears, or no layer effect at all.

Ziva ran in the Godot editor with auto-approve on. Claude Code ran in a terminal with no plugins, MCP servers or project instructions, permissions auto-approved, and Godot and a virtual display available on the command line.

Results

	Ziva run 1	Ziva run 2	Claude Code run 1	Claude Code run 2
Our check in the running app	Pass	Pass	Pass	Pass
Time	6 min 15 s	12 min 50 s	16 min 0 s	15 min 50 s
Cost	$1.94 of Ziva plan usage	$2.93	$2.70 (Claude Code's API-price estimate)	$3.58
Peak context	137,000 tokens	157,000 tokens	135,000 tokens	164,000 tokens
Files left in the project root	its test scene and script (Ziva said so)	an untitled.png it could not explain (Ziva said so)	none	none
Its own testing	Selected cels target only	Selected cels and selection-only	All four targets, save and load, 82 checks	85 checks

Our check was the same script for every run. It opened Effects > Color > Sepia in the running app, applied it to a blue canvas, undid it, applied 50% to a selection only, confirmed the shortcut entry, and added Sepia as a layer effect. All four produced identical pixel values, and none added new errors to the startup log.

On a Claude subscription you pay a flat fee rather than Claude Code's estimate, and Ziva's cost depends on your plan's included usage. Neither run came close to the model's context limit, so this test does not show how either tool handles a chat long enough to need summarizing.

How Ziva found its way around 1,383 files

Ziva does not index or embed your code, and it does not load the project into the model. In both runs its first step was one search for "desaturat" across scripts, scenes, shaders, project settings and translation files. That found every place the existing Desaturation effect is wired. It then read 17 files in run 1 and 22 in run 2 and copied the pattern.

A few things helped on the way, and they come from Ziva running inside the Godot editor:

GDScript checked after every script edit. Each time Ziva created or edited a .gd file, Godot's language server checked it and the files that depend on it. Every one came back with "No problems in this file or its callers."
Project settings through Godot. Ziva added the shortcut's input action with Godot's project settings API instead of editing project.godot by hand, and in run 1 it read the live input map first.
The real app, not a stub. Ziva ran Pixelorama's main scene from the editor and read its output and errors.
A memory for next time. In run 2 Ziva saved a project memory describing how to test Pixelorama code, so the next chat starts with a pointer to it. See memories.

Claude Code got there with shell tools instead: grep, sed, and Godot from the command line on a virtual display. Its output landed in the same files.

Where Ziva struggled

Ziva's game runner timed out on an idle Pixelorama. Pixelorama turns on Godot's low-processor mode, so it only redraws when something changes. Ziva's run_scene waits for a drawn frame to screenshot, and running the main scene timed out after about 35 seconds, twice in each run. We confirmed the cause: with low-processor mode off, the same call returned a screenshot. Ziva worked around it with a temporary test scene that drove the app and printed its results. In run 2 that scene kept the app drawing, so run_scene returned screenshots too.
Ziva's script runner could not load Pixelorama's autoloads. Its one-off GDScript runner reported "Identifier not found: Global", so Ziva switched to the test scene above.
Stray files. Run 1 left its test scene and script in the project root and asked whether to delete them. Run 2 deleted its test files, but an untitled.png appeared in the root during testing, and Ziva flagged it.
Less testing than Claude Code. Ziva tested only the Selected cels target and said so. Claude Code tested all four targets plus saving and loading. In run 1 it also reported a likely bug in Pixelorama's shared effect code, where applying an effect to all projects crops other projects with the current project's size. We read the line and it matches the report, but we did not reproduce it.
The Full Game Playtest Agent did not run. Ziva tried it in both runs, but a credential problem in our local test setup stopped it before it started. This test says nothing about it either way.

What this test does not show

It is one project, one feature, two runs per tool, and one model. The task added a feature across many files. It was not a rename or a move of files across many scenes, which we have not tested yet. Neither tool needed to summarize its chat. Results with other models, a bigger project or a vaguer prompt may differ.

If your AI loses track as your project grows

These habits helped in this test and work with any assistant:

Point it at an existing example. "Make it work like Desaturation" told both tools where to look. Name a similar scene, script or system in your project.
Write your project's rules down. Ziva reads an AGENTS.md file in your project, and Claude Code reads CLAUDE.md. Put your folder layout, autoloads and conventions there so the assistant does not rediscover them every chat.
Ask it to run the project. Both tools ran Pixelorama and read its errors before reporting back. An assistant that only edits text cannot see a scene that fails to load.
Start a new chat for a new task. A long chat full of old file contents leaves less room for the current change.

For a broader comparison of the two tools, see Ziva vs Claude Code for Godot. If you use Claude Code and want Ziva's Godot tools inside it, Ziva can run as a local MCP server.

FAQ

Can an AI assistant handle a large Godot project?

In our test, yes. We asked Ziva and Claude Code, both running Claude Opus 5.5, to add a Sepia effect to Pixelorama (249 GDScript files, about 60,000 lines, 120 scenes). The change touched 8 files across a shader, a dialog scene and script, the menu code, the shortcut list, the layer effects list, project settings and the translation template. All four runs (two per tool) passed the same independent check in the running app. This is one project and one task, so treat it as an example, not a benchmark.

Why does the AI lose track as my Godot project grows?

A model can only see what is in its context window, and a large project does not fit. The agent has to search for the right files, read only those, and keep its notes as the chat grows. In our Pixelorama test Ziva read 17 and 22 of the project's 1,383 files, and its context peaked at 137,000 and 157,000 tokens, far below Claude Opus 5.5's limit. Ziva also checks every GDScript edit with Godot's language server, can save project memories that carry over to new chats, reads an AGENTS.md file with your project's rules, and summarizes long chats automatically when they near the model's limit.

Can Ziva refactor across many Godot files?

We tested a multi-file feature, not a rename: Ziva created a shader, a dialog scene and its script, and edited five existing files, including project.godot through Godot's own project settings API. Both Ziva runs passed our check. We have not yet tested a large rename or move across many scenes.

Is Claude Code or Ziva better for a large Godot project?

On this task both produced working code. Ziva finished in 6 and 13 minutes and charged $1.94 and $2.93 of plan usage. Claude Code took about 16 minutes each time and estimated $2.70 and $3.58 at API prices. Claude Code tested more thoroughly: it checked all four apply targets and save and load, and in one run reported a likely bug in Pixelorama's shared effect code. Ziva tested only the default target, and each run left files in the project root that Ziva pointed out.

Does Ziva index my whole project?

No. Ziva has no embedding or semantic index of your code. It searches the project when it needs something, with ripgrep-based file and text search, and reads files in windows. The Indexing project message you may see on a big project's first chat builds the history Ziva uses for Undo, not a code index.

Is Godot Good for Digital Twins? An Honest 2026 Answer

Ziva — Sat, 07 Nov 2026 15:04:50 +0000

Originally published on ziva.sh: https://ziva.sh/blogs/godot-digital-twin

Yes, for the visual and interactive half of a digital twin: operator screens, training scenes, layout reviews and PLC test benches, with no license fees. No, if the twin has to be the source of truth for physics or process numbers. Godot's physics is built for games, it has no built-in industrial protocols, and it does not import STEP or JT CAD files. The best-known Godot factory simulator, Open Industry Project, archived its Godot version in October 2026 and moved to a browser app.

If your company needs a twin built and checked against your drawings, Kena Labs does that: it builds 3D simulations from a client's drawings, photos, CAD, reports and sensor data and checks them against those sources. Book a demo with Kena Labs.

Ziva.sh publishes this page. Kena Labs is a sister company of Ziva. Facts about Godot and other projects come from their own pages and repositories as of 7 November 2026.

TL;DR

Godot fits the presentation layer. MIT license "for any purpose", strong UI, XR built in, C# and C++ (GDExtension) for your own integrations.
It does not fit as the physics or process model. Godot Jolt "is not able to make such guarantees" about determinism, and CAD has to be converted to glTF or FBX first.
PLC connectivity is up to you. No Modbus or OPC UA addon on the Asset Library today; a Siemens S7 plugin exists, and Modbus TCP is a short GDScript file.
Industrial Godot is real but small. eSOL sells a Godot-based engine for industrial twins, W4 Games sells Godot enterprise support, and Open Industry Project left Godot in 2026.

What a digital twin needs, and what Godot covers

A digital twin is a 3D model of a real asset that stays tied to it: live data from the plant, a model you can trust, and a way to act on what you see. Here is how Godot covers each part.

Need	Godot today
License and cost	"free and open source software released under the permissive MIT license", "free to use Godot Engine, for any purpose" (license)
Operator UI and dashboards	The UI system was made for games but "is also capable of handling complex UI applications and tools" (features)
XR training	"Both OpenXR and WebXR support is built directly into the engine." (features)
Your own integrations	First-class C# on desktop and mobile, and C++ through GDExtension "without having to recompile the engine" (features)
3D import	glTF 2.0 (recommended), Blender `.blend`, FBX, OBJ and COLLADA (formats). No STEP, IGES, JT or IFC: convert CAD to glTF or FBX first.
Physics	Jolt is the default 3D engine for new projects, "developed by Jorrit Rouwe with a focus on games and VR applications" (docs)
Determinism	"Simulations in Godot Jolt may look deterministic, and may even happen to be deterministic, but this should not be relied upon if determinism is a hard requirement." (Godot Jolt)
PLC and plant data	Nothing built in. The Asset Library has a Siemens S7 PLC Plugin (MIT, version 0.1.0 for Godot 4.4) and no Modbus or OPC UA addon. Godot's `StreamPeerTCP`, `WebSocketPeer` and `HTTPRequest` carry anything you write yourself.

The pattern that follows: let a PLC, a simulation tool or a historian own the numbers, and let Godot show them and take operator input. The same split is common in Unity and Unreal twins.

Where Godot is a good choice

You deploy to many screens or customers. No seats, royalties or runtime fees, and you can ship modified versions "even commercially and under a different license (including proprietary)" (license). Unity Personal, by contrast, is "For gaming and entertainment applications only" (pricing).
You want your own editor. Godot's editor is built from the same UI nodes as its projects, so you can turn it into a layout or scenario tool. Open Industry Project's maintainer said in February 2024, after moving the project to Godot: "the fact that editor is built using the same UI as the games gives this project a lot of power" (issue #26).
Training and walkthroughs. VR and AR training, onboarding and sales demos need a good-looking scene and input handling more than certified physics.
PLC test benches and teaching rigs. A conveyor cell driven by a real or soft PLC over Modbus TCP is a small, well-understood project.

Where it falls short

Physics you can sign off on. Game physics trades accuracy for speed, and Godot Jolt makes no determinism promise. If the twin must predict throughput, loads or robot behavior, use a tool built for it and import its results.
CAD and BIM. Engineering formats need a conversion step (CAD to glTF or FBX, often through Blender), and large plants need mesh reduction. Unity, by comparison, says "70+ CAD and 3D file formats can be imported" (Unity).
Industrial protocols. OPC UA, MQTT and most PLC drivers are libraries you wrap yourself. Open Industry Project's Godot version did it with open62541 for OPC UA and libplctag for Modbus TCP and EtherNet/IP, inside a custom Godot build.
Ecosystem. NVIDIA Omniverse and Isaac Sim come with OpenUSD pipelines, robot importers and ROS 2 bridges; Unity and Unreal have industry teams and partners. Godot's industrial ecosystem is a handful of companies and community projects.

What happened to Open Industry Project

Open Industry Project is the project most answers cite for Godot in industry. Its Godot repository described itself as a "Free and open-source warehouse/manufacturing development framework and simulator built on Godot", supported OPC UA, EtherNet/IP, Modbus TCP, Siemens S7, Beckhoff ADS, Universal Robots RTDE and MQTT, and has 859 stars.

On GitHub that repository is now archived, with this notice: "This is the Godot version of Open Industry Project, and it is no longer maintained. Its successor runs in the browser and as a desktop app" (repository). The successor, created on 19 October 2026, describes itself as a "Browser-based industrial automation simulator: conveyors, sensors, PLCs (TypeScript, three.js, Jolt)" (repository).

The maintainers have not published a reason in the repositories. The Godot version's repository shows what users ran into: the project shipped its own Godot fork, and a request for Linux support has been open since November 2025 (issue #228). The new version's site lists its price as "Free. No account, no licence key." If you were planning to build on the Godot version, start from the new one instead or treat the Godot code as reference.

Who uses Godot for industrial work today

eSOL eXRP. A "Godot-based Real-time 3D Engine" for "3D simulations, digital twins, HMIs, and more in industrial sectors such as mobility, robotics, and manufacturing". Its listed uses include "Digital twins for production lines" and "Control simulation for conveyance machines", and eSOL says it "Jointly developed a 3D-LiDAR point cloud simulator" with Tadano Infrastructure Solutions using Godot (eSOL).
W4 Games. It offers "Direct involvement of Godot founders and core maintainers", calls itself "Your enterprise partner in the Godot Engine ecosystem" and sells professional services and "Enterprise-grade support for teams using Godot in production" (W4 Games).
Universities. At GodotFest 2026, an LSU team presented a multiplayer VR and AR digital twin of the university's distillation columns built with Godot (talk).
Community PLC projects. The Siemens S7 PLC Plugin and conveyor-cell demos driven by CODESYS or OpenPLC, many of them built on the archived Open Industry Project.

Godot compared with the usual digital twin platforms

Platform	Non-game licensing, from its own pages	Strongest at
Godot	MIT, "for any purpose"	Free, customizable visualization and tools
Unity Industry	"$4,950.00/yr per seat"; Unity Personal is "For gaming and entertainment applications only"	CAD import, mobile and XR deployment
Unreal Engine	Free for most non-game companies under $1 million in annual gross revenue; above that, $1,850 per seat a year, or a 5% royalty if you license an app that runs the engine	Photorealistic large scenes
NVIDIA Omniverse	"As of May 2026, Omniverse is freely available for both development and production use" (license)	OpenUSD pipelines and physics-based industrial twins
NVIDIA Isaac Sim	Apache 2.0 for the repository code; Omniverse Kit SDK and assets under other terms	Robots, sensors and ROS 2

For the wider field, including Siemens, Azure Digital Twins, AWS IoT TwinMaker and open-source options, see our list of the best digital twin software in 2026.

Connecting Godot to a PLC

Modbus TCP is the easiest place to start: a request is a 7-byte header plus a few bytes of function code and addresses, which GDScript can send over StreamPeerTCP. We wrote and tested one: How to connect Godot to a PLC over Modbus TCP. For Siemens S7-1200 and S7-1500 PLCs, the S7 plugin above reads and writes variables directly. For OPC UA, the realistic routes are a C# OPC UA library in a Godot .NET project or a GDExtension around open62541. Whichever you pick, poll on a timer rather than every frame, and treat a dropped connection as an error the operator sees, not a value that silently freezes.

If you build the Godot side yourself, Ziva, an AI agent that works inside the Godot editor, can write the scenes, GDScript or C# and the UI for you, and run the scene to check it. It does not come with PLC drivers or validated physics. Ziva also works inside NVIDIA Isaac Sim, for teams through Ziva Enterprise.

When to have a twin built instead

If the twin has to match drawings and sensor data, the 3D is the smaller part of the work: collecting the drawings, checking dimensions and wiring the data take most of the time. Kena Labs builds simulations from that material. In its words, it turns "specs and photos into interactive 3D": "Drawings, photos, CAD, reports and sensor data become one scene", the scene is "Checked against the drawing, the sensor record or the case file", and it can be handed off as "OpenUSD for simulation, IFC for the plant model". Its published demos, on public-domain and sample material, include a 1950 pump house rebuilt from one drawing and a parcel line tested in 16 scenarios at once in NVIDIA Isaac Sim.

Kena Labs is a sister company of Ziva. Send Kena Labs your drawing or spec and book a demo.

FAQ

Can Godot be used for a digital twin?

Yes, as the 3D, UI and interaction layer of a digital twin: operator screens, training scenes, layout reviews and PLC test benches. Godot is MIT licensed, so there are no seat or runtime fees, and it imports glTF, Blender, FBX, OBJ and COLLADA. It has no built-in OPC UA, Modbus or MQTT client, no native STEP or JT CAD import, and its physics is a game engine's physics: the Godot Jolt project says simulations should not be relied on to be deterministic. Teams that need an engineering-grade twin usually run the model outside Godot and use Godot to show it.

Is Godot good for industrial simulation?

For visual, interactive simulations such as conveyor cells, warehouse layouts and training, it works, and eSOL sells a Godot-based engine, eXRP, for industrial digital twins and HMIs. For simulations whose numbers must be trusted, it is a weaker base than tools built for that job, such as Siemens Plant Simulation and Process Simulate or NVIDIA Isaac Sim, because physics is not guaranteed to be deterministic and industrial protocols are add-ons. Open Industry Project, the best-known Godot factory simulator, archived its Godot version in October 2026 and moved to a browser app.

Is Godot good for non-game applications?

Often, yes. Godot's license lets you use it for any purpose, its UI system is, in the project's words, capable of handling complex UI applications and tools, and the editor itself is a Godot application. It suits apps that need real-time 2D or 3D, XR or custom editors. For plain forms-and-tables business software, a regular app framework is usually simpler.

Who offers enterprise support for Godot in industrial projects?

W4 Games, which offers "Direct involvement of Godot founders and core maintainers", sells professional services and premium support for teams using Godot in production. eSOL sells eXRP, a Godot-based real-time 3D engine for industrial digital twins and HMIs, with engineering, consulting and support services.

How to Connect Godot to a PLC over Modbus TCP (Tested GDScript Client)

Ziva — Sat, 07 Nov 2026 15:04:42 +0000

Originally published on ziva.sh: https://ziva.sh/blogs/godot-modbus-tcp

Godot has no Modbus or OPC UA support built in, and the Godot Asset Library has no Modbus or OPC UA addon. Modbus TCP is simple enough that you do not need one: each request is a 7-byte header and a 5-byte command sent over TCP, which GDScript can do with StreamPeerTCP. Below is a complete client for reading coils and holding registers and writing single coils and registers, a conveyor that runs while a PLC coil is on, and how we tested both. For Siemens S7 PLCs and OPC UA, see the other options.

We tested this on Godot 4.7.2 on Linux, headless, against two independent Modbus TCP servers: pymodbus 3.16.2 and pyModbusTCP 0.3.1. All 15 checks passed on both on 7 November 2026. We did not test it against PLC hardware. Ziva.sh publishes this page.

The client

Save this as modbus_tcp_client.gd. It supports function codes 1 (read coils), 3 (read holding registers), 5 (write single coil) and 6 (write single register), one request at a time. Every call returns null on failure and sets last_error, so a lost PLC shows up as an error instead of a value that silently stops changing.

class_name ModbusTcpClient
extends RefCounted
## Minimal Modbus TCP client (FC1, FC3, FC5, FC6), one request at a time.
## Every call returns null on failure and sets last_error; Modbus exception
## replies also set last_exception_code. Successful writes return true.
##
## Calls block the calling thread until the reply arrives or timeout_ms passes.
## A LAN PLC answers in a few ms; run the client on a Thread for slow links.

const EXCEPTION_NAMES := {1: "Illegal Function", 2: "Illegal Data Address", 3: "Illegal Data Value",
    4: "Server Device Failure", 6: "Server Device Busy", 10: "Gateway Path Unavailable",
    11: "Gateway Target Failed To Respond"}

var unit_id := 1
var timeout_ms := 1000
var last_error := ""
var last_exception_code := 0
var _tcp := StreamPeerTCP.new()
var _transaction_id := 0


func connect_to_host(host: String, port: int = 502) -> Variant:
    last_error = ""
    last_exception_code = 0
    _tcp = StreamPeerTCP.new()
    var err := _tcp.connect_to_host(host, port)
    if err != OK:
        return _fail("connect to %s:%d failed: %s" % [host, port, error_string(err)])
    var deadline := Time.get_ticks_msec() + timeout_ms
    while Time.get_ticks_msec() < deadline:
        _tcp.poll()
        match _tcp.get_status():
            StreamPeerTCP.STATUS_CONNECTED:
                return true
            StreamPeerTCP.STATUS_ERROR, StreamPeerTCP.STATUS_NONE:
                return _fail("connect to %s:%d refused or failed" % [host, port])
        OS.delay_msec(1)
    return _fail_and_close("connect to %s:%d timed out after %d ms" % [host, port, timeout_ms])


func read_coils(address: int, count: int) -> Variant:
    var reply = _transact(0x01, address, count, 2 + ceili(count / 8.0))
    if reply == null:
        return null
    var coils: Array[bool] = []
    for i in count:
        coils.append((reply[2 + (i >> 3)] >> (i & 7)) & 1 == 1)
    return coils


func read_holding_registers(address: int, count: int) -> Variant:
    var reply = _transact(0x03, address, count, 2 + count * 2)
    if reply == null:
        return null
    var registers: Array[int] = []
    for i in count:
        registers.append(reply[2 + i * 2] << 8 | reply[3 + i * 2])
    return registers


func write_single_coil(address: int, on: bool) -> Variant:
    return null if _transact(0x05, address, 0xFF00 if on else 0x0000, 5) == null else true


func write_single_register(address: int, value: int) -> Variant:
    return null if _transact(0x06, address, value, 5) == null else true


func _transact(function_code: int, address: int, value: int, reply_size: int) -> Variant:
    last_error = ""
    last_exception_code = 0
    if _tcp.get_status() != StreamPeerTCP.STATUS_CONNECTED:
        return _fail("not connected; call connect_to_host() first")
    if address < 0 or address > 0xFFFF or value < 0 or value > 0xFFFF:
        return _fail("address %d or value/count %d is outside 0..65535" % [address, value])
    _transaction_id = (_transaction_id + 1) & 0xFFFF
    var pdu := PackedByteArray([function_code, address >> 8, address & 0xFF, value >> 8, value & 0xFF])
    # MBAP header: transaction id, protocol id 0, byte count of unit id + PDU, unit id.
    var mbap := PackedByteArray([_transaction_id >> 8, _transaction_id & 0xFF, 0, 0, 0, pdu.size() + 1, unit_id])
    var err := _tcp.put_data(mbap + pdu)
    if err != OK:
        return _fail_and_close("send failed: %s" % error_string(err))
    var deadline := Time.get_ticks_msec() + timeout_ms
    var header = _read_exact(7, deadline)
    if header == null:
        return null
    var length: int = header[4] << 8 | header[5]
    if (header[0] << 8 | header[1]) != _transaction_id or header[2] != 0 or header[3] != 0 \
            or header[6] != unit_id or length < 3 or length > 254:
        return _fail_and_close("bad MBAP header %s for transaction %d" % [header.hex_encode(), _transaction_id])
    var reply = _read_exact(length - 1, deadline)
    if reply == null:
        return null
    if reply[0] == (function_code | 0x80):
        last_exception_code = reply[1]
        return _fail("Modbus exception %d (%s) for function %d at address %d" % [
                reply[1], EXCEPTION_NAMES.get(reply[1], "unknown code"), function_code, address])
    var valid: bool = reply == pdu if function_code >= 5 else reply.size() == reply_size and reply[1] == reply_size - 2
    if reply[0] != function_code or not valid:
        return _fail_and_close("unexpected reply %s to request %s" % [reply.hex_encode(), pdu.hex_encode()])
    return reply


func _read_exact(byte_count: int, deadline: int) -> Variant:
    while true:
        _tcp.poll()
        if _tcp.get_available_bytes() >= byte_count:
            return _tcp.get_data(byte_count)[1]
        if _tcp.get_status() != StreamPeerTCP.STATUS_CONNECTED:
            return _fail("connection closed while waiting for %d bytes" % byte_count)
        if Time.get_ticks_msec() >= deadline:
            # The late reply would desync the next transaction, so drop the socket.
            return _fail_and_close("timeout: no reply within %d ms (connection closed)" % timeout_ms)
        OS.delay_msec(1)
    return null


func _fail_and_close(message: String) -> Variant:
    _tcp.disconnect_from_host()
    return _fail(message)


func _fail(message: String) -> Variant:
    last_error = message
    push_error("ModbusTcpClient: " + message)
    return null

Using it:

var plc := ModbusTcpClient.new()
if plc.connect_to_host("192.168.0.10", 502) == null:
    push_error(plc.last_error)
    return
plc.write_single_register(0, 1234)          # holding register 40001
var regs = plc.read_holding_registers(0, 2)  # [1234, ...]
plc.write_single_coil(3, true)               # coil 00004
var coils = plc.read_coils(0, 8)             # [false, false, false, true, ...]

Addresses are zero-based offsets: register 40001 in a PLC manual is offset 0, and coil 00001 is offset 0. If your values are off by one register, this is why.

A conveyor driven by a PLC coil

This Node3D polls coil 0 every 50 ms and moves a Box child along the belt while the coil is on. If the connection drops, it stops the belt rather than leaving it running on the last value it saw.

extends Node3D
## Moves $Box along the belt while PLC coil `motor_coil` is on. Polls every 50 ms.

@export var plc_host := "127.0.0.1"
@export var plc_port := 502
@export var motor_coil := 0
@export var belt_speed := 0.5 # meters per second
var plc := ModbusTcpClient.new()
var motor_on := false


func _ready() -> void:
    if plc.connect_to_host(plc_host, plc_port) == null:
        return
    var timer := Timer.new()
    timer.wait_time = 0.05
    timer.timeout.connect(_poll_plc.bind(timer))
    add_child(timer)
    timer.start()


func _poll_plc(timer: Timer) -> void:
    var coils = plc.read_coils(motor_coil, 1)
    if coils == null:
        timer.stop() # Comms lost: stop the belt; the client already logged why.
        motor_on = false
        return
    motor_on = coils[0]


func _physics_process(delta: float) -> void:
    if motor_on:
        $Box.position.x += belt_speed * delta

Polling on a 50 ms Timer keeps PLC traffic independent of frame rate. Each call blocks until the reply arrives; a PLC on the local network answers in a few milliseconds, but a dead one blocks for up to timeout_ms, so keep the timeout short or move polling to a Thread on slow links.

How we tested it

We ran a Modbus TCP server with 16 coils and 16 holding registers on 127.0.0.1, then a headless Godot script that writes and reads back registers and coils, reads past the end of the data (which must return Modbus exception 2, Illegal Data Address), checks the connection still works after the exception, checks a 200 ms timeout against a server that never answers, and runs the conveyor scene for a few frames with coil 0 on and then off.

python3 -m venv /tmp/modbus-venv
/tmp/modbus-venv/bin/pip install pyModbusTCP==0.3.1
/tmp/modbus-venv/bin/python -c "from pyModbusTCP.server import DataBank, ModbusServer; ModbusServer(host='127.0.0.1', port=5021, data_bank=DataBank(coils_size=16, d_inputs_size=16, h_regs_size=16, i_regs_size=16)).start()" &
godot --headless --path . --import
godot --headless --path . --script res://test_modbus.gd -- --port=5021

The project holds a minimal project.godot, modbus_tcp_client.gd, conveyor.gd and conveyor.tscn (a Node3D with conveyor.gd attached and a MeshInstance3D child named Box), plus this test script:

test_modbus.gd

extends SceneTree
## Headless test: godot --headless --path . --script res://test_modbus.gd -- --port=5020
## Expects a server with 16 coils and 16 holding registers (addresses 0..15) on 127.0.0.1.

var failures := 0


func check(name: String, ok: bool, detail: Variant = "") -> void:
    print("%s %s %s" % ["PASS" if ok else "FAIL", name, detail])
    if not ok:
        failures += 1


func _initialize() -> void:
    var port := 5020
    for arg in OS.get_cmdline_user_args():
        if arg.begins_with("--port="):
            port = int(arg.trim_prefix("--port="))
    print("Godot %s, server 127.0.0.1:%d" % [Engine.get_version_info().string, port])
    var plc := ModbusTcpClient.new()
    check("connect", plc.connect_to_host("127.0.0.1", port) == true, plc.last_error)

    check("FC6 write register 0 = 1234", plc.write_single_register(0, 1234) == true, plc.last_error)
    check("FC6 write register 1 = 0xBEEF", plc.write_single_register(1, 0xBEEF) == true, plc.last_error)
    var regs = plc.read_holding_registers(0, 2)
    check("FC3 read registers 0..1 == [1234, 48879]", regs == [1234, 0xBEEF], regs)

    check("FC5 write coil 3 = true", plc.write_single_coil(3, true) == true, plc.last_error)
    var coils = plc.read_coils(0, 8)
    check("FC1 read coils 0..7 has only coil 3 on", coils == [false, false, false, true, false, false, false, false], coils)
    plc.write_single_coil(3, false)
    coils = plc.read_coils(0, 16)
    check("FC5 coil 3 = false then FC1 read coils 0..15 all off", coils != null and coils.size() == 16 and not coils.has(true), coils)

    var bad = plc.read_holding_registers(100, 1)
    check("FC3 read register 100 returns exception 2", bad == null and plc.last_exception_code == 2, plc.last_error)
    bad = plc.read_coils(16, 1)
    check("FC1 read coil 16 returns exception 2", bad == null and plc.last_exception_code == 2, plc.last_error)
    regs = plc.read_holding_registers(0, 1)
    check("connection still usable after exception", regs == [1234], regs)

    var silent := TCPServer.new()
    silent.listen(5099, "127.0.0.1")
    var mute_plc := ModbusTcpClient.new()
    mute_plc.timeout_ms = 200
    mute_plc.connect_to_host("127.0.0.1", 5099)
    var started := Time.get_ticks_msec()
    var result = mute_plc.read_coils(0, 1)
    var elapsed := Time.get_ticks_msec() - started
    check("timeout on silent server after ~200 ms", result == null and mute_plc.last_error.begins_with("timeout") and elapsed >= 200 and elapsed < 400, "%d ms: %s" % [elapsed, mute_plc.last_error])
    check("call after timeout reports not connected", mute_plc.read_coils(0, 1) == null and mute_plc.last_error.begins_with("not connected"), mute_plc.last_error)
    silent.stop()
    check("connect refused reports error", ModbusTcpClient.new().connect_to_host("127.0.0.1", 5098) == null)

    var conveyor: Node3D = load("res://conveyor.tscn").instantiate()
    conveyor.plc_port = port
    root.add_child(conveyor)
    plc.write_single_coil(0, true)
    await create_timer(0.5).timeout
    var moved_x: float = conveyor.get_node("Box").position.x
    check("conveyor box moves while coil 0 is on", moved_x > 0.15, "x=%.3f" % moved_x)
    plc.write_single_coil(0, false)
    await create_timer(0.2).timeout
    var stopped_x: float = conveyor.get_node("Box").position.x
    await create_timer(0.3).timeout
    var final_x: float = conveyor.get_node("Box").position.x
    check("conveyor box stops when coil 0 is off", is_equal_approx(stopped_x, final_x), "x=%.3f then %.3f" % [stopped_x, final_x])

    print("RESULT: %s (%d failures)" % ["PASS" if failures == 0 else "FAIL", failures])
    quit(1 if failures else 0)

The PASS and FAIL lines against pyModbusTCP 0.3.1 are below. The full log also has ERROR: ModbusTcpClient: ... lines from the checks that expect an error; those are expected. pymodbus 3.16.2 passed the same 15 checks, with the timeout at 200 ms instead of 201 ms.

Godot 4.7.2-stable (arch_linux), server 127.0.0.1:5021
PASS connect
PASS FC6 write register 0 = 1234
PASS FC6 write register 1 = 0xBEEF
PASS FC3 read registers 0..1 == [1234, 48879] [1234, 48879]
PASS FC5 write coil 3 = true
PASS FC1 read coils 0..7 has only coil 3 on [false, false, false, true, false, false, false, false]
PASS FC5 coil 3 = false then FC1 read coils 0..15 all off [false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false]
PASS FC3 read register 100 returns exception 2 Modbus exception 2 (Illegal Data Address) for function 3 at address 100
PASS FC1 read coil 16 returns exception 2 Modbus exception 2 (Illegal Data Address) for function 1 at address 16
PASS connection still usable after exception [1234]
PASS timeout on silent server after ~200 ms 201 ms: timeout: no reply within 200 ms (connection closed)
PASS call after timeout reports not connected not connected; call connect_to_host() first
PASS connect refused reports error
PASS conveyor box moves while coil 0 is on x=0.183
PASS conveyor box stops when coil 0 is off x=0.208 then 0.208
RESULT: PASS (0 failures)

With no server listening, the same script exits with code 1 and FAIL lines, so a broken setup cannot pass silently.

Limits

Function codes 1, 3, 5 and 6 only. Discrete inputs (2), input registers (4) and multiple writes (15, 16) need a few more lines each.
No automatic reconnect: after a timeout the socket is closed and you call connect_to_host again.
No TLS or authentication. Keep plain Modbus TCP on an isolated control network.
32-bit values split across two registers are not decoded; word order differs between PLC vendors.
It does not work in web exports. Godot's web export docs say: "Low-level networking is not implemented due to lacking support in browsers."
Tested on Linux desktop only, not on PLC hardware.

Siemens S7 and OPC UA

Siemens S7. The Siemens S7 PLC Plugin on the Asset Library (MIT, version 0.1.0 for Godot 4.4) says it connects to S7-300, S7-400, S7-1200 and S7-1500 PLCs and reads and writes variables directly. We did not test it.
OPC UA in C#. The OPC Foundation's UA .NET Standard stack, "The official OPC Foundation reference implementation of OPC UA for .NET", runs on .NET 8, which Godot's .NET build uses, and Godot's docs say "NuGet packages can be installed and used with Godot, as with any C# project." C# projects cannot be exported to the web.
OPC UA in a GDExtension. Wrap open62541, a C implementation of OPC UA under MPL 2.0. Open Industry Project's oip-comms did this for its Godot version, which is now archived and no longer maintained.
A bridge process. Run an OPC UA client such as Node-RED or Python's asyncua next to Godot and pass values over a WebSocket. This is the only route that also works in a web export.

We tested none of the OPC UA routes. For whether Godot is the right engine for the whole twin, see Is Godot good for digital twins?

Need the whole twin built?

A PLC link is one piece. If you need a plant, line or cell rebuilt from your drawings and checked against them, Kena Labs builds 3D simulations from a client's drawings, photos, CAD, reports and sensor data and checks them against those sources; one of its demos is a parcel line tested in 16 scenarios at once. Kena Labs is a sister company of Ziva. Book a demo with Kena Labs.

If you are building the Godot side yourself, Ziva, an AI agent inside the Godot editor, can write this kind of client and scene code for you and run the scene to check it.

FAQ

Can Godot connect to a PLC over Modbus TCP or OPC UA?

Yes, but neither is built in. Modbus TCP is a small binary protocol over TCP, so a GDScript client on StreamPeerTCP is enough; ours reads coils (function 1) and holding registers (function 3) and writes single coils and registers (functions 5 and 6), and it passed every check against two independent Modbus servers on Godot 4.7.2. For OPC UA you need a library: the OPC Foundation's .NET stack in a Godot .NET project, a GDExtension around open62541, or a separate bridge process that passes values to Godot.

Is there a Modbus or OPC UA addon for Godot?

Not on the Godot Asset Library as of November 2026; searches for Modbus and OPC UA return nothing relevant. The Asset Library does have a Siemens S7 PLC Plugin (MIT, version 0.1.0 for Godot 4.4) that reads and writes S7-300, S7-400, S7-1200 and S7-1500 variables. Open Industry Project's oip-comms GDExtension supported OPC UA and Modbus TCP, but it is archived and no longer maintained.

Does Modbus TCP work in a Godot web export?

No. Godot's web export docs say low-level networking is not implemented because browsers do not support it; only HTTP, WebSocket client and WebRTC work. For a browser-based HMI or twin, run a bridge that reads the PLC and sends values to Godot over a WebSocket.

How to simulate keyboard and mouse input in GUT and GdUnit4 (tested on Godot 4.7.2)

Ziva — Sat, 07 Nov 2026 06:42:49 +0000

In GUT, queue input on a GutInputSender aimed at Input and await its idle signal before you assert; in GdUnit4, call the scene runner's simulate_key_*, simulate_action_* and simulate_mouse_button_* methods, wait, and await runner.await_input_processed().

Ziva.sh publishes this page and makes Ziva. We ran every test and command on this page on 7 November 2026 with Godot 4.7.2 on Linux, GUT 9.7.1 and GdUnit4 6.2.3, the latest releases that day, on the public Star Catcher sample, a 2D game where the arrow keys move a square into stars. Method names come from the installed addons' source code.

GUT

GUT's GutInputSender sends input events to receivers. With Input as the receiver, GUT 9.7.1 passes each event to Input.parse_input_event, so the game sees it like hardware input. Chained calls are queued and played back in real time, and await _sender.idle waits until the queue is empty.

# res://test/test_input.gd
extends GutTest

var _sender := GutInputSender.new(Input)


func after_each() -> void:
    _sender.release_all()
    _sender.clear()


func test_holding_right_arrow_collects_a_star() -> void:
    var main: Node = add_child_autofree(load("res://main.tscn").instantiate())
    _sender.key_down(KEY_RIGHT).hold_for(1.2).wait(0.3)
    await _sender.idle
    assert_eq(main.get_node("HUD/ScoreLabel").text, "Score: 1")


func test_holding_ui_right_action_collects_a_star() -> void:
    var main: Node = add_child_autofree(load("res://main.tscn").instantiate())
    _sender.action_down("ui_right").hold_for(1.2).wait(0.3)
    await _sender.idle
    assert_eq(main.get_node("HUD/ScoreLabel").text, "Score: 1")


func test_clicking_a_button_emits_pressed() -> void:
    var button: Button = add_child_autofree(Button.new())
    button.position = Vector2(300, 200)
    button.size = Vector2(100, 40)
    watch_signals(button)
    _sender.mouse_left_click_at(Vector2(350, 220))
    await _sender.idle
    assert_signal_emitted(button, "pressed")

hold_for(1.2) sends the matching release 1.2 seconds after the press, and wait(0.3) gives the game time to react; both also take a frame count as a string such as "10f". GutInputSender also has key_up, action_up, mouse_left_button_down, mouse_left_button_up, mouse_right_button_down, mouse_right_button_up, mouse_double_click, mouse_motion, mouse_relative_motion, wait_frames and hold_frames. GUT's docs say to call release_all() "between each test when using Input as a receiver" and clear() "so that state does not leak between tests", which is what after_each does here.

Under xvfb-run with -gcompact_mode, all three tests passed. Headless, the two keyboard tests passed and the click test failed; see Pitfalls.

GdUnit4

GdUnit4's scene runner loads a scene, or wraps a node you pass it, and feeds simulated input through Input.parse_input_event. GdUnit4's docs say "you must wait at least one frame cycle after simulating inputs" and point to await runner.await_input_processed().

# res://test/test_input.gd
extends GdUnitTestSuite


func test_holding_right_arrow_collects_a_star() -> void:
    var runner := scene_runner("res://main.tscn")
    runner.simulate_key_press(KEY_RIGHT)
    await await_millis(1200)
    runner.simulate_key_release(KEY_RIGHT)
    await runner.await_input_processed()
    assert_str(runner.find_child("ScoreLabel").text).is_equal("Score: 1")


func test_holding_ui_right_action_collects_a_star() -> void:
    var runner := scene_runner("res://main.tscn")
    runner.simulate_action_press("ui_right")
    await await_millis(1200)
    runner.simulate_action_release("ui_right")
    await runner.await_input_processed()
    assert_str(runner.find_child("ScoreLabel").text).is_equal("Score: 1")


func test_clicking_a_button_emits_pressed() -> void:
    var button: Button = auto_free(Button.new())
    button.position = Vector2(300, 200)
    button.size = Vector2(100, 40)
    var runner := scene_runner(button)
    monitor_signals(button, false)
    runner.set_mouse_position(Vector2(350, 220))
    runner.simulate_mouse_button_pressed(MOUSE_BUTTON_LEFT)
    await runner.await_input_processed()
    await assert_signal(button).is_emitted("pressed")

GdUnit4 6.2.3 has three methods for each kind of input:

Input	Press and release	Press only	Release
Key	`simulate_key_pressed(KEY_ENTER)`	`simulate_key_press(KEY_SHIFT)`	`simulate_key_release(KEY_SHIFT)`
Mouse button	`simulate_mouse_button_pressed(MOUSE_BUTTON_LEFT)`	`simulate_mouse_button_press(MOUSE_BUTTON_LEFT)`	`simulate_mouse_button_release(MOUSE_BUTTON_LEFT)`
Input action	`simulate_action_pressed("ui_accept")`	`simulate_action_press("ui_right")`	`simulate_action_release("ui_right")`

GdUnit4 moves the mouse with set_mouse_position(position) and simulate_mouse_move(position), or gradually with simulate_mouse_move_relative and simulate_mouse_move_absolute. In GdUnit4 6.2.3, simulate_key_pressed waits one frame between the press and the release, so await it, while simulate_action_pressed and simulate_mouse_button_pressed press and release within the same call. For a key combination, GdUnit4's key docs say to hold each key with simulate_key_press, such as KEY_CTRL then KEY_C, because the shift and control arguments are deprecated and "will be removed in v7.0".

Under xvfb-run, GdUnit4 6.2.3 passed all three tests. GdUnit4's master branch, the unreleased 7.0.0 (commit 2cc420a), also passed all three with --headless.

Outside a test framework

Godot itself has two ways to fake input from code:

# A key event: _input() sees it, and the ui_right action mapped to that key becomes pressed.
var key := InputEventKey.new()
key.keycode = KEY_RIGHT
key.pressed = true
Input.parse_input_event(key)

# An action only: Input.is_action_pressed("ui_right") is true, but _input() is never called.
Input.action_press("ui_right")
Input.action_release("ui_right")

In our headless Godot 4.7.2 run, a node's _input printed the parsed key's press and release and nothing for action_press, and Input.is_action_pressed("ui_right") was true after both. Godot's Input docs say parse_input_event "Also generates Node._input() calls" and that action_press "will not cause any Node._input() calls". To release a parsed key, send another InputEventKey with pressed = false. Neither call touches the operating system: Godot's docs say sending Alt/Cmd + Tab as an InputEventKey "won't toggle between active windows".

Pitfalls

Headless runs don't click Controls. With godot --headless, Godot 4.7.2 delivered our simulated clicks to _input but never pressed a Button: the click test failed in GUT 9.7.1, in GdUnit4 6.2.3 and in a plain project using Input.parse_input_event, and passed in all three under xvfb-run (GUT with -gcompact_mode). GdUnit4 6.2.3's own warning says "Godot 'InputEvents' are not transported by the Godot engine in headless mode", although our key and action tests passed headless. GdUnit4's unreleased master runs the scene in its own SubViewport, and there the click test passed headless.
GUT's results panel covers the game. Under xvfb-run, GUT 9.7.1's click test still failed, because GUT's output panel, on a CanvasLayer at layer 128, was the control under the click. With -gcompact_mode the click reached the button and the test passed.
GdUnit4 6.2.3 refuses --headless. GdUnit4 6.2.3's runtest.sh --headless stops with "Headless mode is not supported!" and exit code 103 before running any test, unless you add --ignoreHeadlessMode. GdUnit4's master says headless "is supported by default".
simulate_frames counts frames, not seconds. GdUnit4's simulate_frames(72) waits for 72 process frames, so the game time that passes depends on the frame rate. Holding ui_right for 72 frames passed headless, where the test took about half a second, and failed 3 times out of 3 under xvfb-run, where it took 110 to 178 ms and the player never reached the star. Wait for time instead: await await_millis(1200) in GdUnit4, hold_for(1.2) in GUT.
simulate_action_pressed is too short for polling. GdUnit4 6.2.3's simulate_action_pressed presses and releases the action in the same call: right after it, Input.is_action_pressed("ui_right") was false, and the Star Catcher player, which reads Input.get_vector in _physics_process, moved 0 px in the next 500 ms. Use simulate_action_press, wait, then simulate_action_release.
GdUnit4's Shift and Ctrl arguments are going away. GdUnit4 6.2.3 prints "Deprecated! Don't use 'shift_pressed' it will be removed in v7.0" for simulate_key_pressed(KEY_A, true), and on GdUnit4's master the same call is a parse error, "Too many arguments for "simulate_key_pressed()" call". Hold KEY_SHIFT with simulate_key_press instead.

Running headless in CI

Import the project once, then run the suite. For tests that only use keys and actions, headless is enough:

godot --headless --path . --import
godot --headless --path . -s addons/gut/gut_cmdln.gd -gdir=res://test -gexit
./addons/gdUnit4/runtest.sh --godot_binary /usr/bin/godot --headless --ignoreHeadlessMode -a res://test

GUT 9.7.1 exited 0 when every test passed and 1 when one failed. GdUnit4 6.2.3's runtest.sh exited 0 on success, 100 when a test failed, and 103 when we left out --ignoreHeadlessMode.

For tests that click Controls, drop --headless and run under xvfb-run, which starts a virtual X display, so the CI machine needs no screen:

xvfb-run -a godot --path . -s addons/gut/gut_cmdln.gd -gdir=res://test -gcompact_mode -gexit
xvfb-run -a ./addons/gdUnit4/runtest.sh --godot_binary /usr/bin/godot -a res://test

Both exited 0 with all three tests passing.

If you would rather not script inputs in a test framework, Ziva, an AI agent inside the Godot editor, has a run_scene tool that runs a scene in the open editor with timed key, action and mouse inputs and returns the runtime errors, the console output and a screenshot; Ziva's run_scene doesn't replace GUT or GdUnit4 tests and doesn't run headless in CI.

FAQ

How do I simulate keyboard and mouse input in Godot tests (GUT or GdUnit4)?

In GUT, create GutInputSender.new(Input), queue input such as key_down(KEY_RIGHT).hold_for(1.2).wait(0.3), action_down("ui_right") or mouse_left_click_at(Vector2(350, 220)), await the sender's idle signal, then assert; call release_all() and clear() in after_each. In GdUnit4, load the scene with scene_runner("res://main.tscn") and call simulate_key_press and simulate_key_release, simulate_action_press and simulate_action_release, or set_mouse_position and simulate_mouse_button_pressed, wait with await await_millis(1200) rather than a frame count, then await runner.await_input_processed() before asserting. In our Godot 4.7.2 tests with GUT 9.7.1 and GdUnit4 6.2.3, key and action input worked headless, but clicks on a Button only worked with a display, such as xvfb-run.

Why doesn't my simulated mouse click press a Button when I run Godot tests headless?

With godot --headless, Godot 4.7.2 delivered our simulated mouse clicks to _input but never pressed a Button, in GUT 9.7.1, in GdUnit4 6.2.3 and in a plain project using Input.parse_input_event. The same tests passed under xvfb-run, a virtual X display. GdUnit4 6.2.3's own warning says "Godot 'InputEvents' are not transported by the Godot engine in headless mode". In GUT, also pass -gcompact_mode on a display, because GUT's results panel otherwise covers the game and takes the click.

How do I run GUT or GdUnit4 tests headless in CI, and what exit codes do they return?

Import once with godot --headless --path . --import. GUT 9.7.1: godot --headless --path . -s addons/gut/gut_cmdln.gd -gdir=res://test -gexit, which exited 0 when every test passed and 1 when one failed. GdUnit4 6.2.3: ./addons/gdUnit4/runtest.sh --godot_binary /usr/bin/godot --headless --ignoreHeadlessMode -a res://test, which exits 0 on success and 100 on a failed test; without --ignoreHeadlessMode, GdUnit4 6.2.3 refuses to run headless and exits 103. For tests that click Controls, run either tool without --headless under xvfb-run -a.

What is the difference between Input.parse_input_event and Input.action_press in Godot?

Input.parse_input_event feeds an InputEvent, such as an InputEventKey, through Godot's input system, so Node._input() receives it and any action mapped to that key becomes pressed. Input.action_press only marks the action as pressed: Input.is_action_pressed returns true, but Godot's docs say it "will not cause any Node._input() calls". In our Godot 4.7.2 run, a node's _input printed the parsed key press and release and nothing for action_press.

Godot MCP server for Claude Code and Cursor: run the game, send input, take screenshots

Ziva — Sat, 07 Nov 2026 06:42:41 +0000

Several Godot MCP servers let Claude Code or Cursor run your game, send it input and screenshot the running game: Ziva, Godot MCP Pro, GDAI MCP, Godot AI (hi-godot/godot-ai) and Erodenn/godot-mcp-runtime, plus Summer Engine's MCP for Summer's own editor. In Ziva, one tool does all three: run_scene runs a scene in the open Godot editor, sends timed keyboard, mouse, input-action and UI-click input, and returns a screenshot of the running game with that run's console output and runtime errors. Ziva's get_godot_errors reads Godot's errors and output, and Ziva's get_screenshot captures the editor, not the game. To connect Claude Code, click Install for Claude Code in Ziva's settings, which runs claude mcp add --scope user ziva-godot -- ... for you. The Ziva plugin supports Godot 4.2 or later and its MCP tools need no paid plan, but Ziva's run_scene and get_screenshot need the Ziva dock signed in (the free Hobby plan works).

Ziva.sh makes Ziva and publishes this page. Facts about other servers are quoted from each vendor's own page or README as of 7 November 2026, except Godot AI's C# statement, from its README on 4 November 2026. Disclosure: GDAI MCP is made by Delano Lourenco, a Ziva cofounder.

Godot MCP servers compared: run, input, screenshot

Server	Cost/licence	Setup	Run game	Input to running game	Game screenshot	Errors/output	Godot version
Ziva (local MCP server inside the Ziva plugin)	Ziva: free Hobby plan works; sign-in needed for screenshots	Ziva: install the plugin, click Install for Claude Code or Install for Cursor; no Node.js or uv	Ziva: `run_scene`, in the open editor	Ziva: `run_scene` actions, keys, left and right clicks, clicks on a Control by path or text, mouse motion	Ziva: `run_scene` returns the final frame; `get_screenshot` is the editor only	Ziva: `run_scene` output and runtime errors; `get_godot_errors`	Ziva: plugin 4.2+; we ran `run_scene` on 4.7.2
Coding-Solo/godot-mcp	Coding-Solo/godot-mcp: free, MIT	Coding-Solo/godot-mcp: `claude mcp add godot -- npx @coding-solo/godot-mcp`; Node.js 18+	Coding-Solo/godot-mcp: "Execute Godot projects in debug mode"	Coding-Solo/godot-mcp: not stated	Coding-Solo/godot-mcp: not stated	Coding-Solo/godot-mcp: "Retrieve console output and error messages"	Coding-Solo/godot-mcp: not stated; UID tools need 4.4+
GDAI MCP	GDAI MCP: "$19 one-time payment", binary only	GDAI MCP: addon in `res://addons/`, plus `uv`	GDAI MCP: `play_scene`	GDAI MCP: `simulate_input`, "keyboard keys and input actions"; mouse not stated	GDAI MCP: `get_running_scene_screenshot`	GDAI MCP: `get_godot_errors`	GDAI MCP: "Godot 4.2+" on its site; its GitHub README says 4.1+
Godot MCP Pro	Godot MCP Pro: "$15 one-time purchase"; server proprietary	Godot MCP Pro: addon plus the Node.js server from the paid package; Node.js 18+	Godot MCP Pro: `play_scene`	Godot MCP Pro: `simulate_key`, `simulate_mouse_click`, `simulate_mouse_move`, `simulate_action`, `simulate_sequence`	Godot MCP Pro: `get_game_screenshot`	Godot MCP Pro: `get_editor_errors`, `get_output_log`	Godot MCP Pro: "Godot 4.4 or later"
Godot AI (hi-godot/godot-ai)	Godot AI: free, MIT	Godot AI: addon from AssetLib, `uv`, then Configure in the Godot AI dock	Godot AI: `project_run`	Godot AI: `game_manage` with `input_key`, `input_mouse`, `input_gamepad`, `input_action`	Godot AI: `editor_screenshot` of the "running game framebuffer"	Godot AI: `logs_read`	Godot AI: "Godot 4.7+"
Erodenn/godot-mcp-runtime	godot-mcp-runtime: free, MIT	godot-mcp-runtime: `npx -y godot-mcp-runtime` with `GODOT_PATH`; Node.js 20+; "No Godot addon"	godot-mcp-runtime: `run_project`	godot-mcp-runtime: `simulate_input`: keys, mouse clicks and motion, clicks on UI elements, actions, text	godot-mcp-runtime: `take_screenshot`	godot-mcp-runtime: `get_debug_output`	godot-mcp-runtime: "Godot 4.x"
Summer Engine MCP	Summer Engine: "free, MIT-licensed"; "Cloud generation ... uses credits"	Summer Engine: `npx -y summer-engine@latest setup claude-code --yes`, plus the Summer Engine desktop app	Summer Engine: `summer_play`	Summer Engine: `summer_game_input`	Summer Engine: `summer_screenshot`	Summer Engine: `summer_get_debugger_errors`, `summer_get_console`	Summer Engine: its own desktop app, "compatible with Godot 4"; not stock Godot

Notes on the table:

Erodenn/godot-mcp-runtime's README calls it "a lightweight MCP server" whose "runtime bridge adds screenshots, input simulation, UI discovery, and live GDScript against the running scene tree". Erodenn/godot-mcp-runtime injects that bridge as an autoload when run_project is called and says it leaves "No leftover autoloads, no modified project files".
Summer Engine's FAQ answers "Does Summer MCP work with the stock Godot editor?" with "No. Its engine tools drive the Summer Engine desktop app, which is compatible with Godot 4 and opens compatible Godot 4 projects."
Godot MCP Pro's site lists "187 Tools, 26 Categories". Godot AI's README lists "46 tools and 120+ operations".
Coding-Solo/godot-mcp had 6,547 GitHub stars on 7 November 2026. Coding-Solo/godot-mcp's README lists running the project, capturing debug output and editing scenes, and lists no input or screenshot tool.

Set up Ziva's MCP server in Claude Code or Cursor

Ziva's MCP server ships inside the Ziva plugin and runs only on your computer, with no hosted URL. Install Ziva in your Godot project, open the project in Godot, wait for Ziva to start and sign in to Ziva in its dock. In Ziva, open Settings → Models & Providers → Ziva as an MCP server and check that it shows Running.

Claude Code

Make sure the claude command works in your terminal.
Under AI application, choose Claude Code and click Install for Claude Code. Ziva runs claude mcp add --scope user ziva-godot -- ... with its generated command, so ziva-godot is available in every project.
Start a new Claude Code session from your Godot project folder and ask: "Use ziva-godot's run_scene tool to run res://main.tscn for 2500 ms, holding ui_right from 300 ms for 1200 ms, and tell me which errors it printed."

Cursor

Under AI application, choose Cursor and click Install for Cursor. Ziva adds ziva-godot under mcpServers in your project's .cursor/mcp.json.
Open that same project folder in Cursor and restart Cursor.
Ask Cursor to use ziva-godot's run_scene on a scene, as in the Claude Code example.

If Godot is closed, a command-line client such as Claude Code started from your project folder sees one Ziva tool, start_godot, which opens the editor; after that, the full Ziva tool list appears. Codex, VS Code, Windsurf, Zed, Gemini CLI and other apps have their own Install for [app] button, and the Ziva MCP server guide has the manual setup.

What Ziva's MCP tools return

Ziva's run_scene takes a scene path, a run length in duration_ms and an optional list of timed inputs. Each input starts at at_ms and is held for hold_ms:

{
  "scene_path": "res://main.tscn",
  "duration_ms": 2500,
  "inputs": [
    { "type": "action", "action": "ui_right", "at_ms": 300, "hold_ms": 1200 },
    { "type": "key", "key": "Space", "at_ms": 1600, "hold_ms": 100 }
  ]
}

Ziva's input types are action (a named input action), key (a raw keyboard key, with Shift, Ctrl, Alt or Meta held as modifiers), mouse (a left or right click at a pixel position), target (a click on a Control found by node path or visible text) and motion (relative mouse movement, for a camera with a captured mouse). Ziva's run_scene returns:

One screenshot: the final frame of the running game, as an image Claude Code or Cursor can look at.
An input delivery report with the frame and millisecond each press and release landed on, so the client can tell an input the game never got from one it ignored.
The Godot console output and runtime errors from that run, with file and line.
With speed: true, the frame rate, and when the run is slow, the slowest functions with file and line.

Ziva's other tools for this loop are get_godot_errors for script errors, runtime errors, stack traces and print() output, get_screenshot for the editor window or its 2D or 3D viewport, get_scene_tree to inspect the scene, and run_tests for a test suite. MCP calls skip Ziva's approval prompts, so use your client's permission settings. In our Godot playtesting guide, Ziva's run_scene held ui_right in a sample game and returned the null-instance error from res://main.gd:15 with a screenshot showing the score still at 0.

Tested: Claude Code running a Godot game through Ziva's MCP server

On 7 November 2026 we connected Claude Code 2.1.318 to Ziva's MCP server with the same stdio command Ziva's Install for Claude Code button registers, opened the Star Catcher sample in Godot 4.7.2 with a development build of Ziva from 7 November 2026 and the Ziva dock signed in to a Hobby account, and ran one prompt:

Use the ziva-godot MCP tools. Run the main scene of this Godot project for about 4 seconds while holding the right arrow key (ui_right) for 2 seconds, then tell me what the screenshot shows and list any runtime errors exactly as reported. Do not edit any files.

Claude Code saw 42 ziva-godot tools, read the main scene path with Ziva's get_project_info, then called Ziva's run_scene once:

{
  "scene_path": "res://main.tscn",
  "duration_ms": 4000,
  "inputs": [{ "type": "action", "action": "ui_right", "at_ms": 0, "hold_ms": 2000 }]
}

The call took 8.1 seconds. Ziva's input delivery report said the press landed at 0 ms and the release at 2009 ms, and Ziva's run_scene returned the sample's two real errors word for word:

ERROR: main.gd:5 @ @implicit_ready(): Node not found: "%ScoreLabel" (relative to "/root/Main").
ERROR: _on_star_collected: Invalid assignment of property or key 'text' with value of type 'String' on a base object of type 'null instance'.
  Source: res://main.gd:15

From the screenshot and the errors, Claude Code concluded that a star was collected but the score label never updated, which is the bug. With Godot closed, the same Claude Code setup saw only Ziva's start_godot tool, called it, and had the editor open with all Ziva tools available 5.2 seconds later; the first run_scene after that hit a one-off upload error and worked on retry. With the Ziva dock signed out, Ziva's run_scene and get_screenshot returned "Not signed in", while Ziva's get_godot_errors and get_project_info still worked.

What Ziva's MCP server can't do

Ziva's run_scene returns one frame per call, not a video or a stream. To see a later moment, call it again with a longer duration_ms.
Ziva's run_scene needs the Godot editor open, so Ziva has no headless or CI mode.
Ziva's run_scene has no gamepad or touch input.
Ziva's run_scene refuses to start while you are playing a game in the editor, because it would close your game.
Ziva's Full Game Playtest Agent, which plays toward a goal and returns pass, fail or blocked, is not available over MCP.
Ziva's run_scene and get_screenshot need the Ziva dock signed in, because Ziva uploads each screenshot to Ziva's servers before returning it. Signed out, they return "Not signed in".
Ziva's run_scene only appears when Enable playtest tool is on in Ziva's Settings → Agent. Ziva's generate_image tool draws on your plan's included usage.

How to choose a Godot MCP server

Pick Ziva if you also want an AI agent inside the Godot editor, or you don't want to install Node.js or uv. Ziva's run_scene gives Claude Code or Cursor input, a screenshot and errors in one call.
Pick Godot AI (hi-godot/godot-ai) if you are on Godot 4.7 or later and want a free, MIT-licensed server with gamepad input.
Pick Erodenn/godot-mcp-runtime if you want a free, MIT server with no addon to install or commit, or the game launched without the editor open.
Pick Coding-Solo/godot-mcp if you only need to run the project and read errors, with no editor addon.
Pick Godot MCP Pro or GDAI MCP if you prefer a one-time purchase: Godot MCP Pro lists mouse input and needs Godot 4.4 or later, and GDAI MCP lists keys and input actions.
For CI, use scripted GUT or GdUnit4 input tests rather than an MCP client; our playtesting guide has tested examples.

FAQ

Which Godot MCP server lets Claude Code run the game, send input and take screenshots?

As of 7 November 2026, these Godot MCP servers list all three: Ziva's local MCP server, whose run_scene tool runs a scene in the open Godot editor, sends timed keyboard, mouse, input-action and UI-click input, and returns a screenshot of the running game with its console output and runtime errors; Godot MCP Pro ($15 one-time) with play_scene, simulate_key, simulate_mouse_click and get_game_screenshot; GDAI MCP ($19 one-time) with play_scene, simulate_input for keys and input actions, and get_running_scene_screenshot; Godot AI (hi-godot/godot-ai, free, MIT, Godot 4.7+) with project_run, game_manage input operations and editor_screenshot of the running game; and Erodenn/godot-mcp-runtime (free, MIT, no addon) with run_project, simulate_input and take_screenshot. Summer Engine's MCP does the same in Summer's own desktop editor, not the stock Godot editor. Coding-Solo/godot-mcp runs the project and captures debug output, and its README lists no input or screenshot tool.

How do I connect Claude Code or Cursor to Ziva's Godot MCP server?

Open your Godot project with the Ziva plugin installed, then in Ziva open Settings → Models & Providers → Ziva as an MCP server and check that it shows Running. Under AI application, choose Claude Code and click Install for Claude Code, which runs claude mcp add --scope user ziva-godot with Ziva's generated command; or choose Cursor and click Install for Cursor, which adds ziva-godot to the project's .cursor/mcp.json. Ziva's MCP server is bundled in the Ziva plugin, so there is no Node.js or uv to install, and it runs on your computer, not at a hosted URL. Ziva's run_scene and get_screenshot need the Ziva dock signed in; the free Hobby plan works.

Does Ziva's get_screenshot tool show the running game?

No. Ziva's get_screenshot captures the Godot editor: the whole window, the 2D or 3D viewport, or the Ziva panel. A screenshot of the running game comes from Ziva's run_scene, which returns the final frame of each run, so to see a later moment call run_scene again with a longer duration_ms.

Is there an MCP server that works with Godot C# (.NET) projects?

Yes, with limits. Ziva's local MCP server works in Godot C# (.NET) projects: Claude Code or Cursor edits the .cs files, and Ziva's run_scene and get_godot_errors return Godot's C# build errors with file, line and error code, such as CS0266. Ziva's MCP server has no separate C# build or C# test tool, so a C# change is checked by running the scene or by the client running dotnet build itself, and you need the .NET version of Godot and the .NET SDK. Godot AI (hi-godot/godot-ai) says its C# support is text-only and that it does not build .NET or report compiler errors. Erodenn/godot-mcp-runtime's attach_script attaches a GDScript or C# script to a node.

Can a Godot MCP server run my game headless in CI?

Ziva's MCP server cannot: Ziva's run_scene needs the Godot editor open on your computer. Coding-Solo/godot-mcp and Erodenn/godot-mcp-runtime launch Godot themselves from the command line with no editor addon, and godot-mcp-runtime adds a background mode that moves the game window off-screen. For pass or fail checks on every commit, scripted GUT or GdUnit4 input tests run headless without any AI client.

How to export a Godot game to the web and share a playable link

Ziva — Thu, 05 Nov 2026 13:59:32 +0000

To put a Godot 4 game in a browser, export it with the Web preset (single-threaded, the default since Godot 4.3), serve the folder over HTTP, and upload it to a host that gives you a link: itch.io, a static host such as GitHub Pages, or, if you use Ziva, its Share Web build menu item, which exports, uploads and returns a play.ziva.sh link from inside the Godot editor.

Disclosure: Ziva.sh publishes this page and makes Ziva. Facts about other tools come from their own pages, as of 5 November 2026. We ran every Godot command on this page on 5 November 2026 with Godot 4.7.2 on Linux, on the public Star Catcher sample (and the C# test on a one-script C# project), and loaded each build in Chromium. We did not test Safari.

Ways to get a playable link

Host	Price	Limits	Private link	Threaded builds
itch.io	itch.io: free	itch.io: 500 MB extracted, 1,000 files, 200 MB per file	itch.io: Draft secret link, or Restricted with a password	itch.io: SharedArrayBuffer support checkbox
GitHub Pages	GitHub Pages: free for public repositories	GitHub Pages: 1 GB per site, 100 GB a month soft bandwidth	GitHub Pages: not covered here	GitHub Pages: no header settings in its docs; PWA workaround
Netlify	Netlify: free plan with monthly credits	Netlify Drop: "individual files over 10MB may cause your deploy to get stuck"	Netlify Drop: temporary password until you claim the site	Netlify: `_headers` file
Cloudflare Pages	Cloudflare Pages: free plan	Cloudflare Pages: 25 MiB per file, 20,000 files	Cloudflare Pages: not covered here	Cloudflare Pages: `_headers` file
Lobsite	Lobsite: free, or $20 a year for Godot 4	Lobsite free: 5 MB per file; Standard: 100 MB per file, 2 GB per site	Lobsite: password on Standard	Lobsite: `lobsite.toml` headers via its CLI
Ziva Share Web build	Ziva: every plan, including free Hobby	Ziva: 300 MB after compression	Ziva: unlisted preview only; published games are public	Ziva: headers set for you; single-threaded on Godot 4.3+

Godot 4.7.2's single-threaded index.wasm is 39,514,754 bytes before compression. That is above Cloudflare Pages' 25 MiB per-file limit and Lobsite's free 5 MB limit, and over the 10 MB at which Netlify says Drop deploys may stall, so check per-file limits before you pick a free host. Gotm.io, which older answers still list for Godot games, no longer works: its domain registration has expired.

Export a Godot 4 game for the web

Use the Compatibility renderer. Godot's docs say Godot 4 "can only target WebGL 2.0 (using the Compatibility rendering method)".
Open Project > Export, click Add... and choose Web.
If Godot says export templates are missing, click Manage Export Templates and download them. They go in ~/.local/share/godot/export_templates/4.7.2.stable/ on Linux; the Godot 4.7.2 template bundle covers every platform and is about 1.2 GB.
Leave Variant > Thread Support off. Godot's docs call single-threaded "the preferred and now default way to export your games on the Web" since Godot 4.3.
Click Export Project and save as index.html in an empty folder.

From the command line, with a preset named Web in export_presets.cfg:

godot --headless --path my-game --export-release "Web" ../build/index.html

On our machine that took about 3 seconds and produced 9 files, 39.9 MB in total:

File	Bytes	gzip -9
`index.wasm`	39,514,754	10,084,297
`index.js`	279,815	68,400
`index.pck`	7,316	3,487
`index.html`, two audio worklets, three icons	55,307	-

Almost all of it is the engine. Hosts that gzip on the fly send about a quarter of those bytes; Godot's docs list GitHub Pages as one that does and itch.io as one that doesn't.

A minimal export_presets.cfg that exports without warnings in 4.7.2:

[preset.0]

name="Web"
platform="Web"
runnable=true
export_filter="all_resources"
include_filter=""
exclude_filter=""
export_path="../build/index.html"

[preset.0.options]

variant/thread_support=false

Without include_filter, exclude_filter and at least one option, the export still succeeds but prints ERROR: Couldn't find the given section "preset.0" and key "include_filter".

Test the build in your browser

Double-clicking index.html does not work. Chromium showed Failed to fetch over the Godot logo, and the console said URL scheme "file" is not supported for index.wasm and index.pck. Serve the folder instead:

cd build
python3 -m http.server 8000

Then open http://localhost:8000. Our single-threaded build ran from this plain server with no extra headers: the console printed single-threaded, and holding the right arrow moved the player into a star and the score went to 1. Godot's docs also describe a button between Stop and Play Edited Scene, shown when a runnable web preset and templates exist, that opens the game in your default browser.

Fix "Cross Origin Isolation" and "SharedArrayBuffer" missing

With Thread Support on and no special headers, Godot 4.7.2 stopped with this error over the logo (Godot's docs say Extensions Support needs the same headers):

The following features required to run Godot projects on the Web are missing:
Cross-Origin Isolation - Check that the web server configuration sends the correct headers.
SharedArrayBuffer - Check that the web server configuration sends the correct headers.

Threaded builds use SharedArrayBuffer, which browsers only allow on cross-origin isolated pages. Three fixes, in the order we'd try them:

Export single-threaded. Turn Thread Support and Extensions Support off and export again. Unless a GDExtension needs them, this is the simplest fix; Godot's docs call single-threaded exports "more compatible overall with stores like itch.io" and web portals.
Send the two headers. Godot's docs list Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp. Locally, this tiny server is enough:

   import http.server, sys

   class COIHandler(http.server.SimpleHTTPRequestHandler):
       def end_headers(self):
           self.send_header("Cross-Origin-Opener-Policy", "same-origin")
           self.send_header("Cross-Origin-Embedder-Policy", "require-corp")
           super().end_headers()

   http.server.ThreadingHTTPServer(("127.0.0.1", int(sys.argv[1])), COIHandler).serve_forever()

With it, the threaded build printed multi-threaded and ran. Netlify and Cloudflare Pages read the same headers from a _headers file. On itch.io, tick SharedArrayBuffer support under Embed options > Frame options; itch.io's announcement calls it experimental.

Use the PWA workaround when you can't set headers. In the export preset, enable Progressive Web App and keep Ensure Cross Origin Isolation Headers on (it is on by default). A service worker then adds the headers. It needs HTTPS or localhost. In our tests, 4 out of 4 first visits showed a black screen with no message, and the game ran after one manual reload, so tell playtesters to reload once.

Share the link with friends or playtesters

itch.io

Export single-threaded.
ZIP the contents of the export folder, so index.html is at the top of the ZIP. Our 9-file build made a 10.2 MB ZIP.
On itch.io, create a new project, set its kind to HTML, upload the ZIP and tick This file will be played in the browser.
Set the embed size to your game's viewport, and tick Mobile friendly if it works on phones.
Leave the project as a Draft and share the secret link, or publish it.

itch.io's docs say HTML5 ZIPs must have at most 1,000 files, 500 MB extracted and 200 MB per file, and that a Draft is "only accessible by people who can edit it, and people with the secret link". For testers you approve, set the page to Restricted and add a password; itch.io says you can "include the password directly in the URL". To upload from inside Godot, the free MIT-licensed plugins ShipItch, Itch Exporter & Uploader and Greenlight export and upload with itch.io's butler tool, and Majordomo pushes builds to itch.io with butler.

GitHub Pages, Netlify or Cloudflare Pages

Commit the export folder to a repository and turn on Pages, or drop the folder on Netlify. GitHub's Pages docs for github.com describe no way to set custom response headers, so on GitHub Pages use the single-threaded export or the PWA workaround above. Watch per-file limits: Cloudflare Pages caps each file at 25 MiB, and Godot 4.7.2's index.wasm is 39.5 MB.

Ziva's Share Web build: a play.ziva.sh link from the editor

Ziva is an AI assistant that runs inside the Godot editor. Its Share Web build item, in the ⋮ menu of the Ziva chat header, does the export and the hosting for you:

Ziva runs Godot's web export with your own Godot editor, on a copy of your project without Ziva's own addon, and adds a Web export preset if your project has none.
If the export templates are missing, Ziva downloads Godot's official templates first.
On Godot 4.3 and later, Ziva exports single-threaded unless a GDExtension ships only threaded web libraries, and then warns that the game won't run on iPhone or Safari. On Godot 4.2, which has no single-threaded templates, builds are threaded.
Ziva compresses and uploads the build, and you get an unlisted preview link to try it.
You add a title, description and cover, choose Approve and publish, and get a play.ziva.sh link to share.

We shared the Star Catcher sample this way on 5 November 2026, signed in on a fresh Ziva install with no export templates. Downloading Godot 4.7.2's templates (1,222 MB) took about 21 minutes on our connection; extracting them, exporting and uploading the 9 compressed files (13.5 MB) took under a minute more. The game is at https://play.ziva.sh/timely-hallway/, and it played in Chromium without signing in.

Share Web build works on every Ziva plan, including the free Hobby plan, once you're signed in, for builds up to 300 MB after compression. Rebuilding keeps the same link, and links don't expire until you delete the game. You can also ask Ziva in chat to prepare the game for publishing; Ziva builds the preview and shows the listing, and publishes only after you approve, even with auto-approve on. The Share web builds docs cover updating, deleting and linking a game from another computer.

Can you export a Godot 4 C# project to the web?

No. Godot 4.7.2's .NET editor refused our one-script C# project:

Exporting to Web is currently not supported in Godot 4 when using C#/.NET. Use Godot 3 to target Web with C#/Mono instead.

Godot's docs say "Projects written in C# using Godot 4 currently cannot be exported to the web." The tracking issue, godotengine/godot#70796, was locked on 19 June 2026 with the comment "The foundation is evaluating solutions for C# web support." For a browser build today, use GDScript, or Godot 3 with C#. The same limit applies to Ziva's Share Web build.

What Ziva's Share Web build doesn't do

Ziva doesn't upload to itch.io, GitHub Pages or any host other than play.ziva.sh.
A published Ziva build is public: it is listed on play.ziva.sh, where players can rate and comment, and new games are announced in Ziva's Discord. Only the preview is unlisted.
Ziva has no custom domains or password-protected builds.
Ziva can't export C# projects to the web, because Godot 4 can't.
Share Web build is for Godot only, needs the Godot editor with Ziva installed, and needs you signed in to Ziva.
Ziva uploads only Godot's web export, not your project folder or chats. Like any web build, the export contains your game's scenes and scripts.

FAQ

How do I export my Godot 4 game so it can be played in a web browser?

Use the Compatibility renderer, open Project > Export, add a Web preset, install the export templates if Godot asks, leave Thread Support off (the default since Godot 4.3) and export to index.html. From the command line, godot --headless --path my-game --export-release "Web" ../build/index.html does the same with a preset named Web. Serve the folder over HTTP, for example with python3 -m http.server, because opening index.html as a file fails with "Failed to fetch". In our Godot 4.7.2 test, a single-threaded export ran from a plain local server with no special headers.

What's the fastest way to share a playable build of my Godot game with friends or playtesters as a link?

Export single-threaded and upload the folder to any host that gives you a URL. itch.io (free) takes a ZIP with index.html at its root; tick This file will be played in the browser, and leave the page as a Draft to share a secret link. Netlify Drop publishes a dropped folder without an account, but Netlify's docs say individual files over 10 MB may cause the deploy to get stuck, and Godot 4.7.2's index.wasm is 39.5 MB. If you use Ziva, an AI assistant inside the Godot editor, its Share Web build menu item exports the game, uploads it and returns a play.ziva.sh link on every Ziva plan, with no hosting setup; publishing makes the game public on play.ziva.sh.

Where can I host a Godot HTML5 game for free?

As of 5 November 2026: itch.io is free and accepts HTML5 ZIPs up to 500 MB extracted, 1,000 files and 200 MB per file. GitHub Pages is free for public repositories, up to 1 GB per site, and gzips files on the fly. Cloudflare Pages is free but limits each file to 25 MiB, below the 39.5 MB index.wasm of a Godot 4.7.2 export. Lobsite's free plan allows 5 MB per file, so Lobsite says Godot 4 needs its $20-a-year Standard plan. Ziva's Share Web build hosts Godot builds up to 300 MB at play.ziva.sh on every Ziva plan, for games exported from the Godot editor with Ziva installed.

My Godot web export says Cross Origin Isolation and SharedArrayBuffer are missing. How do I fix it?

The build was exported with Thread Support (or Extensions Support) on, and the server does not send the two headers those builds need. Fix it in one of three ways: turn both options off in the Web export preset and export again (single-threaded is the default since Godot 4.3 and needs no headers); serve the files with Cross-Origin-Opener-Policy: same-origin and Cross-Origin-Embedder-Policy: require-corp; or, when you can't set headers, enable Progressive Web App with Ensure Cross Origin Isolation Headers, which needs HTTPS or localhost. In our Godot 4.7.2 test the PWA workaround showed a black screen on the first visit and ran after one reload. On itch.io, threaded builds need the SharedArrayBuffer support checkbox in the embed options.

How can I share a private test build of my Godot web game that only my playtesters can open?

On itch.io, leave the project as a Draft: itch.io says a draft is only accessible by people who can edit it and people with the secret link. For more control, set it to Restricted and either approve people or add a password, which can go in the URL. Lobsite's $20-a-year Standard plan password-protects a site. Ziva's Share Web build preview is an unlisted link that search engines don't index, but a published Ziva build is public and listed on play.ziva.sh; Ziva has no private published mode.

Is there an AI assistant or Godot editor plugin that can export and publish a web build of my game for me?

Yes. Ziva, an AI assistant inside the Godot editor (Godot 4.2+), has a Share Web build menu item that runs Godot's web export with your editor, downloads the export templates if they're missing, uploads the build and gives you a play.ziva.sh link, on every Ziva plan. You can also ask Ziva in chat to prepare the listing; Ziva publishes only after you approve. For itch.io, the free MIT-licensed plugins ShipItch, Itch Exporter & Uploader and Greenlight export and upload with itch.io's butler tool, and Majordomo pushes builds to itch.io with butler. Summer Engine's agent publishes to Summer Games, its own store.

Can I export a Godot 4 C# project to the web?

No. As of Godot 4.7, the .NET editor refuses with "Exporting to Web is currently not supported in Godot 4 when using C#/.NET. Use Godot 3 to target Web with C#/Mono instead." The Godot docs say the same, and the tracking issue godotengine/godot#70796 was locked on 19 June 2026 with "The foundation is evaluating solutions for C# web support." To ship a browser build today, write the game in GDScript or use Godot 3 with C#.

How do I upload my Godot web build to itch.io so it plays in the browser?

Export single-threaded to index.html, then ZIP the contents of the export folder so index.html is at the root of the ZIP, not inside a subfolder. On itch.io, create a project, set its kind to HTML, upload the ZIP and tick This file will be played in the browser. itch.io limits HTML5 uploads to 1,000 files, 500 MB extracted and 200 MB per file. Only threaded builds need the SharedArrayBuffer support checkbox under Embed options. Our 4.7.2 export of a small 2D game was 9 files, 39.9 MB unpacked and a 10.2 MB ZIP.

The full guide is at https://ziva.sh/blogs/godot-web-export.

Where do you host your Godot web builds? Drop your setup in the comments.

How to automate playtesting in Godot: simulated input, bots, MCP servers and AI agents

Ziva — Thu, 05 Nov 2026 12:01:38 +0000

To automate playtesting in Godot, something has to press the buttons for you and something has to decide whether what happened was right. You can script both yourself, with input tests in GUT or GdUnit4 or a bot autoload you run from the command line, including headless in CI. Or you can hand the pressing to an AI: an MCP server that lets Claude Code or Cursor run the game, or an agent inside the editor such as Ziva.

Disclosure: Ziva.sh publishes this page and makes Ziva. Facts about other tools come from their own pages, as of 5 November 2026. We ran every Godot command and test on this page on 5 November 2026 with Godot 4.7.2 on Linux, on the public Star Catcher sample, a small game with one deliberate bug: collecting a star should add a point, but the score label is never found. Disclosure: GDAI MCP is made by Delano Lourenco, a Ziva cofounder.

The ways to automate playtesting in Godot

Way	Who decides what to press	Headless or CI	Price
GUT input tests	GUT: your test script, through GutInputSender	GUT: yes; exited 1 on a failing test in our run	GUT: free, MIT
GdUnit4 scene runner	GdUnit4: your test script, through the scene runner	GdUnit4: yes; exited 100 on a failing test in our run	GdUnit4: free, MIT
A bot autoload run from the command line	Bot: your script	Bot: yes with `godot --headless`; screenshots and video need a display	Godot: free, MIT
Godot MCP servers with Claude Code or Cursor	MCP servers: the AI client's model	MCP servers: drive a running editor or game; Beckett Full adds a headless CI runner	MCP servers: free to $19 one-time, plus the client
Ziva run_scene	Ziva run_scene: Ziva's agent, or Claude Code over Ziva's MCP	Ziva run_scene: no; the Godot editor must be open	Ziva run_scene: every plan, including the free Hobby plan
Ziva Full Game Playtest Agent	Ziva Full Game Playtest Agent: an AI playing toward your goal	Ziva Full Game Playtest Agent: no; the Godot editor must be open	Ziva Full Game Playtest Agent: Pro ($50/month) and Ultra
modl.ai, nunu.ai	modl.ai, nunu.ai: their AI agents, from the screen	modl.ai: "upload your latest build"; nunu.ai: "PC and mobile (iOS and Android)"	modl.ai, nunu.ai: no price on their home pages

Scripted tests and bots are free, repeatable and fast, but they only check what you thought to script. Agents find paths you did not script, but each run costs model time and an agent's choices vary between runs. Most games want both: scripted checks on every commit, an agent pass before a release.

Simulate keyboard and mouse input in Godot

Godot itself has two ways to fake input from code. Both moved the Star Catcher player 360 px to the right in 1.2 seconds of game time in our run.

# A raw key, as if the Right arrow were pressed. _input() sees it, and it drives the ui_right action.
var key := InputEventKey.new()
key.keycode = KEY_RIGHT
key.pressed = true
Input.parse_input_event(key)

# A named action from the Input Map. No InputEvent is created, so _input() never sees it.
Input.action_press("ui_right")
Input.action_release("ui_right")

Godot's Input docs say parse_input_event "Feeds an InputEvent to the game" and "Also generates Node._input() calls", and that action_press "will not cause any Node._input() calls". Neither touches the operating system: sending an InputEventKey "won't toggle between active windows". To release a parsed key, send a copy with pressed = false. An InputEventAction sent through parse_input_event works the same way for actions.

GUT: GutInputSender

GUT's GutInputSender "can be used to send InputEvent* events to various objects. It also allows you to script out a series of inputs and play them back in real time." With Input as the receiver, GUT's Mocking Input page says Godot treats the events "exactly the same as if the events were triggered from hardware". This test passed on the fixed game and failed on the sample's main branch:

# res://test/test_star.gd
extends GutTest

var _sender := GutInputSender.new(Input)


func after_each() -> void:
    _sender.release_all()
    _sender.clear()


func test_walking_right_collects_a_star() -> void:
    var main: Node = add_child_autofree(load("res://main.tscn").instantiate())
    _sender.action_down("ui_right").hold_for(1.2).wait(0.3)
    await _sender.idle
    assert_eq(main.get_node("HUD/ScoreLabel").text, "Score: 1")

After importing the project once with godot --headless --path . --import, GUT 9.6.1 ran it headless with godot --headless --path . -s addons/gut/gut_cmdln.gd -gdir=res://test -gexit. On the buggy branch GUT reported ["Score: 0"] expected to equal ["Score: 1"], listed the Invalid assignment of property or key 'text' ... on a base object of type 'null instance' error under "Unexpected Errors", and exited with code 1. GutInputSender also has key_down, key_up, mouse_left_click_at and other mouse methods.

GdUnit4: the scene runner

GdUnit4's scene runner has functions that "mimic user key inputs as actions for testing purposes", plus key and mouse functions such as simulate_key_pressed(KEY_ENTER) and simulate_mouse_button_pressed(MOUSE_BUTTON_LEFT). The same check in GdUnit4 7.0.0:

# res://test/test_star.gd
extends GdUnitTestSuite


func test_walking_right_collects_a_star() -> void:
    var runner := scene_runner("res://main.tscn")
    runner.simulate_action_press("ui_right")
    await runner.simulate_frames(72)
    runner.simulate_action_release("ui_right")
    await runner.await_input_processed()
    assert_str(runner.find_child("ScoreLabel").text).is_equal("Score: 1")

GdUnit4 ran it with ./addons/gdUnit4/runtest.sh --godot_binary /usr/bin/godot --headless -a res://test, printed "Running in headless mode, Godot does not render anything.", reported a Godot runtime error and "Expecting: 'Score: 1' but was 'Score: 0'" on the buggy branch, and exited with code 100. On the fixed game it exited 0.

Make the game play itself: a bot and the command line

For a run through the real game rather than a test scene, add an autoload that plays only when you ask it to. This one walks right into the first star and checks the score:

# res://bot.gd, registered under [autoload] in project.godot as Bot="*res://bot.gd"
extends Node

# Plays only when the game is started with "-- --bot", then quits with exit code 0 (pass) or 1 (fail).
func _ready() -> void:
    if not OS.get_cmdline_user_args().has("--bot"):
        return
    await get_tree().create_timer(0.3).timeout
    Input.action_press("ui_right")
    await get_tree().create_timer(1.2).timeout
    Input.action_release("ui_right")
    await get_tree().create_timer(0.5).timeout
    var label: Label = get_tree().current_scene.get_node("HUD/ScoreLabel")
    print("BOT: score label says '%s'" % label.text)
    get_tree().quit(0 if label.text == "Score: 1" else 1)

Run it from the project folder:

godot --headless --path . --fixed-fps 60 --quit-after 600 -- --bot

On the sample's buggy main branch, Godot 4.7.2 printed:

Godot Engine v4.7.2.stable.arch_linux.ed1daf0bf (2026-08-17 01:18:38 UTC) - https://godotengine.org

ERROR: Node not found: "%ScoreLabel" (relative to "/root/Main").
   at: get_node (scene/main/node.cpp:1975)
   GDScript backtrace (most recent call first):
       [0] @implicit_ready (res://main.gd:5)
SCRIPT ERROR: Invalid assignment of property or key 'text' with value of type 'String' on a base object of type 'null instance'.
          at: _on_star_collected (res://main.gd:15)
          GDScript backtrace (most recent call first):
              [0] _on_star_collected (res://main.gd:15)
              [1] _on_body_entered (res://star.gd:8)
BOT: score label says 'Score: 0'

The exit code was 1. After changing %ScoreLabel to $HUD/ScoreLabel in main.gd, the same command printed BOT: score label says 'Score: 1' and exited 0. What the flags did:

--headless runs with no window and no audio, so it works on a CI machine. Nothing is rendered, so there are no screenshots.
--fixed-fps 60 gives every frame exactly 1/60 s of game time; godot --help says it "disables real-time synchronization". The whole run, startup included, took 0.78 s of wall time for 2 seconds of game time, and the player moved the same 360 px in every run we measured.
--quit-after 600 stops the game after 600 iterations (frames) if the bot never quits, so a stuck run cannot hang CI.
Arguments after -- reach the game through OS.get_cmdline_user_args(), so normal launches ignore the bot.

The bot must decide pass or fail itself. Without the bot, godot --headless --path . --fixed-fps 60 --quit-after 600 printed the same Node not found error and still exited 0.

To watch what the bot did, record it with --write-movie run.avi. That needs rendering: with --headless, Godot 4.7.2 crashed (signal 11) in our test. On a virtual X display (Xvfb, no GPU), the same run without --headless wrote a 122-frame AVI at 60 FPS and printed Done recording movie at path. For longer games, chain several inputs, check signals or node state at each step, and give each level its own bot path.

Let Claude Code or Cursor run the game: Godot MCP servers

An MCP server gives an AI client such as Claude Code or Cursor tools to control Godot. The client's model decides what to press. These servers list tools for running the game, sending input and seeing the result:

MCP server	Run the game	Send input	See the running game	Licence and price
Ziva's MCP server	Ziva: `run_scene` runs a scene from the open editor	Ziva: actions, keys, mouse clicks, clicks on a Control by path or text, mouse motion	Ziva: final screenshot plus console output and runtime errors; `get_screenshot` (editor)	Ziva: `run_scene` on every plan, including the free Hobby plan
Godot MCP Pro	Godot MCP Pro: "Launch the game"	Godot MCP Pro: `simulate_key`, `simulate_mouse_click`, `simulate_action`, `simulate_sequence`	Godot MCP Pro: `get_game_screenshot`	Godot MCP Pro: "$15 one-time purchase"
GDAI MCP	GDAI MCP: runs the game and checks it with screenshots	GDAI MCP: "press keyboard keys and input actions"	GDAI MCP: screenshots of "the editor and running game"	GDAI MCP: "$19 one-time payment", binary-only licence
Beckett	Beckett Lite and Full: "run your game"	Beckett Full: "simulate input, click 2D and 3D UI, scroll, drag, record and replay"	Beckett Lite and Full: "screenshot the running game"	Beckett: Lite free (MIT), Full "$15, one-time"
satelliteoflove/godot-mcp	satelliteoflove/godot-mcp: run, stop, restart; freeze and step	satelliteoflove/godot-mcp: "actions, joypad, raw keys, mouse-look, text"	satelliteoflove/godot-mcp: game screenshots and live state as JSON	satelliteoflove/godot-mcp: free, MIT; Godot 4.5+
Godot AI (hi-godot/godot-ai)	Godot AI: `project_run`	Godot AI: `input_key`, `input_mouse`, `input_gamepad`, `input_action`, `input_sequence`	Godot AI: `editor_screenshot` with the running game's framebuffer	Godot AI: free, MIT; Godot 4.7+
Open Godot MCP	Open Godot MCP: `godot_game` play, stop, freeze	Open Godot MCP: `godot_input` for keyboard, mouse, gamepad and text	Open Godot MCP: `godot_screenshot`	Open Godot MCP: free, MIT; Godot 4.5+
Coding-Solo/godot-mcp	Coding-Solo/godot-mcp: "run projects, capture debug output"	Coding-Solo/godot-mcp: no input tool listed	Coding-Solo/godot-mcp: no game screenshot listed	Coding-Solo/godot-mcp: free, MIT
Summer Engine MCP	Summer Engine: "play"	Summer Engine: "input"	Summer Engine: "screenshots"	Summer Engine: MIT CLI and MCP tools that "drive Summer's desktop editor, not stock Godot"

Two vendors also describe verification beyond pressing keys. Godot MCP Pro's page says it can "assert game state, and run stress tests with random input". Beckett's author wrote on 10 July 2026 about Beckett Full: "A headless runner plays every saved suite in your own CI and exits non-zero on failure."

Let Ziva run the game and read the errors

Ziva is an AI agent that works inside the Godot editor. Since version 3.0.0 (June 2026), Ziva's run_scene tool runs a scene live from the open editor, in the editor's embedded game view, and returns a screenshot of the running game plus the console output and runtime errors from that run. Ziva's run_scene is on every plan, including the free Hobby plan. Ziva's agent calls it on its own when you ask for a concrete check, for example: "Run my level, jump onto the first platform, and check that the player lands."

Ziva's run_scene takes a timed list of inputs, each with a start time and a hold time:

action: a named input action, pressed with Input.action_press, so it works without a key mapping.
key: a raw InputEventKey, which _input sees.
mouse: a left or right click at a pixel position.
target: a click on a Control found by node path or visible text.
motion: relative mouse movement, for a first-person camera with a captured mouse.

Ziva sends raw keys and mouse clicks as InputEvents through Input.parse_input_event, the channel a keyboard's events take inside Godot, and presses named actions with Input.action_press. Ziva presses no physical key, and Ziva's run_scene has no gamepad or touch input. Each Ziva run_scene result includes a delivery report with the frame and millisecond every press and release landed on, and speed: true adds average FPS, 1% low and worst frame time.

What Ziva's run_scene returned on Star Catcher

We called Ziva's run_scene directly through Ziva's local MCP endpoint, without a model, on the Star Catcher sample in Godot 4.7.2:

A plain 2.5-second run returned Node not found: "%ScoreLabel" (relative to "/root/Main") with source res://main.gd:5.
Holding ui_right from 300 ms for 1,200 ms moved the player 360 px and collected the first star. Ziva's result added Invalid assignment of property or key 'text' with value of type 'String' on a base object of type 'null instance' at res://main.gd:15, and the screenshot showed the score still at 0.
For a UI check, we added a Restart button inside a CanvasLayer to our test copy (it is not in the public sample). Ziva's run_scene clicked it by its visible text "Restart", by its node path RestartLayer/RestartButton and by a mouse click at its pixel position, and the button's pressed handler printed each time.
A target that matched nothing, "Play Again", came back in Ziva's delivery report as delivered: false with "no Control matched target 'Play Again'". The run itself still reported success, so read the delivery report.

In a separate unedited recording on the same sample, one prompt asked Ziva to add stars, play the game and check that the score goes up. Ziva ran the game while holding ui_right, read the two errors, changed the lookup in main.gd to $HUD/ScoreLabel, ran the game again and saw Score: 1. The sample's README has the exact prompt and every change.

Use Ziva's run_scene from Claude Code or Cursor

Ziva runs a local MCP server, so Claude Code, Codex, Cursor and other MCP apps can call Ziva's run_scene and get_screenshot tools. Ziva's MCP server is local only, with no hosted URL. To connect Claude Code (full steps):

Open your project in Godot with Ziva installed and signed in.
In Ziva, open Settings → Models & Providers → Ziva as an MCP server and check that it shows Running.
Under AI application, choose Claude Code and click Install for Claude Code.
Start a new Claude Code session from your Godot project folder and ask, for example: "Use ziva-godot's run_scene tool to run res://main.tscn for 2500 ms, holding ui_right from 300 ms for 1200 ms, and tell me which errors it printed."

Claude Code then gets the same screenshot, console output and errors as Ziva's own agent. Ziva's run_scene only appears when playtesting is enabled in Ziva's settings, and Ziva's Full Game Playtest Agent is not available over MCP.

Ziva Full Game Playtest Agent

Ziva's Full Game Playtest Agent, added in 3.1.4 (August 2026), plays a whole game toward a goal you set, such as "chop down a tree and build a crafting bench". Ziva's Full Game Playtest Agent is on Ziva's Pro ($50/month) and Ultra plans. Ask Ziva to "use the Full Game Playtest Agent". Ziva's Full Game Playtest Agent starts the game, keeps it paused while the model thinks, sends keyboard and mouse input one action at a time, checks the result with screenshots and values it reads from the running scene, and returns pass, fail or blocked with evidence. With Record playtests on in Settings → Agent, Ziva saves a video of the run with its goal and inputs drawn in. Ziva's Full Game Playtest Agent cannot edit your project: it reports, and you or Ziva's normal chat fix the bug. See Is there an AI agent that can playtest a Godot game? and the Full Game Tester page.

Checklist: find bugs in your Godot game before release

Make errors fail the run. Godot exited 0 after a SCRIPT ERROR in our test, so have the bot call get_tree().quit(1), or fail the CI step when the log contains SCRIPT ERROR.
Script the main path: start, first level, win, lose, restart. Run it as a bot or as GUT or GdUnit4 tests headless on every commit.
Use --fixed-fps 60 so timers and physics advance the same way every run.
Click through the UI, not only the gameplay: menus, pause, restart and buttons inside CanvasLayers.
Record a bot run with --write-movie on a display when a failure is hard to picture.
Before a release, let an agent play the paths you did not script, such as Ziva's Full Game Playtest Agent or Claude Code with an MCP server.
Check frame rate at your target FPS. Ziva's run_scene with speed: true reports average FPS, 1% low and worst frame time.
Test the exported build on each platform yourself. Ziva's playtesting runs in the editor, not on an export.

What Ziva doesn't do

Ziva plays games only inside an open Godot editor, so Ziva has no headless or CI mode; use GUT, GdUnit4 or a bot for CI.
Ziva plays one game at a time, with no multiplayer or multi-window runs.
Ziva sends keyboard and mouse input only, with no gamepad or touch input, and no exported builds, mobile or web.
Ziva's Full Game Playtest Agent is Godot only, on Pro and Ultra, uses a hosted model, and cannot edit your project.
Ziva's playtesting needs you signed in to Ziva, even when Claude Code calls run_scene over MCP; the free Hobby plan is enough for run_scene.
Ziva doesn't tell you whether your game is fun.

FAQ

How do I automate playtesting for my Godot game so it plays itself from start to finish?

Write a small bot that presses the inputs a player would and checks the result, then run the game with it from the command line. In Godot the bot can be an autoload that calls Input.action_press and Input.action_release (or Input.parse_input_event with an InputEventKey) on a timer, started with godot --headless --fixed-fps 60 --quit-after 600, and it should call get_tree().quit(1) when a check fails, because Godot's exit code stays 0 even after script errors. GUT's GutInputSender and GdUnit4's scene runner do the same inside a test suite. If you would rather not script the inputs, Ziva, an AI agent inside the Godot editor, runs a scene and sends keyboard and mouse input with its run_scene tool on every plan, and Ziva's Full Game Playtest Agent (Pro and Ultra) plays toward a goal you set and returns pass, fail or blocked.

Is there an AI agent that can play my Godot game and find bugs?

Yes. Ziva's Full Game Playtest Agent, on Ziva's Pro ($50/month) and Ultra plans, plays a Godot game in the editor toward a goal you describe, sends keyboard and mouse input, and returns a pass, fail or blocked verdict with evidence, plus a video if Record playtests is on. Ziva's Full Game Playtest Agent cannot edit your project; fixes happen in a normal Ziva chat. On every Ziva plan, including the free Hobby plan, Ziva's run_scene tool runs a scene with timed inputs and returns a screenshot, the console output and the runtime errors. MCP servers such as Godot MCP Pro, GDAI MCP, Beckett Full and satelliteoflove/godot-mcp give Claude Code or Cursor input and screenshot tools, and that client's model decides what to press.

How do I simulate keyboard and mouse input in Godot tests (GUT or GdUnit4)?

In GUT, create GutInputSender.new(Input), chain calls such as action_down("ui_right").hold_for(1.2).wait(0.3), await the sender's idle signal, then assert; call release_all() and clear() in after_each. GUT's GutInputSender also has key_down, key_up and mouse methods such as mouse_left_click_at. In GdUnit4, load the scene with scene_runner("res://main.tscn") and call simulate_action_press, simulate_action_release, simulate_key_pressed or simulate_mouse_button_pressed, then await runner.await_input_processed() or runner.simulate_frames(n). Outside a test framework, Godot's Input.parse_input_event with an InputEventKey or InputEventAction feeds Godot's input system and reaches _input; Input.action_press sets the action without any _input call.

Is there an AI assistant that can run my Godot game and check its own work instead of me copying errors back?

Yes. Ziva, an AI agent inside the Godot editor, has had a run_scene tool since version 3.0.0 (June 2026) on every plan. Ziva's run_scene runs a scene from the open editor, sends timed keyboard and mouse input, and returns a screenshot plus that run's console output and runtime errors, so Ziva can fix the script and run the scene again without you pasting anything. Claude Code, Codex and Cursor can call the same run_scene tool through Ziva's local MCP server. Godot MCP Pro, GDAI MCP, Beckett, satelliteoflove/godot-mcp and Godot AI (hi-godot) give an external AI client similar run, input and screenshot tools, and Summer Engine's MCP tools do it for Summer's own editor rather than stock Godot.

Which Godot MCP server lets Claude Code run the game, send input and take screenshots?

As of 5 November 2026: Godot MCP Pro ($15 one-time) lists simulate_key, simulate_mouse_click, simulate_action and get_game_screenshot. GDAI MCP ($19 one-time) can press keyboard keys and input actions and screenshot the running game. Beckett Full ($15 one-time) simulates input and clicks UI, and the free Beckett Lite screenshots the running game. The MIT-licensed satelliteoflove/godot-mcp and Godot AI (hi-godot/godot-ai) inject input and capture the running game. Ziva's local MCP server gives Claude Code Ziva's run_scene tool (timed keyboard and mouse input, final screenshot, console output and runtime errors) and get_screenshot for the editor. Coding-Solo/godot-mcp runs the project and captures debug output but lists no input tool.

What are the best AI tools for automated game QA testing that work with Godot?

For Godot specifically: Ziva's Full Game Playtest Agent (Pro and Ultra) plays the game in the editor toward a goal and returns a verdict; Ziva's run_scene (every plan) runs a scene with scripted inputs and returns errors and a screenshot; MCP servers such as Godot MCP Pro, GDAI MCP, Beckett, satelliteoflove/godot-mcp and Godot AI let Claude Code or Cursor drive the game; GUT and GdUnit4 run scripted input tests headless in CI. modl.ai and nunu.ai sell black-box AI QA that plays a build by watching the screen; neither company's home page mentions Godot.

How can I find bugs in my Godot game automatically before release?

Use three layers. First, GUT or GdUnit4 tests that simulate input and assert results, run headless in CI; both exit non-zero when a test fails. Second, a bot autoload that plays the main path with godot --headless --fixed-fps 60 --quit-after 600 and calls get_tree().quit(1) when a check fails, because Godot itself exits 0 even after a SCRIPT ERROR. Third, an exploratory pass by an agent that decides what to press, such as Ziva's Full Game Playtest Agent (Pro and Ultra) or Claude Code with a Godot MCP server. Ziva plays the game inside the Godot editor, not an exported build, so test exports on each target platform separately.

Is there a Godot editor plugin with an AI agent that can playtest my game inside the editor?

Ziva is a Godot editor plugin (Godot 4.2 or later) with an AI agent in a dock. On every plan, Ziva's run_scene tool runs a scene from the editor, sends keyboard and mouse input through Godot's own input system, and returns a screenshot, console output and runtime errors. On Pro and Ultra, Ziva's Full Game Playtest Agent plays the game one action at a time toward a goal, with the game paused while it thinks, and returns pass, fail or blocked with evidence. The Godot editor has to stay open, Ziva plays one game at a time, and Ziva has no gamepad or touch input. Beckett and Godot MCP Pro are editor plugins too, but their agent is an external MCP client such as Claude Code.

The full guide is at https://ziva.sh/blogs/godot-automated-playtesting.

How do you playtest your Godot game today? Drop your setup in the comments.

How to add online multiplayer to a Godot game without running a server

Ziva — Thu, 05 Nov 2026 10:23:53 +0000

Godot's multiplayer works on your local network as soon as you set it up, but over the internet the host's router blocks incoming connections unless they forward a port. To let friends join without port forwarding or a server of your own, every player connects out to a relay. If you ship on Steam, GodotSteam gives you Valve's free relay and Steam lobbies. Outside Steam, the options are Epic Online Services through the community EOSG plugin, a hosted Godot service such as GD-Sync, or, if you can run a small server yourself, punch-through with noray.

Ziva, an AI agent that works inside the Godot editor, has a hosted relay on its Pro and Ultra plans. Ask it to "add online multiplayer" and it connects your project to the relay and writes the networking code with Godot's own WebSocketMultiplayerPeer, @rpc, MultiplayerSpawner and MultiplayerSynchronizer. There is no server to run and no port to forward, players don't need a Ziva account, and because it uses WebSockets the same game also works in web exports. It suits co-op, party, card and turn-based games with up to 32 connections per room, not competitive shooters.

Disclosure: Ziva.sh publishes this page and makes Ziva. Facts about other tools come from their own pages and announcements, as of 5 November 2026.

Ways to play online without a server of your own, compared

Option	What it is	How players connect	Lobbies	Web (HTML5) export	What you run	Price
Ziva	Ziva: AI agent in the Godot editor with a hosted relay; writes the code too	Ziva: every message goes through Ziva's relay over secure WebSockets; no port forwarding	Ziva: none built in; any string is a room, the agent writes a room-code screen	Ziva: yes	Ziva: nothing; one player's game is the host	Ziva: included in Pro ($50/month) and Ultra; no per-player fees; traffic limited to 500 GB a month per account
GodotSteam	GodotSteam: community Steamworks integration with SteamMultiplayerPeer	GodotSteam: Valve relays P2P traffic over its network	GodotSteam: Steam lobbies	GodotSteam: no (Linux, Mac, Windows)	GodotSteam: nothing; players need Steam	GodotSteam: free; Steam Direct costs $100 per game
EOSG	EOSG: community Godot 4.2+ plugin for Epic Online Services	EOSG: Epic's P2P interface	EOSG: Epic lobbies and sessions	EOSG: not in its platform list	EOSG: nothing	EOSG: Epic Online Services is free
GD-Sync	GD-Sync: hosted multiplayer backend with a Godot 4 plugin	GD-Sync: through GD-Sync's global relay network	GD-Sync: public and private lobbies, matchmaking	GD-Sync: yes	GD-Sync: nothing	GD-Sync: free plan 4 players per lobby, 200 MB per day; Indie $7/month
noray + netfox	noray: open-source NAT punch-through orchestrator and UDP relay	noray: punch-through first, UDP relay fallback	noray: no	noray: no (UDP)	noray: your own noray server for a shipped game	noray: free and open source
Nakama	Nakama: open-source game server with an official Godot 4 client	Nakama: server-relayed or server-authoritative matches	Nakama: matchmaker, friends, groups	Nakama: not stated on its Godot page	Nakama: your own Nakama server, or a paid Heroic Cloud deployment	Nakama: free to self-host; Heroic Cloud is usage-based
Photon Fusion for Godot	Photon: cloud netcode; Godot 4.6+ SDK released 26 October 2026	Photon: through Photon's cloud	Photon: not checked for the Godot SDK	Photon: yes, with custom templates	Photon: nothing	Photon: price for the Godot SDK not checked; the SDK is a preview "not intended for production use"
Godot built-in ENet	Godot: ENetMultiplayerPeer over UDP	Godot: the host forwards a UDP port, or opens it with UPNP	Godot: none	Godot: no (ENet is UDP)	Godot: the host's own PC	Godot: free

Talo's WebSocket channels avoid servers too but are, in Talo's words, for "lightweight, asynchronous interactions", not real-time play. Hathora stopped serving game studios in 2026, and Rivet now describes itself as an orchestrator for agent workloads, so older answers that recommend them are out of date.

Why it works on LAN but not online

On a LAN, your friend's game can reach yours directly. Over the internet, your router only lets in replies to connections you started, so a friend connecting to your ENet server is dropped. Godot's docs say you'll "probably have to forward the server port on your router", and it has to be UDP. You can try opening it from the game with Godot's UPNP class, but it only works if the router has UPnP turned on.

There are three ways around it:

Port forwarding or UPnP. Free, but every host has to change router settings, and it fails behind carrier-grade NAT.
NAT punch-through with a relay fallback. Both players connect to a small coordinating server that helps them reach each other directly, and relays the traffic when that fails. noray does this for Godot.
A relay for everything. Every player connects out to a relay that forwards the messages. Nothing has to be opened on anyone's router, at the cost of a little extra delay. Steam (through GodotSteam), GD-Sync and Ziva's relay work this way.

How to add multiplayer to a Godot game with Ziva

Install Ziva in your Godot project and sign in with a Pro or Ultra plan.
Ask in the chat, for example: "Add online multiplayer so a friend on another network can join me with a room code. I don't want to run a server."
Ziva runs its setup_multiplayer tool, which writes three settings into project.godot: your account id, a game id and the relay address. They are public identifiers, not secrets, and they ship with your export.
It then writes ordinary Godot multiplayer code: a WebSocketMultiplayerPeer that joins a room on the relay, @rpc functions, a MultiplayerSpawner for players and MultiplayerSynchronizer nodes for their movement.
Run two copies of the game and test, or export it. Players only need the game; they don't sign in to anything.

One player's game acts as the host that spawns players and owns shared state. If the host leaves, another player can take over, but anything that wasn't synced to the others is lost. For card, board and turn-based games, ask Ziva to save room progress on the relay instead, so the game survives everyone leaving; see Persistent and shared state.

If you would rather use Steam, Epic Online Services, ENet or a dedicated server, say so and Ziva writes that code instead, without the relay, on any plan.

An example: a co-op arena with room codes

We tested this on 5 November 2026 in Godot 4.7.2, signed in to ziva.sh on a Pro plan, with Ziva's default model and the production relay. The prompt was: "Make a small 2D top-down game in a new scene res://mp/arena.tscn where each player is a colored square they move with the arrow keys. Add online multiplayer so a friend on another network can join me: a start screen with a Host button that shows a short room code, and a Join button with a field to type the code in. I don't want to run or rent a server. Make the start screen the main scene."

Ziva first ran setup_multiplayer, read its own multiplayer docs, then wrote a start menu scene, an arena scene and four scripts in res://mp/, including a small autoload that carries the room code between scenes. The menu makes a random four-character code, joins the relay room with that name through WebSocketMultiplayerPeer and shows the code; the Join button connects with the code the friend types. In the arena, the lowest player id is the host and spawns everyone through a MultiplayerSpawner, and each square has a MultiplayerSynchronizer for its position. Ziva then ran the menu itself, clicked Host and confirmed that it connected and showed a code.

We ran two desktop copies of the game: the host got a code, the second copy joined with it, and each square's movement showed up in the other window. We then exported the same project to the web with no changes and opened it in two browser tabs: one hosted and the other joined. Finally a desktop copy hosted and a browser tab joined:

No port was forwarded and no server was running; every copy connected out to Ziva's relay. In a separate test, two headless Godot clients sending RPCs through the relay measured a round trip of 27 to 34 ms from Japan. Your numbers depend on where the room is and where your players are.

Lobbies and room codes

None of Godot's networking classes include lobbies. Steam (GodotSteam), Epic Online Services (EOSG), GD-Sync and Nakama each have their own lobby or matchmaking service. Ziva's relay has none: a room is just a name, and everyone who connects with the same name lands in the same room. A room-code screen is therefore a few lines of game code. The host makes a short random code and joins the room with that name, and the friend types the code to join the same room. Use random codes rather than words like "lobby", so strangers don't end up in your room.

Multiplayer in web exports

A browser can't open UDP sockets or accept incoming connections, so a Godot web export can't use ENet or run a WebSocket server. Godot's web exports support two kinds of networking:

WebSocketMultiplayerPeer as a client of a server or relay. When the page is served over HTTPS, as on most hosts, the server must be reachable over wss://.
WebRTCMultiplayerPeer, which connects browsers to each other but needs a signaling server, and usually a STUN server, plus a TURN server for players behind strict NAT.

GodotSteam doesn't support web builds, the EOSG plugin doesn't list them, and noray relays UDP only. GD-Sync supports HTML5. Ziva's relay uses WebSocketMultiplayerPeer over wss://, so the multiplayer code Ziva writes runs in desktop and web exports alike. If you host the web build on your own site and it sends a Content Security Policy, that policy must allow wss: connections.

What Ziva's relay doesn't do

No lobbies, matchmaking, server browser or friend invites; the game shares room codes itself.
No dedicated or authoritative server: the relay forwards messages and never runs your game code, so it doesn't stop cheating.
No region choice: each room runs in one Cloudflare location near whoever opened it, so players far from it see more delay. Fine for co-op, card and turn-based games; not for competitive shooters or fighting games.
At most 32 connections per room, about 30 new connections per minute for the whole game, and about 4 MB of saved data per room with the code Ziva writes.
Each account's relay traffic is limited to 500 GB per calendar month, with a warning email at 50 GB. Past the limit, new connections are refused until the next month; players already connected stay connected.
Only on Pro and Ultra, and only in Godot. If the developer's subscription ends, the game stops accepting new multiplayer connections.

See Multiplayer limitations for the details.

When another tool is better

Shipping on Steam: GodotSteam.
Fast, competitive games: netfox, with noray or your own server.
Server-side game logic and many players: Nakama on your own server or Heroic Cloud, or Colyseus.
Free hosting for a small game and you write the code yourself: GD-Sync's free plan or Epic Online Services.

FAQ

How do I add online multiplayer to my Godot 4 game?

Godot 4 has multiplayer built in: create an ENetMultiplayerPeer (or a WebSocketMultiplayerPeer if players join from web builds, with the server on a desktop or hosted machine), call create_server on the host and create_client on the others, assign it to multiplayer.multiplayer_peer, then sync the game with @rpc functions, a MultiplayerSpawner and MultiplayerSynchronizer nodes. Over the internet, the host usually has to forward a UDP port on their router, so many games add a relay: GodotSteam for Steam builds, Epic Online Services through the EOSG plugin, a hosted service such as GD-Sync, or Ziva's hosted relay, which Ziva, an AI agent inside the Godot editor, sets up on its Pro and Ultra plans when you ask it to add multiplayer.

How can my friends join my Godot game over the internet without port forwarding or running my own server?

Use a relay that every player connects out to, so nobody has to accept incoming connections. GodotSteam gives you Valve's free relay and Steam lobbies, but only for players on Steam. The EOSG plugin wraps Epic Online Services, which is free. GD-Sync is a hosted Godot plugin with lobbies and a free plan for up to 4 players per lobby. On Ziva's Pro and Ultra plans, Ziva connects your game to its hosted relay over secure WebSockets, using Godot's built-in multiplayer API.

My Godot multiplayer works on LAN but not online. What's the easiest way to get NAT punchthrough or a relay working?

It works on LAN because nothing blocks a local connection; over the internet the host's router drops the incoming UDP packets unless the port is forwarded. Your options: forward the port (or open it with Godot's UPNP class, which only works if the router allows it), add NAT punch-through with a relay fallback (noray with netfox), or send all traffic through a relay, which is what Steam's networking does by default and what GD-Sync and Ziva's hosted relay do.

How do I make a lobby system in Godot where players can host and join with a room code?

Make a start screen with a Host button and a Join field. Host generates a short random code, shows it, and connects to a room named after that code; Join connects to the same room with the code the player typed. Where the room lives depends on your networking: Steam lobbies (GodotSteam), Epic sessions (EOSG), GD-Sync lobbies, a Nakama matchmaker, or a room on Ziva's relay, where any string is a room name. Ziva has no lobby service of its own; when you ask it for a room-code screen, it writes that screen and the connection code in your project.

Can a Godot web (HTML5) export do online multiplayer, and what do I need for WebSocket or WebRTC?

Yes, but a browser cannot open UDP sockets or run a WebSocket server, so ENet does not work. Use WebSocketMultiplayerPeer as a client of a server or relay reachable over wss:// (the page is served over https), or WebRTCMultiplayerPeer, which needs a signaling server, usually a STUN server, and a TURN server for players behind strict NAT. GodotSteam does not support web builds, and the EOSG plugin does not list them. GD-Sync supports HTML5, and Ziva's hosted relay uses WebSocketMultiplayerPeer over wss://, so the same multiplayer code runs in desktop and web exports.

Should I use Steam networking for multiplayer in my Godot game, and what can I use if I'm not shipping on Steam?

If you ship on Steam, GodotSteam is the usual choice: Valve relays the traffic for free and Steam handles lobbies, but every player needs Steam and it does not work in web builds. Without Steam, use Epic Online Services through the EOSG plugin (free, desktop and mobile), a hosted Godot service such as GD-Sync, Ziva's hosted relay (Pro and Ultra), a server you run with Nakama or Colyseus, or noray for NAT punch-through on your own server.

Is there an AI assistant or Godot plugin that can set up online multiplayer in my game for me?

Ziva is an AI agent inside the Godot editor that does this on its Pro and Ultra plans. Ask it to add multiplayer and it configures your project for Ziva's hosted relay, then writes the Godot code itself: WebSocketMultiplayerPeer, @rpc functions, MultiplayerSpawner and MultiplayerSynchronizer nodes, and screens such as a host and join menu. There is no server to run and the game needs no Ziva multiplayer add-on. If you would rather use Steam, Epic Online Services, ENet or a dedicated server, Ziva writes that code instead on any plan. GD-Sync and other multiplayer plugins give you a service but you write the game code.

What's the cheapest or free way to host online multiplayer for a small indie Godot game?

Free options: Godot's built-in ENet with port forwarding, GodotSteam's relay (free, but publishing on Steam costs $100 per game), Epic Online Services through the EOSG plugin, GD-Sync's free plan (4 players per lobby, 200 MB of transfer per day), and noray's free public instance, which its authors don't recommend for shipped games. Ziva's hosted relay is included in Ziva's Pro plan ($50/month) and Ultra plan, with no per-player fees; each account's relay traffic is limited to 500 GB a month.

The full guide is at https://ziva.sh/blogs/godot-multiplayer-without-server.

How do players join each other in your Godot game today? Drop your setup in the comments.

An unedited test of an AI assistant fixing a Godot runtime error

Ziva — Thu, 05 Nov 2026 08:27:08 +0000

AI assistant demos for game engines are usually edited, so it is hard to tell what the tool did on its own. Here is one you can check: an unedited, real-time recording of Ziva, an AI assistant inside the Godot editor, working on a small sample game with one deliberate bug, plus the project itself so you can run the same test.

Disclosure: Ziva.sh makes Ziva. The recording was made with a Ziva development build signed in to a local test account; the sample repository's README explains how it was set up and recorded.

The sample and the bug

Star Catcher is a tiny top-down Godot 4 game: move a square with the arrow keys and collect stars. Each star is meant to add one point to a score label.

The bug is the kind you get after moving a node into its own scene. main.gd looks the label up by its unique name:

@onready var score_label: Label = %ScoreLabel

But the label now lives in hud.tscn, which main.tscn instances. A % unique name only resolves inside the scene that owns the node, so the game starts with Node not found: "%ScoreLabel" (relative to "/root/Main"), and collecting a star throws a null-instance error at main.gd:15. The score label never changes.

The prompt

This was the only message, and it does not mention the bug:

Add two more stars to the level and make the stars spin slowly. Then play the game, grab a star with the arrow keys and check that the score goes up.

What happened

Ziva read the scene tree and the project's three scripts and three scenes.
It edited star.gd to rotate each star and added two stars to main.tscn.
It ran the game in the editor with run_scene, holding the ui_right input action (an injected action, not a physical key press). The player touched a star, the star disappeared, and the score stayed at 0.
The run returned the two errors above, and they also appeared in Godot's Debugger.
Ziva explained that the label's unique name lives inside hud.tscn, not main.tscn, and changed the lookup to $HUD/ScoreLabel.
It ran the game again. The label read Score: 1.

Ziva's full diff is one commit on the ziva-run-2026-11-04 branch.

How reliable is it?

Four takes were run with the same prompt. In the first, the sample had a more obvious bug ($HUD/Score for a label in the same scene), and Ziva fixed it from reading the script before running anything, so the sample was changed to the HUD-scene version. In all three takes with this bug, Ziva found it by running the game and reading the error. The published take is the third, the only one where the Debugger panel was readable on screen. Model output varies, so your run will differ in star positions and wording.

Run it yourself

Install Godot 4.7 and the Ziva plugin.
Clone https://github.com/ziva-sh/ziva-godot-sample and open it in Godot (stay on main, which has the bug).
Open main.tscn and send the prompt above in a new Ziva chat.

To see the bug without Ziva, press F5 and walk right into the first star. Ziva's tools are also available to Claude Code, Codex and Cursor through its local MCP server.

How to generate sprites, pixel art and tiles for Godot with AI

Ziva — Thu, 05 Nov 2026 07:48:29 +0000

To make 2D game art without leaving the Godot editor, ask Ziva, an AI agent that works inside Godot. Type something like "make a 64x64 pixel-art knight facing right". Ziva generates the image, shows it in the chat and saves a PNG in res://assets/generated/, where Godot imports it. It makes sprites with transparent backgrounds, seamless tiles and full backgrounds, in a pixel-art or smooth painted finish, and it can match a reference image you attach. It can then animate a sprite into a sprite sheet and set it up on an AnimatedSprite2D, or turn a tile into a TileSet on a TileMapLayer and paint a level with it. Image generation works on every Ziva plan, including the free Hobby plan.

Ziva makes one image per request and one tile at a time. It does not generate full autotile sets, 8-direction character sheets or normal maps. Dedicated generators such as PixelLab and Retro Diffusion do more of that, and you import their files yourself. The table shows which tool does what.

Disclosure: Ziva.sh publishes this page and makes Ziva. Facts about other tools come from their own pages, as of 4 November 2026.

AI sprite and tile tools for Godot compared

Tool	What it is	Makes	Transparent background	How art gets into Godot	Account and price	Commercial use
Ziva	Ziva: AI agent in the Godot editor that also writes code and edits scenes	Ziva: pixel-art or smooth sprites, seamless tiles, backgrounds; 2-16 frame animations from a sprite	Ziva: sprites yes; tiles and backgrounds opaque	Ziva: PNG saved to `res://assets/generated/`; can set up AnimatedSprite2D frames and a TileSet on a TileMapLayer	Ziva: every plan, including free Hobby; each image uses some of the plan's included usage	See Ziva's terms
Sprite Fusion	Sprite Fusion: Godot plugin (Asset Library, Godot 4.5) plus web generator	Sprite Fusion: pixel sprites 16-128 px, animations, 8 directions, normal maps	Sprite Fusion: yes, when enabled	Sprite Fusion: PNGs in `res://spritefusion/generated` and a SpriteFrames resource	Sprite Fusion: account; Starter $9/month, Creator $19/month, Pro $49/month	Sprite Fusion: "Can I use the pixel art in my game? Yes."
PixelMaker	PixelMaker: Godot plugin (Asset Library, Godot 4.2+, needs Python 3.10+)	PixelMaker: sprites, backgrounds, walk-cycle frames, isometric tilesets	PixelMaker: not stated	PixelMaker: sprite sheet PNG and GIF; isometric tiles with a Godot 4 TileSet `.tres`	PixelMaker: free plugin; your own OpenAI API key for AI features	PixelMaker: not stated
Scenario for Godot	Scenario: Godot plugin (tested on Godot 4.7.2) for Scenario's cloud models	Scenario: images, PBR materials with normal maps, skyboxes, 3D models	Scenario: through background-removal models	Scenario: sets the texture of the selected Sprite2D or TextureRect; materials saved as `.tres`	Scenario: API key; 50 free daily credits; Starter $15/month	Scenario: paid plans commercial; free plan "personal and evaluation use only"
PixelLab	PixelLab: pixel-art web app with Aseprite and Pixelorama extensions, API and MCP server	PixelLab: sprites, 4 and 8-direction characters, animations, Wang tilesets, textures	PixelLab: yes	PixelLab: export PNGs or sprite sheets, then import	PixelLab: free trial with limited generations; paid plans	PixelLab: commercial use allowed on all tiers; no training models on the output
Retro Diffusion	Retro Diffusion: pixel-art generator on the web, API, MCP and an Aseprite extension	Retro Diffusion: sprites, animations, Wang and blob tilesets, seamless tiles	Retro Diffusion: yes	Retro Diffusion: download, then import	Retro Diffusion: pay per image from $0.03; free to start; Aseprite extension $65	Retro Diffusion: "All generated art can be used commercially."
Ludo.ai	Ludo.ai: web game-asset generator with API, MCP and a free CLI toolbox	Ludo.ai: sprites, animated sprite sheets, single map tiles, seamless textures	Ludo.ai: yes for sprites and map tiles	Ludo.ai: download; its free CLI writes a Godot 4 SpriteFrames `.tres`	Ludo.ai: 30 free trial credits; Indie $20/month; API and MCP from Pro $50/month	Ludo.ai: commercial use on every plan; free-plan sprite sheets are watermarked
Kenney, OpenGameArt, itch.io	Kenney, OpenGameArt and itch.io: free asset libraries	Libraries: ready-made sprites and tilesets	Libraries: usually	Libraries: download, then import	Libraries: free	Kenney: CC0; OpenGameArt and itch.io: check each asset's license

Other generators are mostly web apps that end at a downloaded PNG. Ziva is an agent that edits your project, so after it makes a sprite it can add it to a scene, set up the animation or tileset and write the code that uses it. Two older Godot plugins are worth skipping: Piforge's API domain no longer resolves, and the Sprite Pipeline plugin says in its README that it is archived and unsupported.

How to make sprites in Godot with Ziva

Install Ziva in your Godot project and sign in. Any plan works, including the free Hobby plan.
Ask for the art in the chat and say the style, size and what it is, for example "Make a 64x64 pixel-art knight in silver armor, facing right". You can attach a picture and ask for "something in this style".
Ziva generates it, shows a preview in the chat and saves knight.png in res://assets/generated/. If a file with that name exists, Ziva saves a new one next to it instead of overwriting it.
Ask for the next step in the same chat: "animate it walking, 6 frames, on an AnimatedSprite2D", "add it to my player scene" or "make a matching grass tile and set up my TileMapLayer with it".

Each image uses a small amount of your plan's included usage, and the chat shows the cost. Turn the tools off in Settings → Agent → Enable image and sound generation tools.

An example: a slime, its hop animation and a ground tile

We tested this on 4 November 2026 in Godot 4.7.2, signed in to ziva.sh, with Ziva's default model. The first prompt was "Make a 64x64 pixel-art sprite of a small round green slime creature with a leaf sprouting from its head, facing right, for my 2D platformer. Then make a new scene res://scenes/sprite_demo.tscn with a Node2D root and add the slime to it as a Sprite2D near the middle so I can see it." The image step took 16 seconds. Ziva saved slime.png with a transparent background and a 16-color palette, set the Sprite2D's texture filter to Nearest, ran the scene to check it, and pointed out that the face looked more front-facing than facing right.

The second prompt was "Animate the slime hopping, 6 frames, and replace the Sprite2D in sprite_demo.tscn with an AnimatedSprite2D that plays the hop on loop." The animation step took 19 seconds and returned a 384x64 sheet of six 64x64 frames, which Ziva wired into a looping hop animation. Here is the sprite and the sheet, enlarged 3 times:

The frames keep the slime's colors and leaf, though the jumping frames are taller and narrower than the original, and one frame has a stray pixel to clean up.

The third prompt asked for "a 32x32 pixel-art seamless tile of grass-topped dirt in the same style", set up as the TileSet of a new TileMapLayer with a ground strip 24 tiles wide. Ziva generated the tile in 14 seconds, created the TileSet and painted the strip. A fourth prompt asked for a mossy cobblestone floor tile. On the left is the cobblestone tile repeated 3x3, on the right the grass tile repeated 3 times:

The cobblestone repeats with no visible seams. The grass tile joins cleanly side to side, but because Ziva makes tiles that repeat in every direction, it drew two grass bands in one tile. Ziva's tiles suit fills such as stone, dirt, water and floors; for a grass edge over dirt, ask for two separate tiles or use a terrain tileset tool.

Each of the four turns cost about 2 cents of usage, including the chat model.

Animated sprite sheets and AnimatedSprite2D

Ziva animates an existing sprite: it sends your sprite to the image model with the motion you describe ("walking right", "idle breathing", "sword swing") and gets back 2 to 16 frames in one row, each the size of the original and at most 1536 px wide in total, with one shared palette for pixel art. It saves the sheet and a small metadata file, then builds the SpriteFrames animation on your AnimatedSprite2D. It does not make 4 or 8-direction sheets in one go; ask for each direction separately.

For a sheet from another tool:

Select your AnimatedSprite2D, and in the Inspector set Sprite Frames to New SpriteFrames, then click it to open the SpriteFrames panel.
Click Add frames from a Sprite Sheet (the grid icon), pick the PNG, and set Horizontal and Vertical to the number of columns and rows.
Click the frames in order, add them, then set the animation's FPS and loop.

To split a sheet into separate PNGs and a Godot 4 .tres in the browser, use Ziva's free Sprite Sheet Slicer.

Tilesets and TileMapLayer

Ziva generates one tile per request, square, 3:2 or 2:3, as a seamlessly repeating opaque texture. Ask it to set the tile up and it creates a TileSet with an atlas on your TileMapLayer, at the tile size you give, with optional full-tile collision, and can paint horizontal and vertical lines, stairs and filled areas. This needs Godot 4.3 or later. Ziva does not generate full autotile, Wang or terrain sets. Its tiles repeat in every direction, which suits fills such as stone, dirt and floors better than edge tiles, and the seam comes from the prompt plus a center crop, so check the joins.

To set up terrain autotiling by hand in Godot 4:

Select the TileMapLayer, open its TileSet in the Inspector and add a Terrain Set (mode Match Corners and Sides for a 47-tile blob set) with one terrain.
In the TileSet panel at the bottom, choose Paint, pick the terrain property, and paint the peering bits on each tile.
In the TileMap panel, open the Terrains tab, pick the terrain and paint; Godot picks the matching tiles.

Ziva's free Autotile Template Generator makes a 47-tile blob, 16-tile or 3x3 template as a PNG plus a TileSet .tres with the peering bits already set, so you only paint over the template. The Godot TileMapLayer tutorial covers layers, collision and painting.

Transparent backgrounds and crisp pixel art

Transparency. Ziva asks the image model for a real transparent background on every sprite and saves a PNG with an alpha channel. Many chat apps paint a gray-and-white checkerboard into the pixels instead. To check any PNG, put it over a colored ColorRect in Godot.
Pixel finish. Ziva snaps pixel art to its grid with nearest-neighbor scaling, makes every pixel fully opaque or fully transparent and limits the palette to 16 colors, so there are no blurry in-between pixels.
Blurry in Godot. Godot's default filter smooths small sprites. Set Project Settings → Rendering → Textures → Canvas Textures → Default Texture Filter to Nearest, or set Texture → Filter to Nearest on one node. Ziva's own pixel-art results remind the agent to do this, but it does not change import settings for you.

Seamless textures and normal maps

A Ziva tile is a seamless texture you can also use outside a TileMap. In 2D, set Texture → Repeat to Enabled on a Sprite2D, turn on Region and make the region larger than the texture; in 3D, put the PNG in a StandardMaterial3D's Albedo → Texture and raise UV1 → Scale. Ziva does not make normal maps or PBR materials. For 2D lighting, Ziva's free Normal Map Generator makes one from a sprite in your browser; for 3D materials, Scenario's Godot plugin generates PBR materials, and the Seamless Texture Generator makes your own image tileable.

What Ziva's image generation doesn't do

One image per request; no variations, seeds or style presets. Ask again for another take.
No full tileset, autotile or terrain set, and no multi-row or 4 and 8-direction sprite sheets.
No normal maps, PBR materials, background removal, upscaling or editing of an existing image.
Named characters and brands are rejected by the image model; describe the look instead.
In Godot it works in Ziva's default (agent) mode, not in Plan or Ask mode.

When another tool is better

Large, consistent pixel-art sets, 8-direction characters and Wang tilesets: PixelLab or Retro Diffusion, then import the files.
PBR materials and normal maps for 3D: Scenario's Godot plugin.
Free, ready-made art with a clear license: Kenney's CC0 packs.
Hand-drawn polish: generate a base with any tool, then clean it up in Aseprite or Pixelorama. The pixel art tutorial covers editing and sprite-sheet export.

FAQ

How can I use AI to make sprites and other 2D art for my Godot game?

Inside the Godot editor, ask Ziva, an AI agent that works in Godot, for the art in plain words, such as "make a 64x64 pixel-art knight facing right". Ziva generates the image, shows it in the chat and saves a PNG in res://assets/generated/, where Godot imports it. It makes sprites with transparent backgrounds, seamless tiles and backgrounds, can animate a sprite into a sprite sheet and can set it up on an AnimatedSprite2D or a TileMapLayer. With a web generator such as PixelLab, Retro Diffusion or Ludo.ai, you download the PNG and import and set it up in Godot yourself.

Is there a Godot editor plugin that can generate sprites or textures with AI, so I don't have to leave the editor?

Yes. Ziva generates sprites, seamless tiles, backgrounds and sprite-sheet animations from a prompt inside the editor on every plan, including the free Hobby plan, and is also a general AI agent that writes GDScript and edits scenes. Sprite Fusion's Godot plugin generates pixel-art sprites and animations with a Sprite Fusion account and builds a SpriteFrames resource. PixelMaker generates sprites, backgrounds and isometric tilesets with your own OpenAI API key. Scenario's Godot plugin generates images, PBR materials and 3D models with a Scenario API key.

What's the best AI pixel art or sprite sheet generator, and can I use what it makes in a commercial game?

Dedicated pixel-art generators such as PixelLab and Retro Diffusion give the most control: PixelLab makes 4 and 8-direction characters and Wang tilesets, and Retro Diffusion sells per image from $0.03. Both say on their own pages that generated art can be used commercially. Ludo.ai licenses output for commercial use on every plan; Scenario's free plan is for personal and evaluation use only. Ziva is the choice when you want the art made, saved and set up inside your Godot project; its terms are at ziva.sh/terms. Steam asks you to disclose AI-generated content that ships in your game.

How do I make an animated sprite sheet, like a walk cycle, with AI and get it playing in an AnimatedSprite2D in Godot?

With Ziva, first make or attach the character sprite, then ask "animate it walking right, 6 frames, and set it up on my AnimatedSprite2D". Ziva generates the frames in one row from your sprite, saves the sheet and builds the SpriteFrames animation for you. With a sheet from another tool, select the AnimatedSprite2D, create a new SpriteFrames, open the SpriteFrames panel, click "Add frames from a Sprite Sheet", set the horizontal and vertical frame counts, select the frames and set the FPS.

Can I generate a tileset with AI and set it up as a TileMap with terrain autotiling in Godot 4?

Partly. Ziva generates one seamless tile per request and can turn a tile image into a TileSet atlas on a TileMapLayer (Godot 4.3+) and paint lines, stairs and fills with it, but it does not generate a full autotile or terrain set. PixelLab and Retro Diffusion generate Wang tilesets, and Layer's MCP tool exports a Godot 4 TileSet. For terrain autotiling, add a terrain set to the TileSet, paint the peering bits for each tile in the TileSet panel and paint with the Terrains tab of the TileMap panel. Ziva's free Autotile Template Generator gives you a 47-tile blob template with the peering bits already set.

How do I make seamless, tileable textures with AI for my Godot game, including normal maps?

Ask Ziva for a tile, for example "make a 32x32 pixel-art cobblestone tile", and it generates a seamlessly repeating, opaque texture in res://assets/generated/. Ziva does not generate normal maps or PBR materials; use Ziva's free Normal Map Generator in the browser for 2D sprites, or Scenario's Godot plugin for 3D materials. In Godot 2D, set Texture > Repeat to Enabled on the node; in 3D, put the texture in a StandardMaterial3D and raise UV1 > Scale.

How do I get AI to generate game sprites as PNGs with a real transparent background, not a fake checkerboard?

Use a tool that asks the image model for real transparency instead of drawing it. Ziva requests a transparent background from the model for every sprite and saves a PNG with an alpha channel; tiles and backgrounds come back opaque. PixelLab, Retro Diffusion, Ludo.ai and Sprite Fusion also offer transparent backgrounds. Chat apps often draw a gray-and-white checkerboard into the pixels instead; check by placing the PNG over a colored background in Godot.

Where can I get free 2D sprites and tilesets that I'm allowed to use in a commercial game?

Kenney's asset packs are public domain (CC0) and can be used in commercial games without credit. On OpenGameArt and itch.io, check the license on each asset before you use it. Import them by copying the files into your Godot project folder.

The full guide is at https://ziva.sh/blogs/godot-ai-sprites.

Where do the sprites and tiles in your Godot game come from today? Drop your workflow in the comments.

How to generate 3D models for Godot with AI

Ziva — Wed, 04 Nov 2026 17:17:52 +0000

To make 3D models without leaving the Godot editor, ask Ziva, an AI agent that works inside Godot. Type something like "make a low-poly wooden treasure chest with metal corner bands and put it in a test scene". On Ziva Pro or Ultra, Ziva writes a Blender Python script, runs it in a copy of Blender it downloads to your computer, shows you a rendered preview in the chat and saves the model in your project as a .blend file, which Godot imports as a scene. It can then add the model to a scene and change it when you ask.

Ziva is not a text-to-3D generator like Meshy or Tripo. It builds models from shapes, materials and modifiers in code, which suits editable low-poly props, buildings, furniture and stylized scenery. For organic characters, creatures or realistic sculpted detail, use a text-to-3D or image-to-3D tool and import its GLB file. The table shows which tool does what.

Disclosure: Ziva.sh publishes this page and makes Ziva. Facts about other tools come from their own pages, as of 4 November 2026.

AI 3D model tools for Godot compared

Ziva's 3D output: a .blend file made by a Blender Python script that Ziva runs in its own downloaded Blender, on Pro and Ultra plans. Ziva's 3D Model Generator does not use Rodin, Meshy, Tripo, Hunyuan 3D or any other text-to-3D or image-to-3D model.

Tool	What it is	Input	How models get into Godot	Output	Account and price	Commercial use
Scenario for Godot	Scenario for Godot: editor dock (its README says tested on Godot 4.7.2) running Rodin, Meshy, Tripo and Hunyuan 3D models	Scenario: text, image	Scenario: GLB instanced under the selected Node3D	Scenario: GLB	Scenario: API key; 50 free daily credits; Starter $15/month	Scenario: paid plans commercial; free plan personal and evaluation use only
Rapid Assets	Rapid Assets: free plugin for Godot 4.0+ on Windows and macOS	Rapid Assets: text; some workflows take a reference image	Rapid Assets: GLB saved to `res://RapidAssets/Models/`, dropped into the scene as a MeshInstance3D	Rapid Assets: GLB	Rapid Assets: free account; generation runs in its cloud; paid limits not stated	Rapid Assets: "intended for commercial and non-commercial" projects; check its terms
Tripo plugin	Tripo plugin v0.02, Godot 4.4+	Tripo: text, image	Tripo: previewed, saved or added to the current scene as a Node3D	Tripo: not stated for the plugin	Tripo: API key; prepaid, $1 = 100 credits, 10-50 credits per model	Tripo: check its terms
Hyper3D Rodin plugin	Hyper3D Rodin's RodinBridge, Godot 4.4+, needs the Rodin webpage open in Chrome 116+	Rodin plugin: image	Rodin plugin: imported into Godot automatically	Rodin: not stated	Hyper3D Rodin: free plan, credits $1.50 each; Creator $30/month	Hyper3D Rodin: paid plans "Unlimited export and any use"; free plan not stated
Meshy	Meshy: web generator with a Godot bridge plugin from meshy.ai	Meshy: text, image	Meshy: sent from your Meshy workspace to Godot; no generation inside Godot	Meshy: GLB, FBX, OBJ, USDZ, STL, `.blend`	Meshy: the Godot bridge needs Pro ($20/month) or above; free plan 100 credits a month	Meshy: free plan CC BY 4.0 (credit required); paid plans private
Sloyd	Sloyd: web generator; Sloyd Godot Bridge on the Asset Library, Godot 4.2+	Sloyd: text, image, templates	Sloyd: sent from the Sloyd web app "straight into your active scene"	Sloyd: GLB, OBJ, FBX	Sloyd: 1 free generation a day; Plus $15/month	Sloyd: free use is personal only; Plus and up commercial
MCP for Blender	MCP for Blender: Blender add-on that lets Claude, Codex, Cursor and others drive Blender	MCP for Blender: prompt in your AI client	MCP for Blender: export from Blender, then import	MCP for Blender: anything Blender exports	MCP for Blender: free with your own Meshy, Hunyuan3D or Rodin keys; Premium from $10/month	MCP for Blender: depends on the model provider
TRELLIS.2 and Hunyuan3D 2.1	TRELLIS.2 and Hunyuan3D 2.1: open image-to-3D models you run yourself	TRELLIS.2 and Hunyuan3D 2.1: image	TRELLIS.2 and Hunyuan3D 2.1: import the GLB	TRELLIS.2: GLB; Hunyuan3D 2.1: mesh (GLB in its examples)	TRELLIS.2 and Hunyuan3D 2.1: free; TRELLIS.2 needs an NVIDIA GPU with at least 24 GB	TRELLIS.2: MIT; Hunyuan3D 2.1: license excludes the EU, UK and South Korea
Kenney, Quaternius, KayKit, Poly Pizza	Kenney, Quaternius, KayKit and Poly Pizza: free 3D asset libraries	Libraries: ready-made models, no prompt	Libraries: download, then import	Libraries: formats vary per pack	Kenney, Quaternius, Poly Pizza and KayKit's free packs: free	Kenney: CC0; Quaternius: free for commercial games, no resale as assets; Poly Pizza: per model, CC0 or CC-BY; KayKit: CC0 (pack checked)
Ziva	Ziva: AI agent in the Godot editor; runs a Blender Python script in a copy of Blender that Ziva downloads to your computer	Ziva: text, or a reference image the agent looks at	Ziva: saved to `res://`; Godot imports `.blend` as a scene; the agent can add it to a scene	Ziva: `.blend`; in our tests the agent also added a `.glb` export to its Blender script and used that in the scene	Ziva: Pro or Ultra plan; one-time Blender download of about 260-390 MB	Ziva: see Ziva's terms

The cloud generators return a mesh made by a neural model and stop there, or import it into a scene. Ziva's models are built by scripts, so you can ask for changes to proportions, colors or parts in the same chat, and because Ziva is an agent that edits your scenes and scripts, it can also place the model in a scene and wire it into your game.

How to make a 3D model in Godot with Ziva

Install Ziva in your Godot project and sign in on a Pro or Ultra plan.
Open Settings → Pro Features and click Download under 3D Model Generator. If you skip this, Ziva asks "Enable Ziva's 3D Model Generator?" with the download size the first time you ask for a model. It installs its own copy of Blender 5.2.2; on Linux the download was 365.5 MB.
Ask for a model in the chat, with size, style and where to put it, for example "Make a stylized low-poly pine tree, about 3 meters tall, with a trunk and three cone layers of leaves, save it in res://models/ and add it to my test scene." You can attach a reference image as well.
Ziva runs its Blender script, renders a preview from a camera in the Blender scene and shows it in the chat. Ask for changes ("make the lid open wider", "darker wood") and it can edit the same .blend.
The model shows up in the FileSystem dock. Godot's own .blend importer turns it into a scene you can drag into any level. On Godot 4.3 or later Ziva points Godot at its Blender if the Blender Path editor setting is empty, so there is no setup dialog.

The 3D Model Generator runs on macOS (Apple silicon), Windows (x64 or ARM64) and Linux (x64).

An example: a treasure chest and a pine tree

We tested this on 4 November 2026 in Godot 4.7.2 with a Pro account. One prompt was "Make a low-poly wooden treasure chest with metal corner bands and a slightly open lid for my game, save it in res://models/, and put it in a new scene res://scenes/chest_test.tscn so I can see it." The Blender script itself ran in about 2 seconds and Ziva showed this preview in the chat:

Ziva saved treasure_chest.blend, exported treasure_chest.glb, set up the test scene with a floor, light and camera, and ran the scene to check the framing. A second prompt asked for "a stylized low-poly pine tree, about 3 meters tall, with a trunk and three cone layers of leaves" next to the chest. Here are both models running in Godot:

The chest is 296 triangles with 3 materials and the tree is 70 triangles with 2, both flat colors with no textures. That is the style this approach is good at: simple, light props you can change by asking.

Import an AI-generated GLB or a Blender file into Godot 4

For files from Meshy, Tripo, Rodin or any other generator:

Format. Godot's docs recommend glTF 2.0 (.gltf or .glb). Copy the file into your project folder and Godot imports it as a scene.
Blender files. Godot imports .blend files by calling Blender to export glTF in the background. Set Editor Settings → FileSystem → Import → Blender → Blender Path to your Blender executable. Teammates who open the project need Blender too, so also export a .glb for teammates without Blender.
Scale. Select the file, open the Import dock and change Root Scale, then click Reimport. Generated models often come in at an arbitrary size, so check them next to a 1 m reference cube.
Collision. Before export, add -col (mesh plus static collision) or -colonly (collision only) to the end of a mesh's name. Or double-click the file to open Advanced Import Settings, select the mesh and enable Physics with a Body Type and a Shape Type. Trimesh shapes only work with Static bodies.
Materials. In Advanced Import Settings, use Actions… → Extract Materials to save them as .tres files you can edit. Godot keeps your edits when the source file is reimported.

AI-generated meshes often have far more triangles than a game needs. Decimate them in Blender, and keep Generate LODs on in the import settings so distant copies draw fewer triangles.

What Ziva's 3D Model Generator doesn't do

No neural text-to-3D or image-to-3D generation. Models are built from shapes in Blender scripts, so detailed organic shapes and realistic sculpts are out of reach.
A reference image guides the script; it is not reconstructed into a matching mesh.
No built-in rigging, animation, retopology or LOD step.
Pro and Ultra plans only. Hobby and Basic see an upgrade card.
Intel Macs and Linux ARM64 are not supported.

When another tool is better

Characters, creatures and organic props: Meshy, Tripo, Rodin or Scenario, then import the model.
Free, offline image-to-3D on your own GPU: TRELLIS.2.
Ready-made, consistent asset sets at no cost: Kenney, Quaternius or KayKit.
Driving Blender from Claude Code, Codex or Cursor outside Godot: MCP for Blender, or Ziva's MCP server for the Godot side.

Can an AI assistant fix Godot C# build errors? We tested Ziva on a .NET project

Ziva — Wed, 04 Nov 2026 14:22:46 +0000

A common test for any AI coding assistant on a Godot C# project: break the build on purpose and see whether the assistant notices. We ran that test on Ziva, an AI assistant that works inside the Godot editor, with a small Godot 4.7 .NET project on 4 November 2026.

Disclosure: Ziva.sh makes Ziva. This is a write-up of our own test; the short version is our docs page Use Ziva with Godot C#.

The setup

Godot 4.7 (.NET version) and the .NET 8 SDK on Linux.
A tiny project: a Player (Sprite2D) that moves with the arrow keys, one scene, and a .csproj that Godot created.
Ziva's default model, with approvals switched off so each turn ran to the end.

You need the .NET version of Godot and the .NET SDK for any C# work. If your project has no C# scripts yet, create the solution first with Project > Tools > C# > Create C# solution. Ziva does not set up C# in a project.

1. Write C# from a plain request

We asked:

This is a C# Godot project. Add a coin the player can collect, written in C#: when the player touches the coin, the coin disappears and a score label on screen goes up by one. Then run the scene to check it works.

Ziva wrote Coin.cs (an Area2D that listens to AreaEntered) and ScoreLabel.cs (a Label), gave the player a hitbox, and added the coin and the label to the scene. Then it ran the scene while holding the right arrow key. The screenshot from that run showed Score: 1 and the coin was gone.

In a later chat we asked for a patrolling enemy without naming a language. Ziva saw that the project used C# and wrote Enemy.cs.

2. Break the build three ways

We introduced one error at a time and asked Ziva about it in plain words.

Error we added	What we asked	What Ziva did
Called `label.AddPoints(1)`, a method that doesn't exist (CS1061)	"I edited Coin.cs and now the game won't start. Can you find the problem and fix it?"	Read the scripts, ran `dotnet build` to confirm CS1061, renamed the call, built again and ran the scene
`Score += amount * 1.5;` on an `int` (CS0266)	"Run the game and check that collecting the coin still adds to the score."	Ran the scene, got Godot's C# build error back, fixed the line, built again and checked the score went up
Removed `partial` from `Enemy` (GD0001)	"Godot says 'Failed to build project' when I press Play. Can you fix it?"	Ran `dotnet build`, added `partial`, built again and ran the scene

When Ziva runs a scene and the build fails, it gets Godot's C# build errors with file, line and error code:

res://ScoreLabel.cs:15:9 CS0266: Cannot implicitly convert type 'double' to 'int'.

These errors come from Godot's last C# build. If you edit code outside Godot and nothing has built since, there is nothing to read yet, so Ziva builds the project with dotnet build or runs the scene to find the error.

Using Ziva's tools from Claude Code, Cursor or Codex

Ziva also runs as a local MCP server. On the same C# project, its get_godot_errors and run_scene tools returned the same C# build errors, for example res://Enemy.cs:3:14 GD0001: Missing partial modifier on declaration of type 'Enemy'.

Limits

Ziva doesn't set up C# in a project. Create the C# solution in Godot first.
Ziva doesn't autocomplete C# as you type. Keep Visual Studio, VS Code or Rider for typing, and use Ziva for changes across scenes and scripts.
Ziva checks C# changes by building and running your scenes. It can't run C# unit tests.
Godot can't export C# projects to the web yet, so Ziva's Share web builds doesn't work for C# games.

The full page, kept up to date: https://ziva.sh/docs/godot-csharp

Do you use an AI assistant with Godot C#? Does it see your build errors, or do you paste them in?

DEV Community: Ziva

AI assistant for a large Godot project: Ziva and Claude Code tested on Pixelorama

The task

Results

How Ziva found its way around 1,383 files

Where Ziva struggled

What this test does not show

If your AI loses track as your project grows

FAQ

Can an AI assistant handle a large Godot project?

Why does the AI lose track as my Godot project grows?

Can Ziva refactor across many Godot files?

Is Claude Code or Ziva better for a large Godot project?

Does Ziva index my whole project?

Is Godot Good for Digital Twins? An Honest 2026 Answer

What a digital twin needs, and what Godot covers

Where Godot is a good choice

Where it falls short

What happened to Open Industry Project

Who uses Godot for industrial work today

Godot compared with the usual digital twin platforms

Connecting Godot to a PLC

When to have a twin built instead

FAQ

Can Godot be used for a digital twin?

Is Godot good for industrial simulation?

Is Godot good for non-game applications?

Who offers enterprise support for Godot in industrial projects?

How to Connect Godot to a PLC over Modbus TCP (Tested GDScript Client)

The client

A conveyor driven by a PLC coil

How we tested it

Limits

Siemens S7 and OPC UA

Need the whole twin built?

FAQ

Can Godot connect to a PLC over Modbus TCP or OPC UA?

Is there a Modbus or OPC UA addon for Godot?

Does Modbus TCP work in a Godot web export?

How to simulate keyboard and mouse input in GUT and GdUnit4 (tested on Godot 4.7.2)

GUT

GdUnit4

Outside a test framework

Pitfalls

Running headless in CI

Related reading

FAQ

How do I simulate keyboard and mouse input in Godot tests (GUT or GdUnit4)?

Why doesn't my simulated mouse click press a Button when I run Godot tests headless?

How do I run GUT or GdUnit4 tests headless in CI, and what exit codes do they return?

What is the difference between Input.parse_input_event and Input.action_press in Godot?

Godot MCP server for Claude Code and Cursor: run the game, send input, take screenshots

Godot MCP servers compared: run, input, screenshot

Set up Ziva's MCP server in Claude Code or Cursor

Claude Code

Cursor

What Ziva's MCP tools return

Tested: Claude Code running a Godot game through Ziva's MCP server

What Ziva's MCP server can't do

How to choose a Godot MCP server

Related reading

FAQ

Which Godot MCP server lets Claude Code run the game, send input and take screenshots?

How do I connect Claude Code or Cursor to Ziva's Godot MCP server?

Does Ziva's get_screenshot tool show the running game?

Is there an MCP server that works with Godot C# (.NET) projects?

Can a Godot MCP server run my game headless in CI?

How to export a Godot game to the web and share a playable link

Ways to get a playable link

Export a Godot 4 game for the web

Test the build in your browser

Fix "Cross Origin Isolation" and "SharedArrayBuffer" missing

Share the link with friends or playtesters

itch.io

GitHub Pages, Netlify or Cloudflare Pages

Ziva's Share Web build: a play.ziva.sh link from the editor

Can you export a Godot 4 C# project to the web?

What Ziva's Share Web build doesn't do

Related reading

FAQ