Meowart Game Asset

Quick Access

When you need to determine which command to use, how to write parameters, and where the output will be saved, first read
```
meowart_api.md
```
.
When you need to confirm precise CLI parameters, request structure, polling logic, download logic, or prepare extension scripts, directly read
```
meowart_api.py
```
.
When you need to quickly execute asset generation tasks, first review the "Core Routing Rules" below, then select the specific workflow according to the "Practical Guide" later in the document.
When you need HD non-pixel characters, icons, item packs, or transparent PNGs, prioritize checking "HD Asset Generation"—usually select a template from
```
hd-gen-template-info
```
, then use
```
hd-gen-run
```
.
When you need game BGM, theme songs, or scene music, prioritize checking "Music Generation"—usually start with the prompt-only mode of
```
music-run
```
.
When you need short sound effects such as UI clicks, attacks, pickups, environment sounds, or skill sounds, prioritize checking "Sound Effect Generation" and use
```
sound-run
```
/
```
sfx-run
```
.
When you need tileable textures, terrain textures, terrain tilesets, or dual-grid terrain transition maps, prioritize checking "Texture / Tileset Generation" and use
```
texture-gen-run
```
or
```
tileset-gen-run
```
.
```
meowart_api.py
```
comes with automatic bootstrap updates by default: before executing commands normally, it will check the remote manifest, and if a new version of the runner is found, it will verify the SHA-256 and execute the cached version. Use
```
bootstrap-status
```
for troubleshooting; pass
```
--no-bootstrap
```
or set
```
MEOWART_BOOTSTRAP=0
```
to disable it.

Core Routing Rules

Whenever the user's clear goal is pixel sprites / small icons / props / characters / monsters / NPCs, default to using
```
pixel-gen-template-info
```
to select a template first, then use
```
pixel-gen-run
```
. Trigger terms include: pixel art, pixel, sprite, spritesheet, character, monster, NPC, prop, item, icon, small UI icon, game asset, transparent material.
For clear requests of non-pixel HD characters, HD icons, HD item packs, or transparent HD assets, use
```
hd-gen-template-info
```
+
```
hd-gen-run
```
and do not fall back to the general
```
gemini-generate-content
```
.
For clear requests of single tileable textures / material tiles / terrain textures, use
```
texture-gen-run
```
. For clear requests of terrain tilesets / dual-grid 15 tiles / grass-water transition maps, use
```
tileset-gen-run
```
. Only use
```
pixel-gen-run
```
when "tile" refers to ordinary small props or pixel small icons.
For clear requests of short sound effects, SFX, UI clicks, attacks, explosions, pickups, or ambient sound clips, use
```
sound-run
```
. Use
```
--sound-pack
```
for a set of sound effects, and
```
--variants
```
for multiple versions of the same sound effect.
Do not automatically switch to
```
gemini-generate-content
```
just because the request includes "background", "scene", "character", or "free-style exploration". If the final asset needs to maintain a pixel grid,
```
pixel-gen-run
```
is the default entry.
```
gemini-generate-content
```
is only used for non-pixel concept art, HD/illustration assets, large complete background concept drafts, overall UI visual drafts, or when there is no suitable pixel template and the user accepts fallback.
When pixel assets fall back to general generation, the result must be treated as a draft: first use
```
gemini-generate-content
```
to generate a white-background/fixed-size image, then use
```
pixelate-run
```
to converge to pixel style, then use
```
remove-background-run --method pixel
```
to remove the white background, and finally verify the size, transparent channel, and edge clarity.
If the user explicitly states "no template", you can skip
```
pixel-gen-run
```
, but still follow the fallback chain above; do not directly use the general generation result as the final pixel asset.

AI Image Generation Basics

Basic Principles:
- Principle 1: The style of each part of the output image can be highly consistent, but it may not match the input image (each part of the output is essentially on the same image, while the input has been transformed by a deep network).
- Principle 2: VLMs usually have some default output sizes. If the input size does not match these sizes, implicit deformation (scaling, cropping) may occur, leading to unexpected situations. Try to avoid this.
Common Methods: Ensure the input and output sizes are the same, and place the reference image and generated image on the same canvas. This not only strictly controls style consistency but also accurately modifies specific areas of the image.
- Blank Space Generation: Place several reference objects in the reference image and leave blank spaces, then guide the large model to generate new objects in the blank spaces via prompts. This ensures that the reference objects and generated objects are on the same canvas. Based on Principle 1, this ensures the style of the generated objects is strictly consistent with the reference objects.
- Batch Generation: Generate N objects at once. Since these N objects are on the same canvas, based on Principle 1, their styles are guaranteed to be consistent.
- Outline Generation: First use Python or ask the user to mark the area to be modified in the image, then guide the large model to modify the specified area or generate an image of the specified outline via prompts. This can strictly control the shape, position, size, etc. of the generated object (try to ensure input and output are standard sizes; otherwise, implicit offset will cause inaccurate marking).

Canvas Size Considerations

Input and output sizes are extremely important parameters when using AI image generation!

Recommended Sizes

The following sizes can be used as the preferred standard target sizes when calling Nano Banana. When calling image generation tools, try to ensure the input and output image sizes are consistent and meet the following dimensions.

Aspect Ratio	1k	2k
`1:1`	`1024 x 1024`	`2048 x 2048`
`3:4`	`896 x 1200`	`1792 x 2400`
`4:3`	`1200 x 896`	`2400 x 1792`
`2:3`	`848 x 1264`	`1696 x 2528`
`3:2`	`1264 x 848`	`2528 x 1696`
`9:16`	`768 x 1376`	`1536 x 2752`
`16:9`	`1376 x 768`	`2752 x 1536`
`1:4`	`512 x 2064`	`1024 x 4128`
`4:1`	`2064 x 512`	`4128 x 1024`
`1:8`	`352 x 2928`	`704 x 5856`
`8:1`	`2928 x 352`	`5856 x 704`
`9:21`	`336 x 792`	`672 x 1584`
`21:9`	`792 x 336`	`1584 x 672`

Best Practices

Unless the official API documentation explicitly states "supports arbitrary input sizes without implicit scaling/cropping issues", the best practice is to first adjust the input image to one of the model's standard target sizes.
For partial modification tasks instead of full-image redrawing, "input size = output size" should almost be the default premise, and both should be standard sizes of Nano Banana.
If the original image is not a standard size, decide whether to pad or crop it first; do not leave this decision to the model's implicit processing.
If multiple rounds of editing are needed later, fix the canvas size in the first round and keep it consistent in all subsequent rounds. This makes it easiest to maintain alignment and pixel stability.
Sprite Generation: Default to using
```
pixel-gen-run
```
from the MeowArt API. Generated sprites usually have a white or transparent background. Only when falling back to general generation do you need to explicitly specify the sprite background color as white in the prompt, then proceed with
```
pixelate-run
```
and background removal after generation.

Pixel Style Considerations

Why Pixel Art is More Sensitive

Pixel art essentially relies on a strict pixel grid. Even slight scaling of ordinary images is often acceptable to the naked eye, but once pixel art is incorrectly scaled, edges, color blocks, and pixel grains will be damaged.
When large models perform implicit scaling, they usually use continuous interpolation such as bilinear sampling (compatible with mainstream HD images), but this clearly damages the clear pixel boundaries of pixel art.
If pixel art must be scaled, the principle is to use nearest-neighbor sampling instead of bilinear or other smooth interpolation.
Therefore, the safest approach for pixel assets is to first adjust the input to the target size, then require the output to maintain the same size to ensure no scaling occurs.

Best Practices for Pixel Style

Pixel style images should not be stretched; only resize by integer multiples and proportionally, and must use nearest-neighbor sampling.
Pixel style sprites, such as characters, items, and icons, are usually small square sizes like
```
32x32
```
,
```
64x64
```
,
```
128x128
```
which are
```
2^n
```
, so
```
1K
```
and
```
1024 x 1024
```
are the optimal solutions for sprite generation.
If generating based on a reference image, the best approach is to first pad the reference image to a suitable
```
2^n
```
square, then scale it proportionally to
```
1024 x 1024
```
using nearest-neighbor sampling, send it to Nano Banana for generation, and output the same
```
1024 x 1024
```
(2K is 2048). After generation, scale it back proportionally to the target sprite size using nearest-neighbor sampling. In many cases, this can result in "perfect pixel" results with strict alignment and clean edges even without relying on perfect pixel algorithms.
At the same time, since pixel blocks are naturally
```
1:1
```
squares, it is easier to maintain high-quality pixel blocks in a
```
1:1
```
canvas.
For scenarios like background generation, it is best to generate an image close to the target size at once, then crop it slightly to reduce pixel compression caused by scaling.

MeowArt API Related Documents

```
meowart_api.md
```
: Quick instructions for daily use, focusing on the most commonly used command entries, authentication methods, and typical call examples. Suitable for directly checking "which command to use and how to write parameters" after clarifying requirements.
```
meowart_api.py
```
: Script encapsulation for actual MeowArt API calls, including parameter definitions, request sending, polling, downloading, and output directory handling logic for each sub-command. When you need more fine-grained control of parameters, confirm underlying behaviors, or extend new calling methods, you should read this script directly.
Bootstrap only updates the CLI runner; if the trigger description and routing instructions in
```
SKILL.md
```
change, users still need to update the skill and restart Codex for the current agent to stably recognize the changes.

Output Directory Rules

When the user requests a batch of assets or a unified location, first create a dedicated root directory for the current task, such as
```
./.meowart-test/<task_slug>/
```
or the project-agreed
```
assets/generated/<task_slug>/
```
; then explicitly pass subdirectories under this root directory as
```
--output-dir
```
for all generation, post-processing, and animation commands.
```
--work-dir
```
is the command log/metadata directory;
```
--output-dir
```
is the directory for assets such as images, animations, and sprites. The directory containing only
```
meta.json
```
is usually not the final asset directory.
Query commands like
```
credits-balance
```
and
```
pixel-gen-template-info
```
usually only generate JSON; commands like
```
gemini-generate-content
```
and various
```
*-run
```
commands will download resource files.
```
hd-gen-template-info
```
only queries templates;
```
hd-gen-run
```
will submit HD generation tasks, poll for completion, and download transparent PNG or asset pack outputs.
```
sound-run
```
/
```
sfx-run
```
will download audio files such as
```
mp3
```
/
```
wav
```
/
```
ogg
```
; if
```
--sound-pack
```
or
```
--variants
```
is used, there will usually be multiple audio files.
```
texture-gen-run
```
will download a single texture PNG, and return a four-way seamless texture when the default
```
--self-loop
```
is enabled;
```
tileset-gen-run
```
will download a dual-grid tileset PNG.
The prompt-only mode of
```
music-run
```
usually only saves
```
submit_response.json
```
and
```
job_response.json
```
; audio files like
```
mp3
```
are only downloaded when
```
--audio-generate
```
is passed and audio generation is successful.
After the task is completed, perform a quick check using image size/frame count to confirm that key files are actually saved in the unified directory specified by the user.

Practical Guide

Align Frequently: Before generating images each time, try to confirm the requirements first. After generation, let the user confirm the quality (or confirm it yourself). It is best not to start large-scale generation immediately; instead, select one or two templates first.
Document Writing: During development, communication, and generation, it is best to continuously update documents, such as writing in the
```
AGENTS.md
```
file in the project root directory, opening a section to record art-related information, such as art style, asset requirements (canvas size, sprite size, etc.), asset distribution, and generation process records. This can improve the efficiency and consistency of overall art development.

Scene Generation

Non-pixel game backgrounds, scene concept art, and atmosphere drafts usually prioritize using the general
```
gemini-generate-content
```
.
For pixel backgrounds, first determine the final deliverable: if it is a single tileable terrain texture, prioritize using
```
texture-gen-run
```
; if it is a terrain transition tileset, prioritize using
```
tileset-gen-run
```
; if it is splittable scene materials, prop sets, small UI icons, or character-related assets, prioritize using
```
pixel-gen-run
```
to select a template for generation; if it is a large complete scene concept draft with no suitable template, use
```
gemini-generate-content
```
to generate a draft, then use
```
pixelate-run
```
to converge to the final pixel-style draft.
Fixed-size non-pixel backgrounds: Directly use general generation mode, and clearly specify the style, subject, and camera relationship in the description. The most important thing here is to first select an aspect ratio close to the final canvas, such as
```
16:9
```
, so that only slight cropping is usually needed later, and no large-scale scaling is required.

If the user explicitly specifies sizes like

2K

16:9

, do not only write the size in the prompt; also pass

generationConfig.imageConfig

, for example:

bash

python3 skills/game-assets/meowart_api.py gemini-generate-content \
  --text "Generate a 2K 16:9 game background..." \
  --generation-config '{"responseModalities":["TEXT","IMAGE"],"imageConfig":{"aspectRatio":"16:9","imageSize":"2K"}}' \
  --output-dir ./outputs/background_2k_16x9

After generation, you must check the actual size;

16:9 2K

is expected to be

2752 x 1536

Infinite Loop Backgrounds: First generate a normal background image (it is best to specify in the prompt in advance whether this is a background for a horizontal or vertical game; otherwise, the aspect ratio or content of the image may be too poor to be transformed into a self-looping background). If pixel art is required in the end, first generate it according to the above pixel background rules or converge it with
```
pixelate-run
```
, then call
```
self-loop-run
```
to convert it into a horizontally or vertically seamless loop background for scroll scenes or repeated tiled textures. Pass
```
--mode full
```
for four-way continuity.

Character / Prop / Icon / Sprite Generation

For resources such as characters, monsters, props, and icons, first check available templates via
```
pixel-gen-template-info
```
. If conditions allow before selecting a template for generation, select several alternatives, download the images from
```
preview_image_url
```
, and display them directly to the user in the conversation window to align styles.
The main differences between different templates lie in art style, single image size, and the number of assets that can be generated in batches. In principle, templates are universal and can generate any content via prompts; but selecting a more suitable template will significantly improve result certainty and make it easier to maintain art consistency across the project.
Template Selection Recommendations:
- Items, icons, small animals: Prioritize the
```
food
```
  and
```
object
```
  templates (these two are the most aesthetically pleasing and universal), which usually generate
```
8
```
```
64x64
```
  pixel objects at a time.
- Characters, protagonists, monster characters: Prioritize the
```
pixel_char
```
  template, which usually generates
```
2
```
```
128x128
```
  objects at a time.
- Specific template names and batch quantities are subject to the return of
```
pixel-gen-template-info
```
  ; if the server template list changes, adjust according to the returned information first.
Use
```
pixel-gen-run
```
for formal generation. Templates usually come with their own style, so there is no need to describe the style in detail; simply describe the appearance. When generating multiple contents in batches, clearly state the type of each object (e.g., folded-eared cat, Persian cat...).
For batch templates,
```
requirement
```
is closer to "what to generate in this batch" rather than the complete prompt directly sent to the model. The system will combine the template's own
```
target_count
```
to package it into the actual generation prompt. For example,
```
cat_2
```
defaults to generating
```
8
```
sprites, so writing "cats" will be interpreted as "generate 8 cats"; if you want more differentiation in this batch of results, you should directly write a list of variants, such as "calico, orange tabby, tuxedo, Siamese, British Shorthair, American Shorthair, tabby, pure white cat".
When generating in batches, you can either describe the appearance of multiple objects separately in
```
requirement
```
or briefly describe the overall requirement in one sentence and let the server agent refine it. Try to generate the maximum number supported by the template at once, as there is usually no difference in price and quality for the same template, and generating more makes it easier to select.
For pixel-gen templates, constraints that are already implied by the template itself, such as "white background" and "pixel style", usually do not need to be repeated in
```
requirement
```
unless the task really needs to override the template's default behavior.
For side-scrolling games or Vampire Survivors-style games, prioritize templates with
```
direction
```
, and use side views like
```
left
```
or
```
right
```
which are more suitable for game performance; if using a normal template, clearly specify the character's perspective in the prompt.
The current set of templates mainly targets Pixel-style Sprites; if you want to create HD anime-style, thick-paint, or illustration-style characters, you can only use the general
```
gemini-generate-content
```
to generate them first, then perform manual matting or post-processing.
If the user explicitly states "no template" but wants pixel characters, use general image generation to generate a single character on a white background, then execute the following steps in order:
```
pixelate-run
```
to converge to pixel style,
```
remove-background-run --method pixel
```
to remove the white background, and finally verify that the PNG is
```
RGBA
```
and the size meets integration requirements. Do not manually pass
```
--pixel-size
```
by default; prioritize letting the server estimate it automatically; only specify it when the target size is clear or parameters have been verified, for example,
```
--pixel-size 16
```
may be closer to a
```
128x128
```
sprite than
```
--pixel-size 8
```
for the same input.
Character protagonists, bosses, and characters with stronger standing drawing styles are usually more suitable for large-size templates that generate only
```
1
```
to
```
2
```
assets at a time. Batch enemies, batch props, icons, etc., are more suitable for templates that generate about
```
8
```
assets at a time to improve efficiency and ensure style consistency across the batch of resources.
Sprites generated by different templates may have different sizes; pay attention to unified resizing when integrating into game code. Pixel art can only use nearest-neighbor sampling and should maintain integer scaling as much as possible, such as
```
2x
```
or
```
3x
```
; do not use non-integer scaling like
```
0.85x
```
or
```
1.2x
```
, as this will damage the pixel texture.

HD Asset Generation

For non-pixel HD characters, props, icons, item packs, and transparent PNG assets, use
```
hd-gen-template-info
```
to view templates, then use
```
hd-gen-run
```
to generate.
The
```
hd_gen_grid_2x2
```
template is suitable for characters or a small number of HD assets, while the
```
hd_gen_grid_4x4
```
template is suitable for batch icons / sprite packs; specific details are subject to
```
workflow_id
```
,
```
agent_type
```
,
```
output_size
```
, and
```
supported_config_keys
```
from
```
hd-gen-template-info
```
.
If the template supports direction, use
```
--template-config '{"direction":"front"}'
```
,
```
left
```
,
```
right
```
,
```
back
```
, etc.; if the template supports quantity, put
```
target_count
```
into
```
--template-config
```
.
HD assets will be processed with HD background removal by default.
```
--hd-remove-bg-mode batch
```
is usually faster, while
```
single
```
is more suitable for retrying when batch mode fails or edge quality needs per-image optimization.

Typical Commands:

bash

python3 skills/game-assets/meowart_api.py hd-gen-template-info
python3 skills/game-assets/meowart_api.py hd-gen-run \
  --template-name "hd_char_1" \
  --requirement "A cheerful fantasy alchemist girl with green cloak" \
  --template-config '{"direction":"front"}' \
  --output-dir ./outputs/hd_alchemist

Texture / Tileset Generation

For single tileable textures, terrain materials, walls, water surfaces, magma, wooden boards, stone blocks, etc., use
```
texture-gen-run
```
. Self-loop post-processing is added by default, outputting a four-way seamless texture of about 512x512.

texture-gen-run

can accept reference texture names:

--texture-name "water surface"

, and you can pass multiple names repeatedly or as a comma-separated list. Current built-in references include

water surface

magma with bubbles

brick wall

wooden board

broken small stones

metal plate

solidifying lava

, and

volcanic rock with lava texture

If you just want to quickly generate a normal texture draft, you can omit
```
--texture-name
```
, and the backend will use three default references. To reduce costs or only need non-continuous drafts, pass
```
--no-self-loop
```
.
For terrain transition tilesets, dual-grid 15-tile atlases, and mixed edges of foreground/background such as grass/water/magma, use
```
tileset-gen-run
```
. Optionally pass
```
--foreground-texture
```
and
```
--background-texture
```
to make the tileset match existing textures.

Typical Commands:

bash

python3 skills/game-assets/meowart_api.py texture-gen-run \
  --prompt "mossy cracked stone floor" \
  --texture-name "brick wall" \
  --texture-name "broken small stones" \
  --output-dir ./outputs/mossy_stone_texture

python3 skills/game-assets/meowart_api.py tileset-gen-run \
  --prompt "lush grass foreground plus shallow blue water background" \
  --output-dir ./outputs/grass_water_tileset

Animation Generation

For actions such as character or object attacks, deaths, movements, jumps, and bounces, usually use
```
animate-run
```
.
Outputs usually include
```
gif
```
,
```
webp
```
, and
```
png
```
formats; the
```
png
```
format generally has the background removed and can be directly used as a sprite sheet in games.
The optimal order is usually not to create animations at the beginning, but to first create static sprites, verify that the size, perspective, art style, collision box, and gameplay are correct in the game, then enter the animation stage.
The reason for this is that
```
animate-run
```
is relatively slower and more expensive, making it more suitable as the final step before asset finalization rather than the main process for repeated trial and error in the early stage.
The animation interface may occasionally return temporary
```
502
```
errors or polling exceptions: if
```
api_job_id
```
is printed during submission, use
```
animate-poll --api-job-id <id>
```
to review and download; if no job id is obtained during submission, directly retry
```
animate-run
```
.

Sound Effect Generation

For short sound effects, UI feedback, attacks, hits, pickups, explosions, magic, and ambient sound clips, use
```
sound-run
```
(aliases:
```
sfx-run
```
/
```
sound-effect-run
```
). It uses the backend
```
elevenlabs_generator
```
workflow, which first optimizes the sound effect prompt, then generates audio.
The default duration for a single sound effect is
```
--duration 2
```
seconds; it supports
```
0.5
```
or integers from
```
1
```
to
```
10
```
seconds. Pass
```
--loop
```
for loopable short ambient sounds.
Pass
```
--sound-pack --count N
```
for a set of different sound effects; pass
```
--variants --count N
```
for multiple versions of the same sound effect for selection.
```
--sound-pack
```
and
```
--variants
```
cannot be used at the same time.
Peak volume normalization is done by default, making the output more suitable for direct integration into games; if you want to retain the original loudness, pass
```
--no-normalize-volume
```
.
If the backend has no ElevenLabs key configured, you can temporarily pass it via
```
--provider-api-key
```
, but it is more recommended to configure it via backend environment variables to avoid the key entering command history.

Typical Commands:

bash

python3 skills/game-assets/meowart_api.py sound-run \
  --prompt "soft wooden UI button click for cozy pixel RPG" \
  --duration 1 \
  --output-dir ./outputs/ui_click

python3 skills/game-assets/meowart_api.py sound-run \
  --prompt "8-bit fantasy combat sound pack: sword slash, shield block, coin pickup, potion drink" \
  --sound-pack \
  --count 4 \
  --duration 1 \
  --output-dir ./outputs/combat_sfx_pack

Music Generation

For exploring directions of game BGM, scene music, and theme songs, usually use
```
music-run
```
. By default, it does not generate audio but only generates structured English music descriptions, including
```
name
```
,
```
summary
```
, and
```
timestamps_detail
```
, which is suitable for letting users confirm the music direction first.
For quick preview, use
```
music-run --audio-generate --demo
```
, which will call 30-second demo audio generation and download the returned audio file. For formal 3-minute music, use
```
--audio-generate
```
without
```
--demo
```
to avoid high costs from repeated trial and error in the early stage.
```
--prompt
```
can be in Chinese or English; if there are game screenshots, scene images, or reference images, you can repeatedly pass
```
--reference-image ./scene.png
```
to let the music prompt runner generate descriptions combined with the scene atmosphere. If only reference images are passed without prompts, the server will generate music directions based on the reference images.
The default music target is loop-friendly, suitable for BGM integration. The prompt should still clearly specify usage scenarios, emotions, rhythms, instruments, vocal restrictions, etc., such as "village daytime market, warm, flute and kalimba, no vocals, loopable".
Focus on
```
result.name
```
,
```
result.summary
```
, and
```
result.timestamps_detail
```
in the output results. For audio mode, also check
```
result.audio_path
```
,
```
metadata.model
```
,
```
metadata.audio_bytes
```
, and the size of the locally downloaded
```
mp3
```
file.
When you have an existing task id, use
```
music-poll --api-job-id workflow-music_generator-...
```
to review and download audio. When generation fails or times out, first check
```
job_response.json
```
and
```
meta.json
```
instead of blindly resubmitting formal audio tasks.

UI Generation

Currently, there is no true end-to-end UI generation interface in the tool, but a usable process can be combined via general image generation and other APIs. General image generation here is only suitable for overall UI visual drafts; if the user wants pixel UI small icons, button sprites, inventory grid, and other independent pixel assets, still follow the core routing rules and prioritize using
```
pixel-gen-run
```
.
Step 1: First capture a real game screen.
Step 2: Use
```
gemini-generate-content
```
for general generation, such as asking the model to "add a character status bar UI in the top-left corner of this game screen, including health, experience, avatar, etc., and keep the overall art style consistent".
Step 3: After obtaining the visual draft, there are generally two routes.
- Programming Replication: Replicate the UI via code based on the visual draft. This route is more controllable, and you can show the user whether the UI meets requirements before generation.
- Extract Non-Pixel UI PNG Assets: Continue using general image generation, changing the prompt to "Extract the character status bar UI in the top-left corner of the screen onto a white background, delete all other backgrounds, characters, and UI elements, only keep the character status bar, and maintain the white background". After obtaining the result, call
```
remove-background-run
```
  to remove the white background; finally, combine cropping or manual size adjustment to get non-pixel UI PNGs that can be directly used in games.

game-assets

NPX Install

Tags

SKILL.md Content (Chinese)

Meowart Game Asset

Quick Access

Core Routing Rules

AI Image Generation Basics

Canvas Size Considerations

Recommended Sizes

Best Practices

Pixel Style Considerations

Why Pixel Art is More Sensitive

Best Practices for Pixel Style

MeowArt API Related Documents

Output Directory Rules

Practical Guide

Scene Generation

Character / Prop / Icon / Sprite Generation

HD Asset Generation

Texture / Tileset Generation

Animation Generation

Sound Effect Generation

Music Generation

UI Generation