You ask ChatGPT for a logo on a transparent background. It hands you a PNG. The PNG looks right — there’s that familiar gray-and-white checkerboard pattern behind your design, the same pattern you’ve seen in Photoshop a thousand times. Transparency. Done.
Then you drop it into a real project — a slide, a website header, a printed shirt — and the checkerboard is still there. It’s not a transparency indicator. It’s part of the image. The AI didn’t give you a transparent background. It gave you a picture of a transparent background.
This happens constantly. One print shop wrote that they see it multiple times per week — customers send ChatGPT images that “look transparent” but open as solid backgrounds, stopping production while someone fixes it by hand. It’s one of the most common, most quietly maddening failure modes in everyday AI image work.
Here’s what’s actually going on — and why the explanation is more interesting, and more our own fault, than it first appears.
The checkerboard is pixels, not transparency
Start with the thing people get wrong about the checkerboard itself.
The gray-and-white checkerboard was never transparency. It’s a convention — a visual stand-in that image editors use to show you transparency on a screen that can’t actually display “nothing.” Your monitor has to put something in every pixel. So Photoshop, GIMP, and every other editor agreed, decades ago, to render empty pixels as a checkerboard so your eye can tell “this area has no content” apart from “this area is solid white.”
The checkerboard is a costume. It’s what transparency wears so humans can see it. The actual transparency lives in something called an alpha channel — an invisible fourth value attached to each pixel (alongside red, green, and blue) that says how opaque that pixel is. Real transparency is data. The checkerboard is just the outfit that data wears in an editor window.
When ChatGPT gives you a checkerboard baked into the pixels, it has handed you the costume with no one inside it.
Cause one: image models paint, they don’t cut
The first technical reason is blunt: most AI image generators have no concept of transparency to begin with.
ChatGPT’s image generation has run on a series of models — DALL-E 3, then gpt-image-1, then gpt-image-2 — and the underlying behavior of the consumer experience is that the model generates red, green, and blue values for every pixel, but does not generate transparency data. Every pixel gets a color. None of them get an “opacity.” The model paints a rectangle, edge to edge. It does not cut anything out, because cutting out isn’t an operation it has.
So when you type “transparent background,” the model still has to put something in those pixels. It cannot leave them empty — empty isn’t a color, and color is all it produces. It has to paint.
The question then becomes: when a painting-only model is asked to paint “transparent,” what does it paint?
Cause two: it paints the symbol — because we taught it the symbol
This is the part where, as the framing of this piece promises, we did it to ourselves.
These models learned what things look like by training on an enormous slice of the visual internet — billions of images scraped from the web. And across that training data, the phrase “transparent background” is overwhelmingly attached, visually, to one specific thing: the checkerboard.
Think about where the checkerboard appears online. Photoshop tutorial screenshots. GIMP tutorial screenshots. “How to remove a background” YouTube thumbnails. Stock-art preview panes. Marketplace listings for “transparent PNG” clip art, displayed with the checkerboard showing through. Design forum posts. Icon packs. The checkerboard is everywhere transparency is discussed, because the checkerboard is how transparency is shown.
And your specific instinct — that people have uploaded countless images “claiming to be a PNG but really a solid image with a faux checkered background” — is real, and it’s part of this. Plenty of flattened JPEGs with a checkerboard painted right into them get uploaded, mislabeled, and passed around as “transparent PNGs.” Sloppy exports. Screenshots saved as the wrong format. Listings where the seller never actually checked. That genuinely happens, constantly.
But the deliberate and accidental fakes are just one tributary into a much bigger river. The real issue is that the checkerboard is the universal representational convention for transparency, and the training-data web is saturated with the convention. The model didn’t need anyone to lie to it. It just needed to see, a few hundred million times, that the words “transparent background” go with that gray-and-white grid.
So that’s what it learned. It learned the costume. As one in-depth test put it bluntly, the model is effectively “drawing the visualization of transparency rather than creating it” — a failure not of your prompt, but of the model’s understanding at a deep level. You asked for transparency; it drew you the picture that the internet told it transparency looks like.
We invented the checkerboard to be helpful. It was a good convention — a clean, universal way to show “nothing here” on screens that can’t show nothing. And then we put it on enough images that a machine learned to mistake the map for the territory. We built a perfectly good signpost, planted millions of copies of it, and trained something to walk straight into the signpost instead of down the road. That’s the monster: not malice, just a helpful shorthand scaled past the point where the machine could tell shorthand from substance.
The twist: it’s now partly on purpose
Here’s the part that complicates the “we did it to ourselves by accident” story — because the latest models did it to us on purpose.
OpenAI’s newest image model, gpt-image-2, removed transparent backgrounds as an option entirely. The background setting only accepts “opaque” or “auto” now — “transparent” was taken out of the menu. Google’s flagship image model, Nano Banana Pro, never supported transparent backgrounds either. The two most-used image-generation engines in the industry both decided this “fundamental” feature wasn’t worth keeping.
The leading theory for why: these models are increasingly trained to complete a whole, realistic scene rather than to isolate a subject. The training objective rewards scene consistency — a believable, fully-rendered world — and a “cut this object out onto nothing” instruction runs against the grain of that. The supervision signal for transparency, in the words of one analysis, is “absent at the foundational level.” It’s a design tradeoff: better, more coherent scenes in exchange for no native cutouts.
So the checkerboard you get isn’t just an accident of training data anymore. It’s the visible symptom of a model that was deliberately built to think in finished scenes, handed a request it was deliberately not built to fulfill.
What actually works
The practical news is good. You can get true transparency — you just can’t always get it the obvious way.
Use the API’s background parameter, on the models that still support it. The gpt-image-1 family does expose a real setting — background: "transparent" in the image generation endpoint, which produces an actual alpha channel rather than a painted checkerboard. This is the cleanest path when transparency is non-negotiable, though note it’s a model-specific feature and the newest models have dropped it.
Generate on a solid color, then remove the background. Ask for a “pure white background” — not “transparent,” which triggers the checkerboard behavior — and then run the result through a background-removal tool. This works well for designs with clean, hard edges.
Use the two-render trick for soft edges. For glows, smoke, glass, or soft shadows that background removers tend to destroy, generate the same image twice — once on pure white, once on pure black — and let a tool compute the true alpha from the difference between them. A pixel that looks identical on both backgrounds is opaque; a pixel that changes a lot is transparent. The math recovers genuine, soft-edged transparency.
Stop saying “transparent” in the prompt. Counterintuitive, but the word itself is what summons the checkerboard. Describe the background you want as a solid color and handle the cutout downstream.
The throughline: don’t trust the checkerboard your image viewer shows you. Drop the file onto a bright red layer, or open it over a dark background. If a white or gray box appears around your subject, the transparency was never real.
The lesson worth keeping
This is a small, annoying problem with a big, useful lesson underneath it — and that lesson is the reason it belongs on this blog rather than a design forum.
Training data is a mirror. It reflects our conventions back at us — including the sloppy ones, the shorthand, the things “everybody knows” that were never actually written down. The checkerboard problem isn’t really about PNGs. It’s a clean, visible example of a thing that happens invisibly all over AI systems: the model learns the representation of a concept that’s common in human-made data, rather than the concept itself. It learns how we depict a thing, because depiction is what it can see.
For anyone building real workflows on top of AI — which is most businesses now, whether they’ve named it that or not — that’s the pattern to watch for. The model is fluent in our shorthand. It will confidently hand you the costume. It’s on you to check whether anyone’s inside.
Allen App Tools builds custom software and AI-assisted workflows for service businesses — and a big part of that work is knowing where the tools quietly lie to you. If you’re trying to figure out where AI genuinely speeds your team up and where it just looks like it does, book a call and let’s talk through it.