Skip to content

Can GPT-6.1 Sol write working Godot 4 code? 15 of 15 on the first try

By Eduardo Orellana · Updated

GPT-6.1 Sol passed 15 of 15 Godot 4 tasks on the first try and 15 of 15 after one fix with the test's output, each run headless on Godot 4.7.2. It missed none.

The main page on this subject is The best LLM for Godot.

AppImage, x86_64. Ubuntu 22.04, Debian 12, Fedora 39 or newer.

Intel or AMD Chromebook, with Linux turned on.

Download for macOSDownload for WindowsDownload for Linux

Every model measured on the same Godot 4 tasks, each run headless on Godot 4.7.2 at a fixed 60 frames per second.

Measured by Flockbay: the same tasks, the same checks, one fix allowed with the test output.

Every model measured on the same Godot 4 tasks, each run headless on Godot 4.7.2 at a fixed 60 frames per second., checked 6 October 2026
ModelFirst tryAfter one fixAgentRun onRead from
Claude Opus 5.515 of 1515 of 15Claude Code2026-10-06Claude Opus 5.5 results
Claude Sonnet 5.515 of 1515 of 15Claude Code2026-10-06Claude Sonnet 5.5 results
GPT-6.1 Sol15 of 1515 of 15Codex2026-10-06GPT-6.1 Sol results
DeepSeek V4.1 Flash15 of 1515 of 15Hosted, by API2026-10-18DeepSeek V4.1 Flash results
Ember-115 of 1515 of 15Hosted, by API2026-10-18Ember-1 results
Gemini 3.1 Pro Preview15 of 1515 of 15Hosted, by API2026-10-18Gemini 3.1 Pro Preview results
Muse Wonder15 of 1515 of 15Hosted, by API2026-10-18Muse Wonder results
Kimi K315 of 1515 of 15Hosted, by API2026-10-18Kimi K3 results
GPT-5.6 Luna15 of 1515 of 15Hosted, by API2026-10-18GPT-5.6 Luna results
GPT-6 Luna15 of 1515 of 15Hosted, by API2026-10-18GPT-6 Luna results
Hy4 preview15 of 1515 of 15Hosted, by API2026-10-18Hy4 preview results
Pareto 26.1015 of 1515 of 15Hosted, by API2026-10-18Pareto 26.10 results
Claude Fable 5.215 of 1515 of 15Hosted, by API2026-11-09Claude Fable 5.2 results
Claude Haiku 5.514 of 1515 of 15Hosted, by API2026-10-18Claude Haiku 5.5 results
MiMo-V2.6-Pro-UltraSpeed14 of 1515 of 15Hosted, by API2026-10-18MiMo-V2.6-Pro-UltraSpeed results
GLM 5.214 of 1515 of 15Hosted, by API2026-10-18GLM 5.2 results
DeepSeek V4 Pro 081314 of 1514 of 15Hosted, by API2026-10-18DeepSeek V4 Pro 0813 results
GPT-5.414 of 1514 of 15Hosted, by API2026-10-18GPT-5.4 results
MiniMax M313 of 1514 of 15Hosted, by API2026-10-18MiniMax M3 results
Qwen3.7 Max13 of 1514 of 15Hosted, by API2026-10-18Qwen3.7 Max results
Fugu Max13 of 1514 of 15Hosted, by API2026-10-18Fugu Max results
Beam 1.0 501B A23B12 of 1514 of 15Hosted, by API2026-10-18Beam 1.0 501B A23B results
Mistral Large 412 of 1513 of 15Hosted, by API2026-10-18Mistral Large 4 results
Claude Haiku 4.511 of 1514 of 15Claude Code2026-10-06Claude Haiku 4.5 results
Nemotron 3.5 Super VL11 of 1514 of 15Hosted, by API2026-10-18Nemotron 3.5 Super VL results
LongCat 2.011 of 1513 of 15Hosted, by API2026-10-18LongCat 2.0 results
Grok 4.311 of 1513 of 15Hosted, by API2026-10-18Grok 4.3 results
Laguna S 2.19 of 1512 of 15Hosted, by API2026-10-18Laguna S 2.1 results
Nova 2 Lite2 of 154 of 15Hosted, by API2026-10-18Nova 2 Lite results

How the test works

Each task asks for one GDScript file with a stated API, in a fresh Godot project. GPT-6.1 Sol ran as a coding agent (Codex, headless, allowed to read and write files and nothing else). A check scene then loaded the file and drove it on Godot 4.7.2, headless, at a fixed 60 frames per second: it pressed input actions, stepped physics, waited on timers and signals, and compared the results.

When a task failed, the model got the check's output once and could fix its file. Every task touches an API that changed between Godot 3 and Godot 4, or was added since: move_and_slide and is_on_floor, FileAccess and JSON, signals, tweens, Timer nodes, PackedScene, TileMapLayer, ray queries, AStarGrid2D, AnimationLibrary, and lambdas, which capture local variables by value.

The checks themselves are tested first: each passes on a reference answer and fails on an empty script. Run on 2026-10-06.

More on this: The best LLM for Godot

Move a CharacterBody2D with an input action: pass

The task: Write res://player.gd for Godot 4: a script for a CharacterBody2D that moves right at 200 pixels per second while the input action "ui_right" is held, and stands still otherwise.

Passed on the first try.

GDScript
extends CharacterBody2D

func _physics_process(_delta: float) -> void:
	velocity = Vector2(200.0, 0.0) if Input.is_action_pressed("ui_right") else Vector2.ZERO
	move_and_slide()

Fall with gravity and land on the floor: pass

The task: Write res://ball.gd for Godot 4: a script for a CharacterBody2D that falls with a gravity of 980 pixels per second squared and stops when it lands on the floor. The scene gives it its collision shape.

Passed on the first try.

GDScript
extends CharacterBody2D

const GRAVITY: float = 980.0

func _physics_process(delta: float) -> void:
	if is_on_floor():
		velocity.y = 0.0
	else:
		velocity.y += GRAVITY * delta
	move_and_slide()

A score label: pass

The task: Write res://score_label.gd for Godot 4: a script for a Label that shows "Score: 0" when it enters the scene, and has a method add(points: int) that adds to the score and updates the text to "Score: <total>".

Passed on the first try.

GDScript
extends Label

var score: int = 0

func _ready() -> void:
	text = "Score: %d" % score

func add(points: int) -> void:
	score += points
	text = "Score: %d" % score

Save and load a dictionary as JSON: pass

The task: Write res://save_game.gd for Godot 4: a script extending RefCounted with two static functions: save_data(data: Dictionary, path: String) -> void writes the dictionary to the file as JSON, and load_data(path: String) -> Dictionary reads it back.

Passed on the first try.

GDScript
extends RefCounted


static func save_data(data: Dictionary, path: String) -> void:
	var file := FileAccess.open(path, FileAccess.WRITE)
	if file == null:
		push_error("Failed to open file for saving: %s" % path)
		return
	file.store_string(JSON.stringify(data))
	file.close()


static func load_data(path: String) -> Dictionary:
	var file := FileAccess.open(path, FileAccess.READ)
	if file == null:
		push_error("Failed to open file for loading: %s" % path)
		return {}
	var contents := file.get_as_text()
	file.close()
	var json := JSON.new()
	if json.parse(contents) != OK:
		push_error("Failed to parse JSON in file: %s" % path)
		return {}
	if not (json.data is Dictionary):
		push_error("JSON in file is not a Dictionary: %s" % path)
		return {}
	return json.data

Health with signals: pass

The task: Write res://health.gd for Godot 4: a script extending Node with health starting at 100, a signal health_changed(old_value: int, new_value: int), a signal died, and a method take_damage(amount: int) that lowers health without going below 0, emits health_changed when health changes, and emits died once, when health reaches 0.

Passed on the first try.

GDScript
extends Node

signal health_changed(old_value: int, new_value: int)
signal died

var health: int = 100
var _has_died: bool = false

func take_damage(amount: int) -> void:
	var old_value: int = health
	health = maxi(0, health - maxi(0, amount))
	if health != old_value:
		health_changed.emit(old_value, health)
		if health == 0 and not _has_died:
			_has_died = true
			died.emit()

Fade out with a tween: pass

The task: Write res://fader.gd for Godot 4: a script extending Node2D with a method fade_out(duration: float) that fades the node's modulate alpha from 1 to 0 over duration seconds with a tween, and a signal faded emitted when the fade ends.

Passed on the first try.

GDScript
extends Node2D

signal faded


func fade_out(duration: float) -> void:
	modulate.a = 1.0
	var tween := create_tween()
	tween.tween_property(self, "modulate:a", 0.0, duration)
	tween.finished.connect(func() -> void: faded.emit())

Spawn on a timer, then stop: pass

The task: Write res://spawner.gd for Godot 4: a script extending Node that, once in the scene, adds a new child Node2D every 0.25 seconds, using a Timer, and stops after 4 children. It keeps the number spawned in a variable spawned_count.

Passed on the first try.

GDScript
extends Node

var spawned_count: int = 0
var spawn_timer: Timer


func _ready() -> void:
	spawn_timer = Timer.new()
	spawn_timer.wait_time = 0.25
	spawn_timer.timeout.connect(_on_spawn_timer_timeout)
	add_child(spawn_timer)
	spawn_timer.start()


func _on_spawn_timer_timeout() -> void:
	add_child(Node2D.new())
	spawned_count += 1
	if spawned_count >= 4:
		spawn_timer.stop()

A door with states: pass

The task: Write res://door.gd for Godot 4: a script extending Node for a door with the states CLOSED, OPENING and OPEN. It starts CLOSED. A method interact() starts opening a closed door; 0.5 seconds of game time later it is OPEN. A method get_state_name() -> String returns "CLOSED", "OPENING" or "OPEN".

Passed on the first try.

More on this: Opus 5.5 vs GPT-6.1 Sol: The Door Problem in Godot

GDScript
extends Node

enum State { CLOSED, OPENING, OPEN }

var state: State = State.CLOSED


func interact() -> void:
	if state != State.CLOSED:
		return
	state = State.OPENING
	await get_tree().create_timer(0.5, false).timeout
	state = State.OPEN


func get_state_name() -> String:
	match state:
		State.CLOSED:
			return "CLOSED"
		State.OPENING:
			return "OPENING"
		State.OPEN:
			return "OPEN"
	return "CLOSED"

An inventory with counts: pass

The task: Write res://inventory.gd for Godot 4: a script extending RefCounted with add_item(item_name: String, count: int), remove_item(item_name: String, count: int) -> bool that removes only when there are enough and returns whether it did, and get_count(item_name: String) -> int that is 0 for an item never added.

Passed on the first try.

GDScript
extends RefCounted

var _items: Dictionary = {}


func add_item(item_name: String, count: int) -> void:
	if count > 0:
		_items[item_name] = get_count(item_name) + count


func remove_item(item_name: String, count: int) -> bool:
	if count < 0 or get_count(item_name) < count:
		return false
	if count > 0:
		_items[item_name] = get_count(item_name) - count
	return true


func get_count(item_name: String) -> int:
	return int(_items.get(item_name, 0))

Load a level scene from a path: pass

The task: Write res://level_loader.gd for Godot 4: a script extending Node with a method load_level(path: String) -> Node that loads the scene file at path, creates an instance of it, adds it as a child, and returns it.

Passed on the first try.

GDScript
extends Node


func load_level(path: String) -> Node:
	var scene: PackedScene = load(path)
	var instance: Node = scene.instantiate()
	add_child(instance)
	return instance

Paint cells on a TileMapLayer: pass

The task: Write res://grid_painter.gd for Godot 4.7: a script extending TileMapLayer with paint_row(y: int, from_x: int, to_x: int) that sets the cells from (from_x, y) to (to_x, y) inclusive to tile source 0, atlas coordinates (0, 0), and is_painted(cell: Vector2i) -> bool that says whether a cell has a tile.

Passed on the first try.

More on this: Can GPT-5.4 write working Godot 4 code? 14 of 15 on the first try

GDScript
extends TileMapLayer


func paint_row(y: int, from_x: int, to_x: int) -> void:
	for x in range(from_x, to_x + 1):
		set_cell(Vector2i(x, y), 0, Vector2i(0, 0))


func is_painted(cell: Vector2i) -> bool:
	return get_cell_source_id(cell) != -1

Cast a physics ray: pass

The task: Write res://line_of_sight.gd for Godot 4: a script extending Node2D with first_hit(from: Vector2, to: Vector2) -> Vector2 that casts a physics ray through the 2D world from from to to and returns the point where it first hits a collider, or to when it hits nothing. It is called from physics processing.

Passed on the first try.

More on this: GPT-6.1 Sol vs Opus 5.5 Physics Truck Game

GDScript
extends Node2D


func first_hit(from: Vector2, to: Vector2) -> Vector2:
	var query := PhysicsRayQueryParameters2D.create(from, to)
	var hit := get_world_2d().direct_space_state.intersect_ray(query)
	if hit.is_empty():
		return to
	return hit["position"]

A path on a grid around walls: pass

The task: Write res://path_finder.gd for Godot 4: a script extending RefCounted with find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i] that returns the shortest path of grid cells from from to to, both included, on a grid of size cells, never entering a wall cell and moving only up, down, left or right.

Passed on the first try.

GDScript
extends RefCounted


func find_path(size: Vector2i, walls: Array[Vector2i], from: Vector2i, to: Vector2i) -> Array[Vector2i]:
	var path: Array[Vector2i] = []
	if size.x <= 0 or size.y <= 0:
		return path
	if not _in_bounds(from, size) or not _in_bounds(to, size):
		return path

	var blocked: Dictionary = {}
	for wall in walls:
		blocked[wall] = true
	if blocked.has(from) or blocked.has(to):
		return path

	var queue: Array[Vector2i] = [from]
	var parents: Dictionary = {from: from}
	var head: int = 0
	var directions: Array[Vector2i] = [Vector2i.UP, Vector2i.DOWN, Vector2i.LEFT, Vector2i.RIGHT]
	while head < queue.size():
		var cell: Vector2i = queue[head]
		head += 1
		if cell == to:
			var cursor: Vector2i = to
			while cursor != from:
				path.append(cursor)
				cursor = parents[cursor]
			path.append(from)
			path.reverse()
			return path
		for direction in directions:
			var neighbor: Vector2i = cell + direction
			if not _in_bounds(neighbor, size) or blocked.has(neighbor) or parents.has(neighbor):
				continue
			parents[neighbor] = cell
			queue.append(neighbor)
	return path


func _in_bounds(cell: Vector2i, size: Vector2i) -> bool:
	return cell.x >= 0 and cell.y >= 0 and cell.x < size.x and cell.y < size.y

Build and play an animation in code: pass

The task: Write res://blinker.gd for Godot 4: a script extending Node2D that, when it enters the scene, creates an AnimationPlayer child and a looping animation named "blink", 1 second long, that keeps the node visible for the first half of each second and hidden for the second half, and plays it.

Passed on the first try.

GDScript
extends Node2D


func _ready() -> void:
	var player := AnimationPlayer.new()
	add_child(player)
	player.root_node = NodePath("..")

	var animation := Animation.new()
	animation.length = 1.0
	animation.loop_mode = Animation.LOOP_LINEAR
	var track := animation.add_track(Animation.TYPE_VALUE)
	animation.track_set_path(track, NodePath(".:visible"))
	animation.value_track_set_update_mode(track, Animation.UPDATE_DISCRETE)
	animation.track_insert_key(track, 0.0, true)
	animation.track_insert_key(track, 0.5, false)

	var library := AnimationLibrary.new()
	library.add_animation("blink", animation)
	player.add_animation_library("", library)
	visible = true
	player.play("blink")

Wait for a signal or a timeout: pass

The task: Write res://waiter.gd for Godot 4: a script extending Node with wait_for(sig: Signal, seconds: float) -> bool, a coroutine that waits until the signal is emitted or seconds of game time pass, whichever comes first, and returns true if the signal came first. The signal has no arguments.

Passed on the first try.

GDScript
extends Node


class WaitRace:
	extends RefCounted
	signal finished(signal_won: bool)
	var settled := false

	func settle(signal_won: bool) -> void:
		if settled:
			return
		settled = true
		finished.emit(signal_won)


func wait_for(sig: Signal, seconds: float) -> bool:
	var race := WaitRace.new()
	var on_signal := func() -> void: race.settle(true)
	var on_timeout := func() -> void: race.settle(false)
	var timer := get_tree().create_timer(maxf(seconds, 0.0), false)
	sig.connect(on_signal, CONNECT_ONE_SHOT)
	timer.timeout.connect(on_timeout, CONNECT_ONE_SHOT)
	var signal_won: bool = await race.finished
	if sig.is_connected(on_signal):
		sig.disconnect(on_signal)
	if timer.timeout.is_connected(on_timeout):
		timer.timeout.disconnect(on_timeout)
	return signal_won

Questions

Is GPT-6.1 Sol good at Godot?
On these 15 tasks it passed 15 on the first try and 15 after one fix. Each task is small and checked by running it, so the score says whether its Godot 4 code works, not how well it designs a game.

Flockbay runs your own agent, Claude or ChatGPT on the official Godot 4.7.2, and gives it Godot's errors the way this test does.

Download Flockbay free