Skip to content
Back to search

godot-ui-integration

Build or revise Godot UI from an approved design, separated art, or a visual reference when scene structure, gameplay binding, and runtime visual verification all matter. Use for complete Godot UI integration; use ordinary Godot UI guidance for isolated node or layout questions that do not require an end-to-end visual workflow.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/zimo-xiao-zheng--godot-ui-integration/badge.svg)](/listings/zimo-xiao-zheng--godot-ui-integration)

HTML

<a href="/listings/zimo-xiao-zheng--godot-ui-integration"><img src="/api/listings/zimo-xiao-zheng--godot-ui-integration/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Copy this repository into the Codex skills directory:

~/.codex/skills/godot-ui-integration/

Install the helper dependency when using the image audit scripts:

python -m pip install -r requirements.txt

Then invoke it explicitly or let Codex select it for an end-to-end Godot UI integration request:

Use $godot-ui-integration to implement this approved UI in Godot and verify runtime visual parity.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 99 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ---
  2. name: godot-ui-integration
  3. description: Build or revise Godot UI from an approved design, separated art, or a visual reference when scene structure, gameplay binding, and runtime visual verification all matter. Use for complete Godot UI integration; use ordinary Godot UI guidance for isolated node or layout questions that do not require an end-to-end visual workflow.
  4. ---
  5. # Godot UI Integration
  6. Turn an approved UI direction into editor-visible Godot scenes, connected behavior, and verified runtime output.
  7. ## Route the request
  8. - If the user already approved a design or supplied the exact reference to implement, lock that reference and proceed.
  9. - If the visual direction is new or materially changing, prepare one composed preview and obtain approval before producing final assets or editing scenes.
  10. - If the user asks for exact, strict, pixel-close, or design-faithful reproduction, read [references/strict-reference-parity.md](references/strict-reference-parity.md) completely before editing.
  11. - For read-only diagnosis, inspect and report without changing project files.
  12. After the composed preview is approved, continue through asset preparation, scene construction, binding, and validation. Pause only when the approved composition must change, asset rights are unclear, validation remains blocked after targeted retries, or gameplay behavior would expand beyond the requested UI scope.
  13. ## Required project checks
  14. Before editing:
  15. 1. Read the project instructions and canonical UI/navigation documentation.
  16. 2. Inspect the target viewport, existing scenes, themes, input patterns, data sources, and asset directories.
  17. 3. Use the Godot MCP first for engine inspection and edits. If it is unavailable, diagnose and attempt reconnection before using a local script, CLI, or UI fallback; report the failure and fallback.
  18. 4. Record the approved reference, its dimensions, the target screen or overlay, and the intended entry and exit paths.
  19. ## Implementation invariants
  20. - Treat `.tscn` scenes as the visual source of truth. Every formal player-facing screen or major overlay must be directly openable with its representative composition visible before `_ready()` runs.
  21. - Runtime code may populate data, localized text, textures, availability, selection, and transient feedback. It must not construct or relocate the primary layout procedurally.
  22. - Give distinct formal screens distinct scenes; inherited scenes are acceptable. Serialize screen-specific hierarchy, visibility, anchors, offsets, styles, and representative state.
  23. - Keep dynamic names, prices, counts, statistics, labels, lock states, and localized strings as Godot nodes or runtime data rather than baking them into raster art.
  24. - Preserve the approved reference's silhouette, material, texture, edge treatment, proportions, and hierarchy. Use native Godot primitives only where the design itself is visually simple.
  25. - Store final resources inside the Godot project. Do not leave scenes referencing temporary generation or working directories.
  26. - Reuse project conventions unless doing so would contradict the approved design or the user's asset-source constraints.
  27. ## Workflow
  28. 1. **Survey:** identify the affected scenes, scripts, data, navigation, input, viewport, safe areas, fonts, and reusable components.
  29. 2. **Lock the design:** choose the exact approved reference and map major regions, dynamic fields, hit targets, ownership, and responsive behavior.
  30. 3. **Plan assets:** classify each visual as direct extraction, reference-guided generation, reconstruction, reusable project art, or native Godot styling. Confirm source rights before reuse.
  31. 4. **Prepare assets:** create one final file per asset, remove temporary backgrounds, preserve intended transparency, normalize display size, and avoid destructive whole-canvas stretching.
  32. 5. **Build scenes:** serialize the formal composition and reusable repeated components in `.tscn`; keep decorative children from intercepting input.
  33. 6. **Bind behavior:** connect data, navigation, disabled/empty/error states, persistent selection, controller/keyboard focus, and save boundaries without rebuilding the authored layout.
  34. 7. **Validate:** inspect the editor scene, run the UI at the target resolution, exercise interactions, check errors, compare against the reference, and update the project UI documentation.
  35. ## Validation helpers
  36. The included Python tools require Pillow:
  37. ```bash
  38. python -m pip install -r requirements.txt
  39. ```
  40. - Inspect alpha and visible bounds:
  41. ```bash
  42. python scripts/alpha_audit.py path/to/asset.png
  43. ```
  44. - Build a contact sheet for candidate review:
  45. ```bash
  46. python scripts/contact_sheet.py "path/to/candidates/*.png" --out path/to/contact-sheet.png
  47. ```
  48. - Compare an approved reference with a runtime capture:
  49. ```bash
  50. python scripts/reference_parity_audit.py reference.png runtime.png --out path/to/parity.png
  51. ```
  52. - Audit panel-like textures for deformation and invalid nine-slice margins:
  53. ```bash
  54. python scripts/stretch_audit.py --project-root path/to/project --scene res://path/to/screen.tscn
  55. ```
  56. - Remove an edge-connected white background from an approved cutout:
  57. ```bash
  58. python scripts/white_bg_to_alpha.py --input source.png --out asset.png
  59. ```
  60. Review generated outputs visually. Passing deterministic checks does not prove design fidelity.
  61. ## Completion gate
  62. Do not report completion until:
  63. - the formal scene is editor-visible before runtime binding;
  64. - the runtime path reaches and exits the UI correctly;
  65. - dynamic content and interaction states behave correctly;
  66. - there are no new parse, import, or runtime errors caused by the change;
  67. - strict-reference work includes a same-resolution comparison artifact and disclosed deviations;
  68. - the canonical project UI documentation reflects the implemented behavior and validation evidence.
  69. Report the changed scenes, scripts, assets, runtime captures, validation commands, MCP status, known deviations, and any deferred product decisions.
README.md · README · 49 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # Godot UI Integration Skill
  2. A Codex skill for turning approved UI designs and visual references into editor-visible Godot scenes, connected runtime behavior, and reviewable visual evidence.
  3. It is designed for the part that usually gets lost between a mockup and a working game UI:
  4. - preserving an approved composition instead of approximating it with generic panels;
  5. - keeping formal screens visible and editable as `.tscn` scenes;
  6. - separating static art from dynamic text and state;
  7. - connecting navigation, data, focus, and persistent selection;
  8. - validating runtime output against the reference rather than accepting a plausible screenshot.
  9. ## Included
  10. - `SKILL.md` — routing, implementation invariants, workflow, and completion gate
  11. - `references/strict-reference-parity.md` — the stricter contract for pixel-close work
  12. - `scripts/alpha_audit.py` — transparency and visible-bounds inspection
  13. - `scripts/contact_sheet.py` — deterministic candidate contact sheets
  14. - `scripts/reference_parity_audit.py` — side-by-side, overlay, and difference comparison
  15. - `scripts/stretch_audit.py` — static audit for distorted Godot texture controls
  16. - `scripts/white_bg_to_alpha.py` — edge-connected white-background removal
  17. ## Install
  18. Copy this repository into the Codex skills directory:
  19. ```text
  20. ~/.codex/skills/godot-ui-integration/
  21. ```
  22. Install the helper dependency when using the image audit scripts:
  23. ```bash
  24. python -m pip install -r requirements.txt
  25. ```
  26. Then invoke it explicitly or let Codex select it for an end-to-end Godot UI integration request:
  27. ```text
  28. Use $godot-ui-integration to implement this approved UI in Godot and verify runtime visual parity.
  29. ```
  30. ## Scope
  31. This skill does not replace ordinary Godot documentation or a general-purpose UI tutorial. It provides the workflow and verification rules needed when visual intent, editor scene structure, gameplay binding, and runtime parity must survive the same implementation.
  32. ## License
  33. MIT

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.