What's Inside a Tesla Paint Shop Wrap File (and How to Validate One Before It Hits the Car)

Since the Paint Shop feature started accepting custom wraps, a lot of Tesla owners have discovered the same thing: making the image is the fun part, but getting the car to accept it is where the afternoon goes. The file either doesn't show up in the Wraps tab, or it shows up and the stripes land on the wrong panel.

I spent a while digging into how these files work. This post covers what the format actually is, why designs end up misaligned, and a small Python script that checks a file against the published rules before you copy it to a USB stick.

It's a texture, not a picture of a car

The most important mental shift: a wrap is a texture map. Tesla publishes a template for each vehicle in its teslamotors/custom-wraps repository on GitHub. Each template is a flat image where every body panel (hood, doors, fenders, bumpers, roof) has been unfolded onto a 2D canvas, the same way a 3D artist unwraps a model before painting it. The car's renderer then samples that image using the model's UV coordinates.

That explains the two most common surprises:

1. Panels are not where you expect. The left and right sides of the car may sit next to each other, rotated, or mirrored. A stripe drawn straight across the template does not become a straight stripe on the car.
2. Templates differ per variant. Model 3 2017–2023 and the 2024+ refresh have different body shapes, so they get different templates. The same goes for Model Y 2020–2024 versus the 2025+ Standard, Premium and Performance versions, Model Y L, Model S 2021+ versus the 2025+ Plaid, Model X 2021+, and Cybertruck. A wrap made for one will look wrong on another, even if it loads.

The rules the car enforces

From Tesla's README, a wrap file must be:

• PNG format
• 512×512 to 1024×1024 pixels (the template size is the safe choice)
• 1 MB or smaller
• named with letters, numbers, underscores, dashes and spaces only, max 30 characters
• placed in a folder called Wraps at the root of a USB drive formatted as exFAT, FAT32, MS-DOS FAT, ext3 or ext4 (not NTFS), with no map or firmware update files on the drive

You can load up to 10 wraps from USB and up to 10 through the mobile app. In the car, they appear under Toybox → Paint Shop → Wraps.

The 1 MB limit is the one that catches people. A 1024×1024 PNG full of gradients and noise compresses badly, so a detailed design can easily land at 1.5–2 MB.

A quick validator

Here is a small script using Pillow that checks the rules above and tries to shrink an oversized file by quantizing its palette:

import os, re, sys
from PIL import Image

NAME_RE = re.compile(r"^[A-Za-z0-9 _-]{1,30}$")
MAX_BYTES = 1024 * 1024

def check(path):
    problems = []
    stem, ext = os.path.splitext(os.path.basename(path))
    if ext.lower() != ".png":
        problems.append("not a .png file")
    if not NAME_RE.match(stem):
        problems.append("name must be 1-30 chars: letters, numbers, _ - or space")
    with Image.open(path) as im:
        w, h = im.size
        if im.format != "PNG":
            problems.append(f"actual format is {im.format}")
        if not (512 <= w <= 1024 and 512 <= h <= 1024):
            problems.append(f"size {w}x{h} is outside 512-1024 px")
    size = os.path.getsize(path)
    if size > MAX_BYTES:
        problems.append(f"{size/1024:.0f} KB is over the 1 MB limit")
    return problems

def shrink(path, out):
    with Image.open(path) as im:
        im.convert("RGB").quantize(colors=256, method=Image.Quantize.MEDIANCUT) \
          .save(out, optimize=True)
    return os.path.getsize(out)

if __name__ == "__main__":
    p = sys.argv[1]
    issues = check(p)
    print("OK" if not issues else "\n".join("- " + i for i in issues))

Quantizing to 256 colors usually brings a busy design well under 1 MB. Banding can show up in smooth gradients, so look at the result before you load it. If banding is bad, reduce noise or texture in the design rather than lowering resolution, since a smaller image gets stretched across the same panels.

Check alignment before the car does

The validator tells you whether the car will accept the file. It cannot tell you whether the wrap will look right. Seams are the usual culprit: the edge where the door meets the rear fender is two separate regions on the template, and a pattern that doesn't line up across them shows a visible break.

The slow way to check is to copy, walk to the car, open Paint Shop, squint, and repeat. The faster way is a 3D preview that uses the same template mapping. I ended up building Tesla Wrap Designer for this: you pick the exact model and trim, design (or generate a starting point from a text prompt), rotate the car in 3D in the browser, and export a PNG that has already passed the size, file name and file size checks. Editing, preview and export are free.

Whatever tool you use, three habits save the most time:

• Start from the right template. Confirm the model year and trim first.
• Design across seams on purpose. Either keep patterns continuous across neighboring regions, or break them deliberately at panel edges.
• Keep the file name boring. matte_blue_stripes will always work. Matte Blue (v2).png will not, because parentheses and periods aren't allowed.

Wrapping up

Paint Shop wraps are a small but nice example of texture mapping meeting a consumer product with strict input rules. Treat the file as a texture, validate it like an upload API would, and preview it in 3D before you walk to the garage.

If you've built anything around these templates, like batch converters or pattern generators, I'd like to hear about it in the comments.