Voidless

Outline a sprite on a transparent background, like the Sprite Outline tool on voidless.dev/tools: colour, thickness, outside (the canvas grows by thickness + 2 px a side, as on the site, unless expand is false) or inside (the sprite's own edge pixels), 8-connected (rounded) or 4-connected (blocky) corners. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Add items to an existing asset set (from generate_asset_set), reusing everything it was made with: its view, style preset, style words, palette and style sheet. Or redraw_failed: true draws again, on a small sheet in the same style, just the pieces that failed their view check or were not cut out. Same price: 20 a sheet + 10 a cut; estimate_only shows it first. New pieces get world_height in the same reference character's heights (give size for each new item whose size matters: a new sheet has no reference character on it to measure against).

Animate a rigged 3D model. Either a ready-made move (free; characters: idle, walk, run, jump, attack, punch, kick, wave, hurt, death, cast, dance; four-legged animals: idle, walk, run, jump, attack, sit, hurt, death), a move copied from another of the user's rigged models (free: from_id + from_animation), or a description of any motion ('wag its tail', 'open the lid', 20 credits). Returns the clip, a GLB of the skeleton's motion that plays on the rigged model.

Animate one sprite into a single 16-frame clip from a description of the motion. Only for one clip: several facings of one character (its rotation views, one action in every direction) or several moves go through generate_animation_set, which decides room and size once for every facing so they come out one size; separate animate_sprite calls per facing do not match. 15 credits; 25 for a 1024 HD image (drawn at 1080P), 30 for a looping walk/run on a 1024 HD image (walk, stroll, march, sneak, tiptoe, patrol, run, jog, sprint, dash or a charge forward, ending on its start frame: a 2 s clip, played at its own pace).

Get the result of a generation that was still running when its tool returned (the tool said 'Still generating' and gave a job). Call it about a minute later; if it is still running, wait and call again. Never re-run the original tool instead: that makes and charges a second one. Free.

Make a sprite or a short animation made ANYWHERE (another AI tool, an artist, a screen recording) game-ready with Voidless's own clean-up: background removed with stray pieces checked (sparks and dust kept, smudges removed); pixel art put on a real pixel grid with one palette and stray pixels fixed. A 1-5 s video comes back as 16 frames: kind 'loop' cuts the cleanest loop (walk, run, idle), 'once' keeps the whole move (attack, jump). Saved to the user's library. Give the file as a public URL (best for videos) or base64. 1 free run a day (10 on Voidless+), then 1 credit an image, 2 a video. For a quick pixel-art version of an already clean image, pixelate_image is enough.

Grade a sprite, tile or scene to dawn, day, dusk and night, like the Day/Night Palette tool on voidless.dev/tools. Each colour maps to exactly one new colour, so pixel art keeps its palette size, and the reply lists every from→to pair per time of day: a palette swap an engine can apply at runtime. Optional: keep bright saturated colours lit at night (windows, torches), and a looping day-cycle GIF. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Downscale big art or AI art to a target pixel size without mush, like Smart Downscale on voidless.dev/tools. Each output pixel is one clean colour for its cell: k-centroid (default) runs k-means with k=2-3 on the cell's pixels in OKLab and takes the biggest cluster's centre, so outlines and fills don't blend; dominant takes the cell's most common colour (only colours the input has); nearest takes the centre pixel. Mostly transparent cells become transparent. Target by width (and optionally height) or by factor; optional colour limit after. For AI pixel art drawn on a hidden grid, where the size should be detected rather than chosen, the Pixel Art Fixer on voidless.dev/tools finds the grid. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Edit an existing image asset with an instruction (change colours, add a hat, fix a detail…). The edit is added as a new frame; the original stays. 5 credits.

Make a Godot 4 SpriteFrames resource (.tres) and the sheet PNG it references, the same files as the Godot Exporter on voidless.dev/tools: one AtlasTexture per frame, named animations with fps and loop. Give frames (packed into a grid sheet) or a sheet (kept as is, grid auto-detected unless given). Each animation picks frames by index (frames or first/last) or brings its own images; with no animations every frame plays as "default". Save the PNG as .png in the folder the .tres names. For a Voidless character give asset_id: alone it exports every clip of the asset (named as in get_asset); or give each animation's frame_id (from get_asset; -1 = the base image, image_index picks one rotation view), or just a name matching one of its frames, or frames/images that are its image keys. Their images, sprite_scale and feet come from the asset, and the export puts every animation at ONE pixel scale with the feet on ONE point (video clips are drawn ~0.57x the base, so mixing them with rotations or the base otherwise changes the size). It returns the world height, px per world unit and the node scale/offset to use (_scale.json, also in the .tres metadata): set the AnimatedSprite2D's scale to node_scale (unit_px / px_per_unit) and offset as given, the same unit_px for every character, instead of guessing sizes. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Continue an existing video asset from its last frame. 15 credits per second.

Pull the colour palette out of an image, like the Palette Extractor on voidless.dev/tools. Up to max_colors every exact colour is listed with its pixel count; over it the colours are reduced to max_colors in OKLab (median cut refined by k-means), by default snapped to colours the image really has. Sorted by hue (greys first, then hue families dark to light), luminance or frequency. Returns the swatch PNG and, as text, the palette in GIMP .gpl (Aseprite, GIMP, Krita), .hex (Lospec), JSON with counts, and Adobe Swatch Exchange .ase as base64 (decode it to a binary .ase file). Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Cut an image into its separate pieces. Two uses: (1) a sheet of game items (characters, props, trees...) into one NEW asset per item (the default, save_as 'assets'): each item at its own proportions, framed on a square at the sheet's size (1024 for a 2048/4k asset sheet from generate_image, cut from the full-resolution sheet) like a generated sprite (filling the frame), named after the item, a character or an object, in the sheet's projects and style. Those are generated images like any other: rotate_sprite, animate_sprite, generate_animation_set and resize_sprite all take them; (2) a character sprite into body parts (head, torso, arms, legs...) as 'layer' frames on that asset, for rigging or cut-out animation: pass save_as 'frames'. 10 credits either way. Frames: call get_asset afterwards for their ids.

Mirror every right, up-right and down-right animation on an asset that has no left twin into one (walk-right -> walk-left). The 8-way turns draw the left side as a mirror of the right, so animate the right-facing turns and flip for the rest. Free (no model call). One-sided details swap sides.

Generate a 3D model (GLB) from a prompt. 45 credits (game-ready) or 15 (lq draft).

Generate several animations in one job, one clip per animation, all run in parallel. For several facings of one character (its rotation views) use this, not one animate_sprite call per facing: the set decides room and size once for every facing, so they come out one size. Ways to use it:

1. A PRESET on one or more sprites: platformer-character (idle, walk, run, jump, attack-1, death, hurt) or a top-down set (topdown-walk/run/dash/attack: 8 directions; topdown-idle: 4). Every sprite gets EVERY action of the preset: topdown-run on one image makes all 8 runs (8 clips), not one. For one clip, pass no preset and type the action (way 3).

2. A PRESET across an 8-way rotation set: one item per facing, {assetId, frameIndex:, imageIndex:i} where i is the facing's position in the frame's facings list, and every facing gets its own directional clip (walk-left from the left-facing image, …). If the facings list has no 'down' (the sprite was drawn facing the camera), add {assetId, base:true} as 'down'. If it already has 'down' (a side-view sprite), use only the rotation's own images: the base is the side view, not the front. For topdown-idle pick only the 4 cardinals (down, right, up, left). The left, up-left and down-left clips are mirrored from their right-side twins in the same rotation set, for free; set flipFacings false to animate them too.

3. No preset, a typed action: one clip per image. A list of actions makes one clip per action (up to 6): 'name: description' separated by semicolons names each clip (e.g. 'attack-2: an overhead slash; block: raise the sword to guard'); for one image a plain 'idle, run, jump' also works. Several actions on several images: every image gets every action. Cost: 15 credits per clip, 25 per clip of a 1024 HD image (drawn at 1080P), 30 per looping walk/run clip (walk, stroll, march, sneak, tiptoe, patrol, run, jog, sprint, dash, a charge forward) of a 1024 HD image; mirrored clips are free and clips that fail are refunded. Clips that come back to their start (idle, walk, run, attack, jump, hurt, dash) end on their own first frame, so they loop; one-off clips such as a death do not. Clips are added to their source asset as frames named after the action. Price check: without expectedCost this only shows the plan (the clips it would make and the total) and charges nothing; show it to the user, then call again with expectedCost set to that total. A plan that would charge anything else is refused, with nothing charged.

Make a whole matching game art set in the game's CAMERA VIEW: characters, props and tiles drawn on 2048 GPT-Image 2.6 sheets, cut into one asset per item, each tagged with the view's dimension and facing so rotate_sprite and the animation tools use the right angle. view: 'platformer' (side profile facing right, eye level), 'topdown' (classic RPG, ~45° camera, characters head-on and symmetrical), 'topdown-overhead' (straight down), 'isometric'. Items are planned onto sheets (about 3-4 characters, 4-6 objects or 3 tall props a sheet; the first sheet, or style_asset_id, is the style every later sheet copies at full resolution). Cost: 20 a sheet + 10 a cut; pass estimate_only to see the plan and price first. Every piece gets a free view check (head-on for top-down, a profile for platformer) and failures are reported with a redraw offer; nothing else is spent (no rotations or animations). Voidless+ only. Returns set_id: add_to_asset_set adds to it later. Every piece gets a world_height in heights of the set's reference character (the first humanoid, or the item marked reference), measured on the sheet before the cut-outs are reframed, or the item's own size when given. In a game, size every piece from world_height and the export's scale data (export_godot_spriteframes with asset_id), never by guessing from the image size: all cut-outs are framed to the same pixel height.

Generate a game sprite/asset image. Infer every field from the request: art STYLE, colour PALETTE, asset TYPE, output SIZE and PERSPECTIVE; for characters also facing/pose/bodyType. Leave model out unless the user names one: the server then picks by size (flux2-klein, 1 credit, up to 64 px; gpt-image-2.5, 3 credits, from 96 px). Costs by model: flux2-klein 1, flux-juggernaut 1, seedream-5-flash 10, gpt-image-2.5 3, gpt-image-2.6 10, retro-diffusion 10, nano-banana-2 15 credits (a reference image makes it 2 and uses flux2-klein). ASSET SHEETS: type 'artwork' + model 'gpt-image-2.6' + size 2048 (20 credits) or '4k' (30 credits) draws one big picture holding a whole matching set (e.g. 'nine fantasy RPG items in a grid, clear space between them, plain light background') at full resolution; cut it into one asset per item with extract_parts save_as 'assets' (each cut-out a 1024 sprite). Call it once per request and show the result; ask the user before generating again (each call spends credits). Every image is drawn in exactly one of Voidless's fixed style presets, and the result says which one was used and why. Model 'free' is not AI: procedural pixel art drawn by code (item icons and loot sheets, RPG characters in 8 directions with animations, trees, plants and rocks), instant, 0 credits; use it only when the user asks for free or procedural pixel art or a quick placeholder, never by default (options in free).

Generate a music track. 10 credits.

Generate a short sound effect (coin pickup, sword hit, footstep…). 5 credits.

Make a pixel-art visual effect (explosion, slash, sparkle, magic burst…) procedurally, from a prompt or a recipe a previous call returned: a sprite sheet PNG, an animated GIF, atlas and Aseprite JSON, a Godot SpriteFrames .tres and the recipe (pass it back with changes to tweak the effect). The effect is also saved to your library (free, private; save: false to skip): the reply gives its asset id and cdn.voidless.dev URLs for the sheet, GIF and frames, which the other tools take as inputs. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Generate a short video clip (trailer shot, cutscene, animated background) from a prompt and 1–7 reference images. 15 credits per second.

List the animation-set presets (platformer-character, topdown-walk/run/dash/attack/idle) with the actions each one makes, and the credit cost per clip. Free.

Show one asset with every frame: frame ids, types (animation, rotations - 8-way, edit - text, layer…), names, facings and image keys. Frame ids are what frameIndex/items/frameId take elsewhere; image keys are what referenceFile and end_frame take, on this asset or any other of yours. Long clips show their first and last key; pass frameId to list every key of that frame. Each key downloads at its exact pixels from https://cdn.voidless.dev/. Also its world height (in heights of the hero / its set's reference character) and each frame's sprite_scale (how big the character is drawn there against the base: video clips are usually ~0.57): size it in a game from these, never by eye. Free.

An asset's image as a data: URI to put straight into HTML ( or a CSS background), for sandboxes that cannot load images from another site, such as Claude's HTML artifacts. For an animation or rotation frame it returns ONE horizontal sprite strip (all frames side by side, each size×size) plus a CSS snippet that plays it. Shrunk to fit a reply (small sizes are fine for sprites; scale them up in CSS with image-rendering: pixelated). Free.

Make a seamless, looping animated pixel-art liquid tile, like the Animated Water & Lava Tiles tool on voidless.dev/tools: ocean (swells, crests, sparkles), river (streaks and foam flowing in a direction), pond (shallow water with caustics), lava (dark crust, glowing cracks), acid (green boil, bubbles that pop) or waterfall (falling streaks, plus a foaming base tile for the bottom of the fall). Every frame tiles in both directions and the last frame flows into the first. Six colours per material. Same seed, same tile. Returns a GIF of the tile, a GIF of it repeated 4x4, and a sprite sheet (frames in one row; a waterfall adds its base as a second row). Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

List the user's Voidless assets, newest first: id, type, prompt, tags and how many frames/animations each has. Use this to find an asset to animate, rotate or edit. Free.

Turn frames (or a sprite sheet) into an animated GIF: frame rate, loop, whole-number nearest-neighbour scale for crisp pixel art, transparency kept (GIF transparency is on/off per pixel), or flattened onto a background colour. Pixel art with up to 255 colours keeps every colour exactly. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Make a glow map from an edit that switched lights on (or made a night version with lights glowing): the light the edit added over the picture it came from, on transparency, for an additive or emissive layer in a game. Same size as the picture. Pass the edit's frameId (from get_asset). Free.

Make a normal map for an image asset, for 2D lights in a game engine: which way each pixel faces, so a moving light shades it. The shape comes from a depth model, the drawn detail from the picture. PNG at the picture's own size, OpenGL style (green = up: Godot and Unity read it as is; flip green for Unreal). Pass frameId (from get_asset) for an edit, or an animation (one map per frame); leave it out for the image itself. Free.

Free. Only for images generated in Voidless (not uploads): pixel sprites of size 32, 48, 64, 96, 128, 192, 256 or 384 (an HD image: resize_sprite it to a pixel size first). Puts 1-12 sprites on ONE shared palette so separately generated assets look like one scene. The palette is built from all of them as colour ramps, or given as hex colours, or led by one sprite's own colours; every frame of every sprite is remapped along the ramps so shading stays smooth. Each sprite gets a NEW asset (originals untouched).

Pack frames or sprites into one sheet (texture atlas) plus a JSON atlas in the frames-hash format Phaser and PixiJS load (TexturePacker JSON Hash). Without columns it packs tightly like voidless.dev/tools (shelf packing, tallest first); with columns it lays a uniform grid in the given order. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Recolour a sprite. swaps: from→to colour pairs; by default only pixels of those exact colours change (raise tolerance to catch near shades), match "nearest" snaps every pixel to its nearest from colour (the voidless.dev/tools palette swap). Or palette: a preset (1bit, gameboy, cga, gray4) or a list of hex colours to quantize to, with optional dithering. Call with neither to list the image's colours. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Make a layered pixel-art parallax background for a side-scroller, like the Parallax Background Generator on voidless.dev/tools: a banded sky, sun/moon/ringed planet, stars, clouds, mountains, hills, a city or ruins, and a treeline, from a preset (day, sunset, night, dusk-forest, snowy-mountains, alien-world). Every layer tiles seamlessly left to right; far layers fade towards the horizon colour. Returns the composed PNG, one PNG per layer (far to near; transparent where empty, except the sky), optionally a scrolling GIF, and speeds.json with each layer's scroll speed and Godot Parallax2D / ParallaxLayer values. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Convert any image to pixel art at a target size (the colour count follows the size). Returns the image; nothing is saved to the library. 1 credit.

Reduce an image to N colours, like the Color Reducer on voidless.dev/tools. The palette is found in OKLab, a perceptual colour space (k-means seeded by median cut, or median cut alone), so the colours are spent where the eye sees a difference. Dithering is off by default (clean pixel art); ordered (Bayer 8x8) or Floyd-Steinberg are optional. Transparency is kept exactly. An image that already has N colours or fewer comes back unchanged. Returns the PNG with the before/after colour counts and the palette. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Render a 3D model as 2D game sprites: one of its moves (from animate_3d_model) or the model standing, seen from 8 directions, 4, the two sides of a platformer, 4 isometric diagonals, or the front. 16 frames by default, at 32-512 px (pixel art up to 128, from the same pass as generated sprites; smooth above). Saved as an animated sprite asset linked to the model, one animation per direction, ready to export as a sheet or edit. Every render of the same model goes onto that one asset. Free.

Free. Re-cut an asset's animations from the videos Voidless stored when it made them, with the current pipeline: cut-out, seamless loop, 30 fps, one size across facings, steady idles. Replaces those frames in place (same ids and names; the old images are kept and can be restored). Only for animations made in an animation set (generate_animation_set) since Voidless started keeping their videos. frameIds: the animation frame ids to re-cut (omit for every re-cuttable animation on the asset).

Free. Only for images generated in Voidless (not uploads): pixel sprites of size 32, 48, 64, 96, 128, 192, 256 or 384, or HD (non-pixel, square 512/1024) images. Re-runs Voidless's pixel pass at a new size from the art it stored, so the base image, its rotations, edits and every animation come out at the new size on one palette and the character keeps its design (unlike generating it again smaller). On an HD image it makes a pixel version at size: generate HD, then resize to 64 and to 32 for pixel versions. Makes a NEW asset; the original is untouched.

Add a skeleton to a 3D model so it can be animated: a humanoid, a four-legged animal, or a prop's moving parts (a chest lid, a door, a tree's trunk). Run before animate_3d_model. 30 credits.

Rotate a pixel-art sprite by any angle and keep it pixel art, like the Pixel Art Rotate tool on voidless.dev/tools. RotSprite method: the sprite is scaled up 8x with Scale2x (EPX) three times so diagonals stay smooth, rotated with nearest neighbour, and scaled back down taking each 8x8 block's most common colour, so lines don't break into stairs and no new colours appear (the result's palette is a subset of the sprite's, with hard alpha). Quarter turns are exact. The canvas grows to fit. Angles are degrees, clockwise. Give directions (e.g. 8 or 16) for a sweep starting at angle: every frame on one canvas size, returned as a GIF and a sprite sheet plus the angle list. It turns the picture in the plane (a top-down car, ship or turret heading 16 ways, a swinging sword, a tilted prop); to draw a character from its other sides (front, back, side views), use rotate_sprite instead. Sprites up to 512x512; sprite pixels x directions up to 1048576 (a 256x256 sprite in 16 directions). Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Turn a sprite into an 8-way set (front, back, sides and diagonals) in one pass. The result is a 'rotations - 8-way' frame whose facings line up with its images; pass those to generate_animation_set to animate each direction. Works best from a side-profile sprite. 20 credits.

Add secondary motion to a sprite's cape, hair, beard, scarf, tail or plume, like the Secondary Motion tool on voidless.dev/tools. Give the part as its hex colours (every pixel of those colours moves; its outer outline comes along). One image: the part sways in a gentle breeze that loops. Frames or a sheet (an animation): the part lags the body's movement and overshoots (spring-damper follow-through), same frame count, loops. The body never changes; the part moves by whole pixels in the sprite's own colours. Returns a GIF and a sprite sheet (one row). Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Cut a sprite sheet into frames. Give columns/rows, or cell_width/cell_height, or neither to auto-detect the grid like voidless.dev/tools (gaps between frames first, else square frames along the long side). Returns each frame as a PNG plus a JSON list of where each sat on the sheet. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Make a death (or despawn) animation from a sprite, like the Sprite Death Animation tool on voidless.dev/tools: dissolve (eaten away in patches, with an edge colour), burn (burns away with embers), burst (pixels fly apart and fall), disintegrate (drifts away pixel by pixel) or blink (classic retro flash and fade). Every frame keeps the sprite's own colours; the first frame is the sprite, the last is empty. Returns a GIF and a sprite sheet (frames in one row). Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.

Add, remove or replace the tags on an asset, so it can be found again with list_assets(tag). Free.

Add, remove or replace the tags on one frame of an image asset (an animation, edit or part), e.g. to mark which clip is 'idle' or 'final'. 8-way rotation frames cannot be tagged: their tags are the facings the animation presets rely on. Free.

Add an image the user already has to their library, so it can be animated, rotated or edited. The editors work on squares of 32, 48, 64, 96, 128, 192, 256 or 384, 512, 768 or 1024 px; any other picture is centred on the smallest of those that holds it, with transparent padding (scaled down to 1024 if larger), and the reply says so. Give it as a public URL (best: a long base64 string is easy to garble) or as base64. Free.

Make a pixel-art tree, bush, grass tuft or flower sway in the wind, like the Pixel Wind Sway tool on voidless.dev/tools. The bottom row is the base and never moves; pixels bend more the higher and further out they are. Whole pixels move (no blending), so every frame keeps the sprite's own colours. The sway loops seamlessly. Optional: a one-shot storm clip where leaves blow off and fade. Returns a GIF and a sprite sheet (frames in one row) for the loop, then the storm's GIF and sheet when asked. Images up to 2048x2048, 256 frames, 32 MB of input per call. Free: no credits.