Skip to content
Images

Pixelquill-61M

16×16 pixel-art sprite generation without diffusion or a VAE

3 min read

A compact 61.3M-parameter model by MahdiAlikhah that turns short English prompts into ready-to-use 16×16 pixel sprites. Unlike standard image generators, it was trained from scratch without diffusion or a VAE (an encoder network used to compress images). Instead of producing blurry pixels, the model autoregressively predicts a sequence of 289 discrete tokens: it first picks a 32-color palette and then fills each of the 256 pixels with indices from that palette, including transparency. Ideal for indie devs and hobbyists looking to quickly prototype game icons, items, and simple characters.

Key features

  • Tokens instead of diffusion: the model locks in a 32-color palette before placing pixels, preventing color bleed and outputting a clean RGBA sprite right away.
  • Lightweight architecture trained from scratch: pairs a 3-layer text encoder with a closed 8,643-word vocabulary and a 12-layer decoder featuring 2D axial RoPE and SwiGLU; fp32 weights take up just 245.5 MB.
  • Color accuracy and novelty: in tests, 23 out of 24 color-named prompts hit the target hue (with a 4° median error), and none of the generated sprites were exact duplicates from the training set.
  • Open license: code and weights are released under Apache-2.0, trained on the open pixel-art-atlas-1.4m dataset (CC0-1.0).

What you can do

  • Prototype game assets: quickly draft icons for potions, weapons, monsters, or environment props using short text prompts like cute teal slime or green potion.
  • Batch-generate sprite sheets: pass a list of prompts directly to generate() and save upscaled image sets (such as crisp 16×16 to 128×128 scaling without blur) straight from Python or the CLI.
  • Recolor objects via prompts: swap just the color word in your prompt to generate variations of the same item—this works best on round shapes like slimes and potions.

Example

import sys
from huggingface_hub import snapshot_download

path = snapshot_download("MahdiAlikhah/pixelquill-61m", local_dir="pixelquill")
sys.path.insert(0, path)
from pixelquill import Pixelquill

model = Pixelquill.from_pretrained(path)
model.generate_one("cute teal slime", scale=8).save("slime.png")
Read moreDetails
Metrics on held-out objects with zero training overlap: per-pixel accuracy is 80.65% with teacher-forcing and 31.6% in free-running generation, with 0.00% exact full-sprite matches.
Speed and hardware: on an NVIDIA L4, generation takes ~2.8 s per sprite (~90 s for a batch of 32), as sampling does not yet use KV-caching.
Limitations: fixed 16×16 canvas, a closed 8,643-word English vocabulary (unknown words become ), weak structural consistency on thin objects like swords (0.46 IoU vs. 0.94 for slimes), confusion when combining two objects in a single prompt, and high variance across seeds (28% pixel overlap).
Discuss Telegram 0

Will it run?

Runs in F32

Fits without quantisation.

  • F32weights 0.2 GB · ready files1.8 GB
  • BF16weights 0.1 GB1.6 GB
  • FP8 / INT8recommendedweights 0.1 GB1.6 GB
  • 4-bitweights 0.0 GB1.5 GB

Tip: go 8-bit.FP8 / INT8 is within about a percent of full precision in quality, takes half the memory and runs faster on RTX 40/50 and H100. Full precision only pays off for fine-tuning.

What to get for this model

Massed ComputeOpen Massed Compute

Your own GPU: FP8 / INT8 — from RTX 2060 · F32 — from RTX 2060

Massed Compute hourly prices, November 2026. The discounted price applies with the coupon at checkout.

Estimate: weights plus working memory. Long videos, high resolutions and long contexts need more.

Run it on Massed Compute

The script downloads the model to the rented machine. How to run it is in the model card.

  1. 1. Rent a machine with a fitting GPU

    Open Massed Compute
  2. 2. Paste the script into the machine's terminal

    Connect over SSH (the Massed Compute panel shows the command) or open a terminal on the machine's desktop.

    HF_TOKEN / CIVITAI_TOKENThe script starts with token lines: paste yours between the quotes. The Hugging Face token is for gated models, the Civitai one for Civitai models.

    # MahdiAlikhah/pixelquill-61m
    mkdir -p ~/models
    curl -LsSf https://astral.sh/uv/install.sh | sh
    source "$HOME/.local/bin/env"
    uv tool install "huggingface_hub[cli]"
    hf download MahdiAlikhah/pixelquill-61m --local-dir ~/models/pixelquill-61m
    # The model is in ~/models. How to run it is in the model card (link above).
    Add more LoRAs to pixelquill-61m
  3. 3. Use it

    The model is in ~/models. How to run it is in the model card (link above).

Stop the machine in the panel when you are done: it bills by the minute while it runs.

How to speed it up

Picked for this model type. Choose your hardware above to see what fits you exactly.

  • SageAttention 3v2.2.0from October 28, 2025

    even faster on RTX 50 / Blackwell

    FP4 attention for Blackwell. Faster than SageAttention 2, but the authors suggest v2 when accuracy matters.

    How to enable: Build from the sageattention3_blackwell folder of the repo; in ComfyUI via KJNodes.

    Earlier generations (2)
    • SageAttention 2++ — Quantised (INT8/FP8) attention with no visible quality loss. The main speed-up for image and video generation.
    • SageAttention 1 — First version: INT8 for Q·K. Still works, but 2++ is faster and more accurate.
  • FlashAttention 44.0.0b40from November 18, 2026new release

    fastest exact attention on B200

    Kernels for Blackwell (beta). Exact attention without quantisation — fine for everything, LLMs included.

    How to enable: pip install flash-attn-4; vLLM and SGLang pick it up themselves.

    Earlier generations (3)
    • FlashAttention 3 — The Hopper (H100/H200) version with FP8.
    • FlashAttention 2 — The standard for RTX 30/40/50 and A100: exact attention without the memory cost of long contexts.
    • xFormers — The older way to speed up attention, works almost everywhere. Sage or Flash are faster where available.
  • cache-dit (DBCache)v1.5.6from November 20, 2026new release

    1.5–3× at nearly the same quality

    Reuses block outputs between diffusion steps. Supports most DiT models.

    How to enable: pip install cache-dit; one line cache_dit.enable_cache(pipe) for diffusers.

    Earlier generations (2)
    • MagCache — Skips steps by magnitude of change. More accurate than TeaCache, no calibration.
    • TeaCache — The first popular diffusion step cache. Works, newer methods are more accurate.
  • Nunchaku (SVDQuant 4-bit)v1.2.1from January 25, 2026

    ≈3× faster and 3.5× less memory

    4-bit versions of popular image models with almost no quality loss (FP4 on RTX 50).

    How to enable: Ready weights for supported models; in ComfyUI use ComfyUI-nunchaku.

  • torch.compile2.15.0from October 28, 2026new release

    10–30% for free

    Compiles the model for your GPU. Slower first run, faster afterwards.

    How to enable: model = torch.compile(model); in ComfyUI the TorchCompileModel node.

Model family

New posts about versions of pixelquill-61m (quants, finetunes, LoRAs) will show up under the bell.

No known relatives of this model yet. All derivatives on Hugging Face

About the model

MahdiAlikhah/pixelquill-61m
Author
MahdiAlikhah
Category
Images
Released
Posted

On NeyroLearn

Hugging Face

00

Ask AI about this model

Answered by Gemini 4 · the chat is kept only in this tab

Comments