Agent skill · Audited from source
godot-resources
skill · gamedev-skills/awesome-gamedev-agent-skillsApache-2.0 licenceAudited 13 Nov 2026 · source c974b5ce8f0d
Is it safe? Yes — SAFE, grade B (89/100). We read this skill's source at commit c974b5ce8f0d and found no filesystem, network or shell access and no hard-coded secrets. What it does: Godot 4.7 data-driven design with custom Resources: class_name and @export fields, .tres files, shared references vs duplicate_deep(), uids and threaded loading. Use for items, stats or enemy configs as data, or when…
Cite
Cite this page
ModelsAtlas. “godot-resources (gamedev-skills/awesome-gamedev-agent-skills)”. Retrieved 13 Nov 2026. https://modelsatlas.com/skills/gamedev-skills/godot-resources
Trust audit
Audit 0.4.1 · source read 13 Nov 2026
SAFE means nothing in the source contradicts what the skill says it does. Grade B is shared by 17,406 of 18,389 audited skills.
What the source does
- FilesystemNone observedNo reads or writes in the source
- NetworkNone observedNo outbound calls in the source
- ShellNone observedNo commands run in the source
- DependenciesPinnedNothing floats
- SecretsNone foundNo keys in source
Five audit layers
| Layer | What we check | Result | Findings |
|---|---|---|---|
L0 Provenance | Repo owner, licence, archive status, activity | PASS | 0 |
L1 Static source | Secrets, path traversal, supply chain, hidden code | NA | 0 |
L2 Instructions | Prompt injection, authority framing, hidden directives | PASS | 0 |
L3 Inventory | The files and declarations match the source | PASS | 0 |
L4 Sandbox | Run in isolation and watch behaviour | SKIPPED why | 0 |
Gates applied: no behavioural pass.
Findings (0)
No findings at any severity. We re-audit when the source changes.
Audit 0.4.1 · source sha c974b5ce8f0d · 13 Nov 2026Report an issue or request a re-scan
Provenance
Who published it, and what the verdict is pinned to
- Publishergamedev-skills GitHub organizationOwner of the repository this skill is read from
- Source foldergamedev-skills/awesome-gamedev-agent-skills/skills/godot/godot-resourcesThe exact folder we audited
- LicenceApache-2.0As the repository states it
- Commit pinned for this verdictc974b5ce8f0dA new audit runs when the source changes
- Repository statusNot archivedLast push 1 day ago
- Sandboxed runNot runSkills are read, not executed; layer L4 is skipped
What it tells the agent
Full source on GitHub ↗Its description: Godot 4.7 data-driven design with custom Resources: class_name and @export fields, .tres files, shared references vs duplicate_deep(), uids and threaded loading. Use for items, stats or enemy configs as data, or when…
---
name: godot-resources
description: >
Godot 4.7 data-driven design with custom Resources: class_name and @export fields, .tres files,
shared references vs duplicate_deep(), uids and threaded loading. Use for items, stats or enemy
configs as data, or when editing one enemy changes every enemy or a .tres stops loading. Not for
save slots (`save-systems`) or the C# version (`godot-csharp`).
---
# Godot Resources (4.x)
Model game data as `Resource` objects saved as `.tres`/`.res`, share them safely, and
load them without hitches. Targets **Godot 4.7** (see Version notes).
## When to use
- Items, stats, enemy configs, dialogue lines or level metadata as data files; custom
`Resource` subclasses; `ResourceLoader`/`ResourceSaver` code.
**When *not* to use:** scene structure → `godot-nodes-scenes`; the player's runtime
progress, slots and migration → `save-systems`; C# → `godot-csharp`.
## Core workflow
1. **Subclass `Resource`** with `class_name` and typed `@export` fields (Pattern 1). The
`class_name` is what lets the editor offer it in "New Resource" and as an export type.
2. **Create instances as text `.tres` files.** You can write them directly (Pattern 2)
instead of clicking through the FileSystem dock and Inspector; use binary `.res` only for
large generated data.
3. **Reference resources from nodes** with `@export var data: ItemResource` or
`@export var loot: Array[ItemResource]`, or load them by path in code.
4. **Load** with `preload` (constant path) or `load` (variable path); use
`ResourceLoader.load_threaded_request` for large scenes (see the reference).
5. **Duplicate before mutating** a shared resource at runtime (Pattern 3); every node that
loaded the same path holds the same object.
6. **Check before you finish.**
- After adding or moving `.tres`/`.gd` files, run the `godot-nodes-scenes` skill's
`scripts/check_godot_project.py <project-dir>` to catch broken `ext_resource` paths,
uids and ids. Fix every `ERROR`.
- Prove the data loads and copies correctly with a headless test (Pattern 4):
`godot --headless --path . --import` once on a fresh checkout (so `class_name` types
resolve), then `godot --headless --path . --script res://tests/test_items.gd`, and
read the exit code. With no Godot binary (`godot`, `godot4` or `$GODOT_BIN`), ask the
user to run both lines and paste the output.
## Patterns
### 1. A custom data resource
```gdscript
# res://items/item.gd
extends Resource
class_name ItemResource
@export var id: StringName = &""
@export var display_name: String = "Item"
@export_multiline var description: String = ""
@export var icon: Texture2D
@export var max_stack: int = 99
@export var value: int = 0
```
### 2. The same item as a hand-written `.tres`
```ini
[gd_resource type="Resource" script_class="ItemResource" format=3]
[ext_resource type="Script" path="res://items/item.gd" id="1_item"]
[resource]
script = ExtResource("1_item")
id = &"sword"
display_name = "Sword"
max_stack = 1
value = 50
```
Leave out the `uid=` attributes; Godot adds them the next time the file is saved. Fields
left out keep the script defaults.
### 3. Duplicate before mutating shared data
```gdscript
func give_unique_copy(template: ItemResource) -> ItemResource:
# true = deep: copies nested arrays/dictionaries and *embedded* sub-resources, but
# sub-resources saved in their own .tres stay shared. Use
# template.duplicate_deep(Resource.DEEP_DUPLICATE_ALL) to copy those as well.
var copy: ItemResource = template.duplicate(true)
copy.value += 5 # mutating the copy won't touch the template .tres
return copy
```
### 4. Headless check: the file loads as its class and copies are independent
```gdscript
# res://tests/test_items.gd
extends SceneTree
func _initialize() -> void:
var failed := 0
var sword := load("res://items/sword.tres") as ItemResource
if sword == null:
failed += 1
push_error("sword.tres did not load as ItemResource")
else:
var copy: ItemResource = sword.duplicate(true)
copy.value += 1
if copy.value == sword.value:
failed += 1
push_error("duplicate(true) shares state with the template")
print("Results: %d failed" % failed)
quit(1 if failed > 0 else 0)
```
## Gotchas
- **Resources are shared by reference.** Every `load()` of one path returns the same cached
object, so mutating it changes every user (and re-saving writes the change into the
file). Duplicate for per-instance state, or set `resource_local_to_scene = true` for a
copy per scene instance.
- **A deep copy still changes the original's sub-resource** → `duplicate(true)` only copies
sub-resources embedded in the file; one saved as its own `.tres` (e.g. a shared
`stats.tres` inside `goblin.tres`) stays the same object. Use
`duplicate_deep(Resource.DEEP_DUPLICATE_ALL)` when those must be copied too.
- **`class_name` is required for editor and typed use.** Without it the class is missing
from "New Resource" and cannot be an `@export` type.
- **`class_name` "not declared" only in headless or CI runs** → the global class cache in
`.godot/` is missing on a fresh checkout. Run `godot --headless --path . --import` first.
- **`res://` is read-only in exported games.** Write runtime data to `user://`.
`ResourceSaver.save` to `res://` works only while running from the project folder.
- **Moving a `.gd` or `.tres` outside the editor breaks `ext_resource` paths.** Move the
`.uid` sidecar with scripts, then run the checker; a uid that still resolves keeps the
link working.
- **Nodes stored in a Resource don't serialize.** Resources hold data; reference scenes as
`PackedScene`, not node instances.
- **Cyclic references** (A holds B holds A) can fail to save or load cleanly; keep data
graphs acyclic or link by id.
- **`preload` vs `load`.** `preload` needs a constant path and loads with the script;
`load` takes a runtimeExcerpt, first 6,000 characters of SKILL.md, verbatim from the audited commit. It is text from someone else’s repository, quoted so you can judge it before your agent reads it.
Install
Pinned to the audited commit c974b5c
git clone https://github.com/gamedev-skills/awesome-gamedev-agent-skills git -C awesome-gamedev-agent-skills checkout c974b5ce8f0d
The author documents no install command, so this uses the repository directly. Our verdict covers commit c974b5ce8f0d only.
Works in
The author has not said which agents this skill supports, and we have not tested it in any.
Audit history
Every audit, every source change
- ✓SAFE B 89 / 100
first audit · source
c974b5ce8f0d
README badge
For maintainers · shows the latest audit
[](https://modelsatlas.com/skills/gamedev-skills/godot-resources/)
The badge shows our verdict and grade for this skill, and links back to this page. It changes when the audit does.
Similar skills
gamedev-skills/awesome-gamedev-agent-skills
Godot 4.7 Shading Language syntax and pipeline: canvas_item, spatial and particle shaders, built-ins, ShaderMaterial wiring, a headless compile check and 3.x porting. Use for a .gdshader, a SHADER ERROR, shader…
gamedev-skills/awesome-gamedev-agent-skills
Godot 4.7 physics API in 2D and 3D: body and Area types, collision_layer and mask bits, Area signals for hurtboxes, RayCast and space queries, and Jolt (3D default since 4.6). Use when objects pass through each other,…
gamedev-skills/awesome-gamedev-agent-skills
Build networked games with Godot 4.7 high-level multiplayer: set up an ENetMultiplayerPeer server/client, define RPCs with the @rpc annotation (call via rpc()/rpc_id()), set per-node multiplayer authority, and replicate…
gamedev-skills/awesome-gamedev-agent-skills
Structure a Godot 4.7 project with the scene tree and node composition: build reusable scenes, instance PackedScenes at runtime, navigate the tree safely, and register autoload singletons. Use when designing .tscn…
gamedev-skills/awesome-gamedev-agent-skills
Export and build a Godot 4.7 project for distribution: install export templates, define export presets (Windows/macOS/Linux/Web/Android), run headless command-line exports for CI, and handle web (HTML5) COOP/COEP and…
gamedev-skills/awesome-gamedev-agent-skills
Write idiomatic GDScript for Godot 4.7: static typing, the node lifecycle (_ready/_process/_physics_process), @export/@onready/@tool annotations, signals, and await for asynchronous flow. Use when editing .gd scripts in…
Add this badge to your README
[](https://modelsatlas.com/skills/gamedev-skills/godot-resources/)
<a href="https://modelsatlas.com/skills/gamedev-skills/godot-resources/"><img src="https://modelsatlas.com/skills/gamedev-skills/godot-resources/badge.svg" alt="ModelsAtlas: SAFE B"></a>
Questions about godot-resources
What does the godot-resources skill do?
Is godot-resources safe to install?
What can godot-resources access on my machine?
How current is this page?
Sources
- github.com/gamedev-skills/awesome-gamedev-agent-skills/tree/main — the audited source at commit c974b5ce8f0d and every finding aboveObserved · 13 Nov 2026
Spotted something wrong? Report a correction · Methodology
Keep going in your AI
Opens with this page as the source. We add nothing else to the prompt.
- What does the godot-resources skill do?
- Is godot-resources safe to install?
- What can godot-resources access on my machine?