plain English →
pixel sprites — fully offline

All 38 classes, verified 100%

The final acceptance run tested every class with two prompt styles × two seeds through the exact shipped user path: 152/152 passed (100%). A second, independent sweep with 39 never-seen phrasings scored 99.1%. Each card below is a real accepted render — hover any sprite to zoom.

Prompt words actually change pixels

The corpus is built from a procedural rasterizer with counterfactual twin pairs — identical geometry, one changed word — so the model learns word→pixel causality, not vibes.

Benchmarks

Run it on your laptop

No GPU. No PyTorch at inference. No internet. Python ≥ 3.9 with numpy and pillow.

# 1. get the bundle
git clone https://github.com/tarulahsan/PXG-Tiny-AI
cd PXG-Tiny-AI
pip install numpy pillow pytest

# 2. single sprite
python3 cli.py "a golden sword" -o sword.png

# 3. four variations on one sheet
python3 cli.py "an iron chest" --variations 4 \
  --sheet chest_variants.png

# 4. batch from a prompt list
python3 cli.py --sheet-from-prompts prompts.txt \
  --outdir sprites/

# Python API
from pxg_tiny.pipeline import PXGPipeline

pipe = PXGPipeline()
grid, meta = pipe.generate_pixels(
    "a ruby potion that glows", seed=7)

if grid is None:
    print(meta["message"])  # clarify / refuse
else:
    pipe.generate_png("a ruby potion that glows",
                      "ruby_potion.png")

# ask-first gate (rule-based, offline)
PXGPipeline.ask("render a 3d photo")
# -> "i only make 16x16 pixel-art sprites..."

• ▸Ask-first behavior — asks clarifying questions on unknown objects or conflicting words ("tiny huge sword"), refuses photos/3D/animation requests instead of hallucinating.
• ▸Verifier-guided sampling — every candidate sprite is checked against the parsed prompt; failed seeds escalate through self-guidance (8 attempts) automatically.
• ▸Deterministic seeds — same prompt + seed ⇒ same sprite, forever.
• ▸22 automated tests — tokenizer, gates, NumPy kernels, end-to-end: pytest tests/ -q

What it won't do

• ✕16×16 only — larger canvases, spritesheets and tilemaps are refused by design; scaling to 32×32 would 4× the sequence length and require a full redesign.
• ✕38-class vocabulary — anything outside the trained families gets a clarifying question, never a hallucinated blob.
• ✕Binary transparency — master-palette indices mean no soft edges/anti-aliasing.
• ✕Impossible combos downgrade — "emerald dagger" renders a default dagger (the recipe set has no such training pair) instead of failing.
• ✕No animation / multi-view — roadmap items from the main PXG program.

Architecture in 30 seconds

caption ids (32 chars) ──► intent encoder (bi-attention, fp32) ──► 8 prefix vectors
[8 prefixes | 256 visual tokens] ──► 4× pre-LN causal blocks (d=96, 4 heads, FFN 256)
                                    └─► 32-way softmax over master-palette indices (0 = transparent)

teacher-forced top-1 98.89% · KV-cached decode ~0.6 s/sprite on 2 CPU cores
training corpus: 97,005 fully procedural rows (CC0), counterfactual twins + paraphrase engine

• ▸Built-in visual "tokenizer" — sprites are grids of 32 master-palette indices, so decoding is byte-exact and alpha transparency is exact by construction.
• ▸Self-teaching recipe — no external dataset: the procedural rasterizer makes captions honest by construction; twins teach causality; paraphrases teach invariance.
• ▸Verifiable — quality gates calibrated so the GT corpus passes 100%; parity harness proves the shipped NumPy runtime matches the torch training reference bit-for-bit.