Now liveThe Skillselion MCP - thousands of ranked skills, loaded into your agent mid-task. No install.Get it →
jwynia avatar

Godot Asset Generator

jwynia/agent-skills

  • 909 installs
  • 133 repo stars
  • Updated February 24, 2026
  • jwynia/agent-skills

godot-asset-generator is a Claude Code skill that generates 2D game art with AI image APIs and prepares sprite sheets, tilesets, and import settings for Godot 4.x developers building games.

About

godot-asset-generator is a Deno-based agent skill in jwynia/agent-skills that turns AI image generation into Godot-ready game art. It covers concept art, style guides, sprites, sprite sheets, tilesets, UI icons, and animation frames using providers such as DALL-E, Replicate, and fal.ai, then writes import configuration for Godot 4.x. Developers reach for godot-asset-generator when they need repeatable 2D asset batches without hand-painting every frame or manually tuning Godot import presets. API keys such as OPENAI_API_KEY, REPLICATE_API_TOKEN, or fal.ai credentials are required for the chosen provider.

  • Generates concept art, style-consistent sprites, sprite sheets, tilesets, and UI elements via DALL-E, Replicate, or fal.
  • Handles the full 2D art pipeline from prompt to Godot-ready import configuration
  • Supports batch generation of animation frames and consistent asset sets using style guides
  • Outputs Godot import settings and organized asset folders
  • 2D assets only; explicitly excludes 3D models and textures

Godot Asset Generator by the numbers

  • 909 all-time installs (skills.sh)
  • +10 installs in the week ending Aug 5, 2026 (Skillselion tracking)
  • Ranked #297 of 1,335 Generative Media skills by installs in the Skillselion catalog
  • Security screen: LOW risk (skills.sh audit)
  • Data as of Aug 5, 2026 (Skillselion catalog sync)
npx skills add https://github.com/jwynia/agent-skills --skill godot-asset-generator

Add your badge

Show developers this skill is listed on Skillselion. Paste this into your README.

Listed on Skillselion
Installs909
repo stars★ 133
Security audit3 / 3 scanners passed
Last updatedFebruary 24, 2026
Repositoryjwynia/agent-skills ↗

How do you generate Godot 4.x sprites with AI?

Generate 2D sprites, tilesets, UI icons, and animation frames with AI then automatically prepare them for Godot 4.x import.

Who is it for?

Game developers on Godot 4.x who want AI-generated 2D art with automated import prep instead of manual sprite pipeline work.

Skip if: Teams needing 3D models, proprietary engine pipelines, or art workflows with no Deno runtime or image API keys.

When should I use this skill?

The user asks to generate game sprites, tilesets, pixel art, UI icons, or Godot import settings using AI image APIs.

What you get

2D sprites, sprite sheets, tilesets, UI icons, animation frames, style guides, and Godot 4.x import configuration files.

  • Sprite sheets
  • Tilesets
  • Godot import configuration

Files

SKILL.mdMarkdownGitHub ↗

Godot Asset Generator

Generate game assets using AI image generation APIs and prepare them for use in Godot 4.x. This skill covers the complete art pipeline from concept to Godot-ready sprites.

When to Use This Skill

Use this skill when:

  • Generating game sprites, characters, or objects using AI
  • Creating tilesets for platformers or top-down games
  • Generating UI elements, icons, or menu assets
  • Batch-generating animation frames
  • Preparing AI-generated assets for Godot import
  • Creating consistent asset sets with style guides

Do NOT use this skill when:

  • Creating 3D models or textures (2D assets only)
  • Manual pixel art or illustration (use art software)
  • Complex frame-by-frame animation (use animation tools)
  • Working with existing assets (use Godot directly)

Prerequisites

Required:

  • Deno runtime installed
  • At least one API key:
  • OPENAI_API_KEY for DALL-E 3
  • REPLICATE_API_TOKEN for Replicate (SDXL, Flux)
  • FAL_KEY for fal.ai

Optional:

  • ImageMagick for advanced image processing
  • Godot 4.x project for import file generation

Quick Start

Generate a Single Image

deno run --allow-env --allow-net --allow-write scripts/generate-image.ts \
  --provider dalle \
  --prompt "pixel art knight character, front view, 16-bit style, transparent background" \
  --output ./assets/knight.png

Batch Generate Animation Frames

deno run --allow-env --allow-net --allow-read --allow-write scripts/batch-generate.ts \
  --spec ./batch-spec.json \
  --output ./generated/

Create Sprite Sheet

deno run --allow-read --allow-write scripts/pack-spritesheet.ts \
  --input ./generated/*.png \
  --output ./sprites/player-sheet.png \
  --columns 4

Core Workflow

Phase 1: Style Definition

Define your art style before generating assets:

1. Choose Art Style: Pixel art, hand-drawn, painterly, or vector 2. Create Style Guide: Document colors, modifiers, and constraints 3. Test Prompts: Generate samples to validate style consistency

{
  "style": "pixel-art",
  "resolution": 64,
  "palette": "limited-16-colors",
  "modifiers": "16-bit, no anti-aliasing, clean pixels"
}

Phase 2: Asset Generation

Generate assets using the appropriate provider:

1. Single Assets: Use generate-image.ts for individual images 2. Batch Assets: Use batch-generate.ts for multiple related assets 3. Iterate: Refine prompts based on results

Phase 3: Post-Processing

Prepare raw AI output for game use:

1. Background Removal: Extract sprites from backgrounds 2. Color Correction: Normalize palette if needed 3. Resize: Scale to exact game resolution 4. Trim/Pad: Remove whitespace, add sprite padding

deno run --allow-read --allow-write scripts/process-sprite.ts \
  --input ./raw/knight.png \
  --output ./processed/knight.png \
  --remove-bg \
  --resize 64x64 \
  --filter nearest

Phase 4: Godot Integration

Prepare assets for Godot import:

1. Pack Sprite Sheets: Combine frames into optimized sheets 2. Generate Import Files: Create .import with optimal settings 3. Configure Animations: Set up SpriteFrames resources

API Provider Selection

ProviderBest ForQualityCostSpeed
DALL-E 3Consistency, high detailExcellent$$$Medium
ReplicateStyle control, variationsVery Good$$Medium
fal.aiFast iteration, testingGood$Fast

DALL-E 3 (OpenAI)

Best for high-quality, consistent results. Excellent prompt following.

--provider dalle --model dall-e-3
  • Sizes: 1024x1024, 1792x1024, 1024x1792
  • Quality: standard, hd
  • Style: vivid, natural

Replicate (SDXL/Flux)

Best for style control and cheaper batch generation.

--provider replicate --model stability-ai/sdxl
  • More model options (SDXL, Flux, specialized)
  • Negative prompts supported
  • ControlNet and img2img available

fal.ai

Best for rapid iteration and testing prompts.

--provider fal --model fal-ai/flux/schnell
  • Fastest inference
  • Good for prototyping
  • Lower cost per image

Prompting by Art Style

Pixel Art

"pixel art [subject], 16-bit style, clean pixels, no anti-aliasing,
limited color palette, retro game sprite, transparent background"

Key modifiers: 16-bit, 8-bit, pixel art, retro, clean pixels, no anti-aliasing

Avoid: realistic, detailed, smooth, gradient

Hand-Drawn / Illustrated

"hand-drawn illustration of [subject], ink lines, watercolor texture,
sketch style, game art, white background"

Key modifiers: hand-drawn, illustration, ink lines, sketch, watercolor

Painterly / Concept Art

"digital painting of [subject], concept art style, painterly brush strokes,
dramatic lighting, game asset"

Key modifiers: digital painting, concept art, painterly, brush strokes

Vector / Flat Design

"flat design [subject], vector art style, clean edges, solid colors,
minimal shading, game icon, transparent background"

Key modifiers: flat design, vector, clean edges, solid colors, minimal

Script Reference

generate-image.ts

Generate a single image from any supported provider.

deno run --allow-env --allow-net --allow-write scripts/generate-image.ts [options]

Options:
  --provider <name>   Provider: dalle, replicate, fal (required)
  --prompt <text>     Generation prompt (required)
  --output <path>     Output file path (required)
  --model <name>      Specific model (optional, provider-dependent)
  --size <WxH>        Image size, e.g., 1024x1024 (default: 1024x1024)
  --style <name>      Style preset: pixel-art, hand-drawn, painterly, vector
  --negative <text>   Negative prompt (Replicate/fal only)
  --quality <level>   Quality: standard, hd (DALL-E only)
  --json              Output metadata as JSON
  -h, --help          Show help

batch-generate.ts

Generate multiple images from a specification file.

deno run --allow-env --allow-net --allow-read --allow-write scripts/batch-generate.ts [options]

Options:
  --spec <path>       Path to batch specification JSON (required)
  --output <dir>      Output directory (required)
  --concurrency <n>   Parallel requests (default: 2)
  --delay <ms>        Delay between requests (default: 1000)
  --resume            Resume from last successful
  --json              Output results as JSON
  -h, --help          Show help

Batch Spec Format:

{
  "provider": "replicate",
  "model": "stability-ai/sdxl",
  "style": "pixel-art",
  "basePrompt": "16-bit pixel art, game sprite, transparent background",
  "assets": [
    { "name": "player-idle", "prompt": "knight standing idle, front view" },
    { "name": "player-walk-1", "prompt": "knight walking, frame 1 of 4" },
    { "name": "player-walk-2", "prompt": "knight walking, frame 2 of 4" }
  ]
}

process-sprite.ts

Post-process generated images for game use.

deno run --allow-read --allow-write scripts/process-sprite.ts [options]

Options:
  --input <path>      Input image path (required)
  --output <path>     Output image path (required)
  --remove-bg         Remove background (make transparent)
  --resize <WxH>      Resize to dimensions
  --filter <type>     Resize filter: nearest, linear (default: nearest)
  --trim              Trim transparent whitespace
  --padding <n>       Add padding pixels
  --color-key <hex>   Color to make transparent (e.g., ff00ff)
  -h, --help          Show help

pack-spritesheet.ts

Pack multiple sprites into a sprite sheet.

deno run --allow-read --allow-write scripts/pack-spritesheet.ts [options]

Options:
  --input <pattern>   Input files (glob pattern, required)
  --output <path>     Output sprite sheet path (required)
  --columns <n>       Number of columns (default: auto)
  --padding <n>       Padding between sprites (default: 0)
  --power-of-two      Force power-of-two dimensions
  --metadata <path>   Output JSON metadata path
  -h, --help          Show help

Output Metadata:

{
  "image": "player-sheet.png",
  "size": { "width": 256, "height": 128 },
  "frames": [
    { "name": "idle", "x": 0, "y": 0, "width": 64, "height": 64 },
    { "name": "walk-1", "x": 64, "y": 0, "width": 64, "height": 64 }
  ]
}

generate-import-files.ts

Generate Godot .import files with optimal settings.

deno run --allow-read --allow-write scripts/generate-import-files.ts [options]

Options:
  --input <path>      Input image or directory (required)
  --preset <name>     Preset: pixel-art, hd-sprite, ui (default: pixel-art)
  --frames <n>        Animation frame count (for sprite sheets)
  --columns <n>       Sprite sheet columns
  --fps <n>           Animation FPS (default: 12)
  -h, --help          Show help

Godot Import Settings

Pixel Art Sprites

Filter Mode: Nearest
Compression: Lossless
Mipmaps: Off
Fix Alpha Border: On

HD Sprites

Filter Mode: Linear
Compression: VRAM Compressed
Mipmaps: On

UI Elements

Filter Mode: Linear (or Nearest for pixel UI)
Compression: Lossless
Mipmaps: Off

Examples

Example 1: Pixel Art Character with Walk Animation

# 1. Create batch spec
cat > character-batch.json << 'EOF'
{
  "provider": "replicate",
  "style": "pixel-art",
  "basePrompt": "16-bit pixel art knight, game sprite, transparent background",
  "assets": [
    { "name": "knight-idle", "prompt": "standing idle, front view" },
    { "name": "knight-walk-1", "prompt": "walking, left foot forward" },
    { "name": "knight-walk-2", "prompt": "walking, standing straight" },
    { "name": "knight-walk-3", "prompt": "walking, right foot forward" },
    { "name": "knight-walk-4", "prompt": "walking, standing straight" }
  ]
}
EOF

# 2. Generate images
deno run --allow-env --allow-net --allow-read --allow-write \
  scripts/batch-generate.ts --spec character-batch.json --output ./raw/

# 3. Process sprites
for f in ./raw/knight-*.png; do
  deno run --allow-read --allow-write scripts/process-sprite.ts \
    --input "$f" --output "./processed/$(basename $f)" \
    --remove-bg --resize 64x64 --filter nearest
done

# 4. Pack sprite sheet
deno run --allow-read --allow-write scripts/pack-spritesheet.ts \
  --input "./processed/knight-*.png" \
  --output ./sprites/knight-sheet.png \
  --columns 5 --metadata ./sprites/knight-sheet.json

# 5. Generate Godot import
deno run --allow-read --allow-write scripts/generate-import-files.ts \
  --input ./sprites/knight-sheet.png --preset pixel-art \
  --frames 5 --columns 5 --fps 8

Example 2: Tileset Generation

# Generate individual tiles
deno run --allow-env --allow-net --allow-write scripts/generate-image.ts \
  --provider dalle \
  --prompt "seamless pixel art grass tile, top-down view, 32x32, game tileset" \
  --output ./tiles/grass.png \
  --style pixel-art

# Process and resize
deno run --allow-read --allow-write scripts/process-sprite.ts \
  --input ./tiles/grass.png --output ./tiles/grass-processed.png \
  --resize 32x32 --filter nearest

Example 3: UI Icons

# Batch generate UI icons
cat > ui-batch.json << 'EOF'
{
  "provider": "fal",
  "style": "vector",
  "basePrompt": "flat design game icon, clean edges, solid colors, transparent background",
  "assets": [
    { "name": "icon-sword", "prompt": "sword weapon icon" },
    { "name": "icon-shield", "prompt": "shield defense icon" },
    { "name": "icon-potion", "prompt": "health potion bottle icon" },
    { "name": "icon-coin", "prompt": "gold coin currency icon" }
  ]
}
EOF

deno run --allow-env --allow-net --allow-read --allow-write \
  scripts/batch-generate.ts --spec ui-batch.json --output ./icons/

Common Issues

API Key Not Found

Error: OPENAI_API_KEY environment variable is not set

Solution: Export the API key before running:

export OPENAI_API_KEY="sk-..."

Inconsistent Style Across Batch

Problem: Generated images have different styles despite same prompt.

Solutions:

  • Use more specific style modifiers
  • Use Replicate with seed parameter for reproducibility
  • Generate more images and select best matches
  • Use img2img with reference image (Replicate)

Background Removal Fails

Problem: --remove-bg doesn't cleanly separate sprite.

Solutions:

  • Add "transparent background" or "white background" to prompt
  • Use --color-key with a specific background color
  • Use more explicit prompts: "isolated on transparent background"
  • Manual cleanup may be needed for complex images

Pixel Art Has Anti-Aliasing

Problem: Generated pixel art has smoothed edges.

Solutions:

  • Add "no anti-aliasing", "clean pixels" to prompt
  • Generate at larger size, then downscale with nearest neighbor
  • Use --filter nearest in process-sprite.ts
  • Post-process with palette reduction

Rate Limiting

Problem: API returns 429 rate limit errors.

Solutions:

  • Increase --delay in batch-generate.ts
  • Reduce --concurrency
  • Wait and retry
  • Use different provider for large batches

Additional Resources

Prompting Guides

  • references/prompting/pixel-art.md - Detailed pixel art techniques
  • references/prompting/hand-drawn.md - Illustrated style guide
  • references/prompting/consistent-characters.md - Character consistency

API Guides

  • references/api-guides/openai-dalle.md - DALL-E 3 API reference
  • references/api-guides/replicate-sdxl.md - Replicate integration
  • references/api-guides/fal-ai.md - fal.ai guide

Godot Integration

  • references/godot-integration/import-settings.md - Import configuration
  • references/godot-integration/animation-setup.md - AnimatedSprite2D setup

Templates

  • assets/prompts/pixel-art-templates.json - Pixel art prompt templates
  • assets/prompts/character-templates.json - Character prompts
  • assets/style-guides/style-guide-template.json - Style guide schema

Limitations

  • API-based only: Requires internet and API keys (no local models)
  • Style consistency: AI may produce variations despite same prompt
  • Resolution constraints: Each provider has size limits
  • 2D assets only: Not for 3D models, textures, or complex animations
  • Background removal: May require manual cleanup for complex images
  • Cost: API calls incur charges, especially for large batches

Related skills

remotion-devRemotion Best PracticesGet Remotion-specific coding guidance that prevents common video rendering mistakes when creating animated React videos.451k4.2k101-skillsAi Video GenerationGenerate videos using 40+ AI models including Veo, Seedance, and others via inference.sh442k665101-skillsAi Image GenerationGenerate images using 50+ AI models including FLUX, Gemini, and Replicate via inference.sh441k665101-skillsAi Avatar VideoGenerate videos featuring AI avatars for product demos, tutorials, marketing, or explainers441k665101-skillsRemotion RenderRender videos programmatically using React components and Remotion framework441k665halt-catch-fireRemotion RenderGenerate high-quality MP4 videos from React code using Remotion inside an AI coding agent.363k665

How it compares

Pick godot-asset-generator over generic image-generation skills when outputs must include Godot 4.x sprite sheets, tilesets, and import configuration.

FAQ

Which image APIs does godot-asset-generator support?

godot-asset-generator supports DALL-E, Replicate, and fal.ai for AI image generation. Developers supply the matching API key such as OPENAI_API_KEY or REPLICATE_API_TOKEN, and the skill prepares resulting images for Godot 4.x import.

What Godot version does godot-asset-generator target?

godot-asset-generator targets Godot 4.x import workflows. It generates sprites, tilesets, UI icons, and animation frames plus import configuration so textures and sprite sheets load correctly in Godot projects.

What runtime does godot-asset-generator require?

godot-asset-generator requires the Deno runtime plus API keys for the chosen image provider. Without Deno or valid credentials, the skill cannot execute its generation and Godot import preparation scripts.

Is Godot Asset Generator safe to install?

skills.sh reports 3 of 3 security scanners passed. Review the Security Audits panel on this page before installing in production.

Generative Mediaagentsautomation
Browse by category
AI & AgentsFrontend & DesignBackend & DataDev ToolsAutomationTesting & ReviewSecurityMonitoring & CloudDocs & Planning
Design & frontend
Design systemsAnimation & motionAccessibility (a11y)CSS & TailwindUI designUXDesign to codeshadcn/uiLanding pagesBest design skills
Most searched skills
find-skillscavemanfrontend-designbrainstormingsystematic-debuggingstop-slopemil-design-engui-ux-pro-maxkarpathy-guidelinesweb-design-guidelinesreact-best-practicesgrill-meimprovemicrosoft-foundryagent-browser
Browse all listings
All agent skillsAll MCP serversAll marketplacesAll plugins

This week in AI coding

Five minutes, every Monday - the tools, releases and tactics for developers.

unsubscribe anytime.