MihaiPopa-1/minecraft-skins-1.1m-deduped-64x64-1.5

Minecraft Skins 1.1M Deduped (64x64 Edition) 1.5!

Minecraft Skins 1.1M Deduped but troll skins were filtered (more this time).

Format is a 2.5 GB ZIP archive containing 64x64 PNG skin files.

Tools used

PIL Image (Python) and Google Colab (free CPU tier)

How it was made

1. Loaded Minecraft Skins 1.1M Deduped,
2. Troll (like single-color) skins were filtered (std > 10 were kept) and removed.
3. Result is 1100250 real 64x64 skins.
4. Output is given in a 2.5 GB ZIP archive.

This can be used to make your own skin generation model (but I'm going with VQ-VAE anyway!)

Future improvements for version 2

1. Captioning (with Florence 2 Base)
2. Filtering troll skins (skins that are formed of just a single color) already done!

Code

Code to reproduce it (all by Claude 4.6 Sonnet):

Same code as before, then:

import os
import numpy as np
from PIL import Image
from tqdm import tqdm
from multiprocessing import Pool, cpu_count
import shutil

SKIN_DIR      = "/content/filtered_skins"
OUTPUT_DIR    = "/content/filtered_skins_pro"
STD_THRESHOLD = 10

os.makedirs(OUTPUT_DIR, exist_ok=True)
skin_files = [f for f in os.listdir(SKIN_DIR) if f.endswith(".png")]

def process_skin(filename):
    path = os.path.join(SKIN_DIR, filename)
    try:
        img = Image.open(path).convert("RGB")
        std = np.array(img).std()
        if std >= STD_THRESHOLD:
            shutil.copy2(path, os.path.join(OUTPUT_DIR, filename))
            return "kept"
        return "filtered"
    except Exception:
        return "error"

print(f"CPUs available: {cpu_count()}")

with Pool(processes=cpu_count()) as pool:
    results = list(tqdm(
        pool.imap(process_skin, skin_files, chunksize=100),
        total=len(skin_files)
    ))

kept     = results.count("kept")
filtered = results.count("filtered")
errors   = results.count("error")

print(f"\nKept     : {kept:,}")
print(f"Filtered : {filtered:,}")
print(f"Errors   : {errors:,}")

then:

import os
import zipfile
from tqdm import tqdm

INPUT_DIR = "/content/filtered_skins_pro"
ZIP_PATH  = "/content/minecraft_skins_64x64_v1_5.zip"

skin_files = [f for f in os.listdir(INPUT_DIR) if f.endswith(".png")]
print(f"Skins to zip: {len(skin_files):,}")

with zipfile.ZipFile(ZIP_PATH, "w", zipfile.ZIP_DEFLATED, compresslevel=1) as zf:
    for filename in tqdm(skin_files):
        zf.write(os.path.join(INPUT_DIR, filename), arcname=filename)

size_mb = os.path.getsize(ZIP_PATH) / 1024 / 1024
print(f"\nDone!")
print(f"Skins zipped : {len(skin_files):,}")
print(f"ZIP size     : {size_mb:.1f} MB")