Doping

A tiny AI that invents brand-new Minecraft skins

47M parameters · trained from scratch · free to download · free to try

_{by Shahriar Mahmud · from the makers of Neather Launcher}

Pick a number (a seed), and Doping gives you one new, ready-to-use Minecraft skin. No prompts, no account, no payment. Try it in your browser with the free Colab notebook, or download the weights and run it yourself.

🎨 Examples

Every skin below was made by Doping. The big picture is the skin worn in 3D, and the small square is the real 64×64 PNG you upload to Minecraft.

_{seed 8008902}	_{seed 1028026}	_{seed 13825950}	_{seed 15581446}
_{seed 10944066}	_{seed 9551768}	_{seed 14802163}	_{seed 13717920}

_{Want one of these exact skins? Type its seed into the notebook with Best of = 1.}

🚀 Try it in 3 minutes (free)

Open the Colab notebook
In the menu choose Runtime → Change runtime type → T4 GPU (free).
Click Runtime → Run all and scroll to the bottom.

You get a 3D viewer you can rotate (with Front / Back / Left / Right and a Walk animation), a control panel right under it, and a Download button for every skin. Nothing to install, nothing to pay for.

Want to keep a copy of the notebook? Download it here (.ipynb), then in Colab choose File → Upload notebook. You can also view it on Hugging Face.

Prefer your own computer? Jump to Run it yourself.

📋 At a glance


Model name	Doping
Parameters	46.97 million
What it makes	One 64×64 RGBA Minecraft skin per seed (classic or slim arms)
Input	A random seed. No text prompts
Method	Flow matching (rectified flow)
Backbone	UNet with self-attention
Training	From scratch, 120,000 steps, fp16, one Kaggle T4 GPU
Weights file	`doping_fp16.pt` (about 94 MB, EMA weights)
License	Apache-2.0

✅ What it does (and doesn't)

Does

Turns a seed into a new skin. The same seed and settings give the same skin back, so you can always recreate one you like (tiny pixel differences are possible between CPU and GPU).
Draws a properly laid-out skin: face on the head, arms and legs in the right places, unused areas left empty, base layer fully opaque.
Supports classic (4 px) and slim (3 px) arms. Pick one, or let auto decide.
Can try several seeds and keep the best one (Best of 2 / 4 / 8).

Doesn't

Take text prompts. You can't ask for "a red hoodie". Style comes from the seed.
Make anything other than 64×64 skin textures.

🧠 How it works

A Minecraft skin isn't a normal picture. It's a flat unfolding of a body made of 12 boxes: head, hat, body, jacket, two arms, two sleeves, two legs and two pant layers. A pixel in the top-left means something completely different from a pixel in the middle. Doping is built around that.

random seed
   │
   ▼
 noise (4×64×64)  +  21 layout channels  +  time step  +  arm type
   │
   ▼
 ┌────────────────────────── UNet · 47M ──────────────────────────┐
 │  64×64 ─► 32×32 ─► 16×16 ─► 8×8 ─► 16×16 ─► 32×32 ─► 64×64     │
 │  2 residual blocks per level · skip connections                │
 │  self-attention in the middle and at the lower resolutions     │
 └────────────────────────────────────────────────────────────────┘
   │
   ▼
 predicted "velocity"  ─►  40 small Euler steps  ─►  finished skin

1. The input: noise plus a map of the body

The network sees 25 channels at every pixel:

Channels	What they are
4	The current image (RGBA), starting as pure noise
2	x and y position
12	Which body part the pixel belongs to (head, hat, body, jacket, right arm, right sleeve, left arm, left sleeve, right leg, right pants, left leg, left pants)
6	Which face of that box it is (top, bottom, right, front, left, back)
1	Is it on the outer layer?

Because the model always knows "this pixel is the front of the head", it can learn that eyes and mouths belong there and that sleeves belong on the arms.

2. The UNet

Four resolution levels (64 → 32 → 16 → 8) with channel widths 96, 192, 288 and 384, then back up with skip connections.
2 residual blocks per level, using GroupNorm and SiLU.
Self-attention at 16×16 and 8×8 in the encoder, in the 8×8 bottleneck, and at 16×16 and 32×32 in the decoder. It lets far-apart parts of the skin agree with each other, so both sleeves match, the hair matches the hat layer and the torso matches the legs. There is no attention at full 64×64 resolution, and the encoder's 32×32 stage skips it to train faster.
The time step and the arm type (classic or slim) are turned into a vector that scales and shifts the features inside every residual block.
No text encoder, no cross-attention and no classifier-free guidance, so every step is a single pass through the model.

3. Flow matching instead of classic diffusion

During training the model sees a skin mixed with noise and learns the straight-line direction from noise to skin. To generate, Doping starts from noise and follows that direction in 40 small Euler steps. It's simpler than DDPM-style diffusion and needs far fewer steps.

4. Built-in rules so the output is always a valid skin

Fixed channels. The base layer's alpha is always fully opaque, and the unused areas of the 64×64 texture are always empty. The model never has to generate these, so it can't produce junk there.
No horizontal-flip augmentation. Left and right body parts are different regions of a skin, so flipping would teach the wrong thing.
Face-weighted loss. Head-front and hat-front pixels count 3× more in training, because an eye is only 1 to 2 pixels.
Light clean-up after sampling. Overlay alpha is snapped to fully on or off, and unused pixels are zeroed.

How "Best of N" works

For each skin you ask for, Doping can try N consecutive seeds, score every candidate with a small rule-based quality check (valid layout, low noise, coherent colors, a face with two eyes and a mouth), and keep the best. Best of 1 returns exactly the seed you typed.

🏋️ Training


Data	A cleaned dataset of Minecraft skins, sampled so that common styles don't dominate
Objective	Flow matching with logit-normal time steps and a face-weighted MSE loss
Steps	120,000
Batch size	128 (2 × 64 with gradient accumulation)
Optimizer	AdamW (betas 0.9 / 0.99, weight decay 0.01)
Learning rate	Peak 2e-4, 1,000 warmup steps, then cosine decay
Gradient clipping	1.0
Precision	fp16 autocast with GradScaler
EMA	Decay 0.9995. The released weights are the EMA weights
Hardware	One free Kaggle T4 GPU, trained in resumable sessions

💻 Run it yourself

pip install torch pillow numpy huggingface_hub

import os, sys
from PIL import Image
from huggingface_hub import hf_hub_download

REPO = "shahriar15011/Doping"
code    = hf_hub_download(REPO, "skin_model.py")      # model + sampler code
weights = hf_hub_download(REPO, "doping_fp16.pt")     # the 94 MB weights
sys.path.insert(0, os.path.dirname(code))

from skin_model import load_model, make_skin

model, _ = load_model(weights)
# model = model.to("cuda")                            # optional: use a GPU

# one skin from seed 1234 (arm: "auto", "classic" or "slim")
skin, seed, is_slim = make_skin(model, 1234, arm="auto", best_of=1, steps=40)
Image.fromarray(skin).save(f"skin_seed{seed}.png")
print("saved", seed, "slim" if is_slim else "classic")

# try 8 seeds in a row and keep the best-looking one
skin, seed, is_slim = make_skin(model, 5000, best_of=8)

Using a skin in Minecraft: open the Minecraft Launcher (or your profile on minecraft.net), choose Skins, upload the PNG, and select classic or slim to match.

📁 Files in this repository

File	What it is
`doping_fp16.pt`	The model weights (EMA, fp16, about 94 MB). This is the one you need
`skin_model.py`	Model, sampler, quality check and 3D viewer code
`Doping_Colab.ipynb`	The free Colab notebook (click to download)
`examples/`	The example skins and their 3D previews shown above
`README.md`	This page

⚠️ Limitations

No control. There are no prompts. You choose a seed, not a style.
Not every skin is great. Generation is random. Try another seed, or use Best of 4 or 8.
Style follows the training data. Common looks appear more often than rare ones.
Faces are tiny. An eye is one or two pixels, so an eye or mouth can occasionally be off by a pixel.
It can resemble existing skins. As with any generative model, a result may look similar to a skin from the training data by chance.

👤 Creator

Shahriar Mahmud
Facebook: shahriar.mahmud.5686
Email: shahriar.developer111@gmail.com
Website: neatherlauncher.github.io

🟩 Also try Neather Launcher

Neather Launcher is a free launcher that I make. In my opinion it is better than any other launcher on the market, and you can use it for free.

Visit the Neather Launcher website

📄 License, data and credits

The code and weights are released under Apache-2.0. The training skins come from third-party sources that may have their own terms. If you plan to reuse or sell generated skins commercially, please make sure you're comfortable with that.

@misc{doping2026,
  title  = {Doping: a 47M-parameter flow-matching Minecraft skin generator},
  author = {Shahriar Mahmud},
  year   = {2026},
  note   = {Trained from scratch on Minecraft skins}
}

_{Doping is a fan project. It is not affiliated with, endorsed by, or connected to Mojang or Microsoft. Minecraft is a trademark of Mojang Synergies AB.}

Downloads last month: -; Downloads are not tracked for this model. How to track

Inference Providers NEW

Unconditional Image Generation

This model isn't deployed by any Inference Provider. 🙋 Ask for provider support