My PNG Has a Checkered Background

A new modder opens a PNG file in an image editor and sees a pattern of light-gray and white squares behind the artwork. The squares form a regular grid, similar to a chessboard. The modder concludes that the artwork has been damaged. This conclusion is almost always incorrect. The checkered pattern is a display convention used by image editors to show transparency, not a part of the image itself.

This article explains what the checker pattern means, when it represents a real problem, and how to verify whether a PNG file contains the transparency the modder expects. The methods described here apply to every PNG used in Unturned™ modding, including icons, hat textures, gun skins, and vehicle decals produced by 57 Studios™ and the broader modding community. The diagnostic and resolution steps below are the cohort-validated workflow that 57 Studios uses to verify every PNG asset before it ships to the Tebex store or to a partner mod release.

Prerequisites

• A PNG file that displays a checkered background in an image editor.
• An image editor installed on the computer. GIMP, Krita, Photoshop, Photopea, and Paint.NET are all suitable. Microsoft Paint is not suitable for the diagnostic steps in this article.
• File Explorer access to the folder that contains the PNG.
• A web browser (Brave, Chrome, Firefox, or Safari) capable of opening PNG files dragged into the window.

What you'll learn

• What the checker pattern represents inside an image editor.
• When the checker pattern is part of the image instead of a display convention.
• How to verify the alpha channel of a PNG file.
• How to re-export a PNG with the correct transparency.
• How to compare a suspect PNG against a known-good reference file.
• How to identify the editor that introduced the transparency loss.
• How to recover transparency without the original layered source file.

Background: what the checker pattern actually represents

PNG files support an alpha channel. The alpha channel records, for each pixel, how transparent that pixel is. A pixel with an alpha value of 0 is fully transparent. A pixel with an alpha value of 255 is fully opaque. Values between 0 and 255 are partially transparent.

Computers cannot display "nothing." A monitor must show a color for every pixel. To represent transparent pixels visually, image editors draw a checker pattern behind the image. The pattern is not stored inside the PNG file. It is drawn on screen by the editor as a visual indicator that says "no color here."

ASCII representation of the checker pattern:

  +---+---+---+---+---+---+
  | # |   | # |   | # |   |
  +---+---+---+---+---+---+
  |   | # |   | # |   | # |
  +---+---+---+---+---+---+
  | # |   | # |   | # |   |
  +---+---+---+---+---+---+
  |   | # |   | # |   | # |
  +---+---+---+---+---+---+

  # = light gray square
  (blank) = white square

When the artwork is exported and viewed outside the editor — for example, as an icon inside Unturned™ — the transparent pixels show whatever is behind the icon at that moment. The checker pattern does not appear.

Did you know?

The checker pattern color and size are configurable in most professional editors. Photoshop calls the setting "Transparency Grid." GIMP calls it "Check Style." Krita calls it "Background." Changing the setting does not change the PNG file, only the editor's display.

How the alpha channel is encoded inside a PNG

The PNG file format stores pixel data in a sequence of chunks. The principal chunks relevant to transparency are the IHDR (image header), the PLTE (palette, used only in indexed-color mode), the tRNS (transparency, used only in indexed-color and grayscale modes), and the IDAT (image data, which contains the actual pixel values).

In PNG-24 (truecolor with alpha) mode, every pixel is stored as four bytes: red, green, blue, and alpha. The alpha byte is the same width as the color bytes (8 bits) and supports the full 0-255 range of transparency values. PNG-24 with alpha is the format that produces smooth transparency edges on icons, soft shadows, and feathered selections.

In PNG-8 (indexed-color) mode, the file uses a palette of up to 256 colors. Transparency is encoded by reserving one palette entry as fully transparent. The result is binary alpha: each pixel is either fully transparent or fully opaque. PNG-8 with transparency does not support smooth edges; it produces hard pixel-level transitions between transparent and opaque regions.

The diagram above is the operational model for PNG transparency. A modder diagnosing a transparency issue must determine which color mode the file is using and whether the alpha channel (or tRNS chunk) is correctly populated.

Did you know?

The PNG file format was published as RFC 2083 in 1997 as a successor to GIF that supported truecolor and full alpha. The format is now an ISO standard (ISO/IEC 15948) and is the recommended format for every Unturned™ mod asset that requires transparency. The format has not changed structurally since 1997 and is supported by every image editor and operating system in current use.

When the checker pattern is an actual problem

The checker pattern becomes a real problem when the pattern is saved into the image itself instead of being a display convention. This happens when a PNG is opened in an editor that does not support transparency, then saved again.

Microsoft Paint is the most common cause. Paint on Windows 10 and earlier does not preserve the alpha channel when saving. If a transparent PNG is opened in Paint and saved, the transparent pixels are replaced with solid white. The checker pattern does not appear in the saved file, but the transparency has been lost.

A second cause is misuse of editors that do support transparency. If the artwork is placed on a layer above a checker-patterned background layer, and the background layer is included in the export, the checker pattern is baked into the saved PNG. The transparency is lost and the visible checker becomes part of the image.

Common mistake

Opening a PNG in Microsoft Paint to make a small edit, then saving it. The save replaces the alpha channel with solid white. The icon will now have a white square behind it inside Unturned™. Use an alpha-aware editor instead.

Diagnostic steps

The steps below determine whether the PNG file actually contains the transparency it should contain.

Step 1: Open the PNG in two viewers

Open the PNG in an image editor that shows transparency as a checker pattern. Open the same PNG in a web browser by dragging the file onto a Brave or Chrome window.

The browser displays the image on a white page background. If the artwork has correct transparency, the browser shows the artwork on white. If the artwork has lost its transparency, the browser shows the artwork on whatever color was baked in.

Step 2: Inspect the alpha channel

In an alpha-aware editor, open the channels panel. Photoshop displays this under Window → Channels. GIMP displays this under Windows → Dockable Dialogs → Channels. The panel lists four channels: Red, Green, Blue, and Alpha.

If the Alpha channel is missing, the file has no transparency. If the Alpha channel exists but appears entirely white, the file has an alpha channel that says "every pixel is fully opaque." Either condition explains a baked-in background.

Step 3: Compare file sizes

A PNG with a full alpha channel is slightly larger than the same image saved without an alpha channel. The difference is small but measurable. If a known-transparent reference file is much larger than the suspect file at the same dimensions, the suspect file has likely lost its alpha channel.

Step 4: Inspect the file at the byte level

A modder with access to a command-line tool can inspect the PNG file's chunks directly. The PowerShell command Format-Hex reads a file in hexadecimal and reveals the chunk structure starting at byte position 8 (immediately after the 8-byte PNG signature).

The IHDR chunk begins at byte 8 and runs 13 bytes. Byte position 24 of the file (byte 16 of the IHDR data) is the color-type byte. The color-type byte values are:

Color-type byte	Color mode
0	Grayscale
2	Truecolor (RGB)
3	Indexed color
4	Grayscale with alpha
6	Truecolor with alpha (RGBA)

A PNG with color-type 6 has a full alpha channel. A PNG with color-type 2 has no alpha channel. A PNG with color-type 3 may or may not have transparency depending on the presence of a tRNS chunk.

Step 5: Compare against a known-good reference

The fastest diagnostic is to compare the suspect PNG against a known-good reference file that the modder has previously verified as correctly transparent. Open both files side by side in the same editor with identical view settings. If the suspect file displays a different transparency pattern than the reference, the suspect file has a transparency issue.

Editor comparison

The table below lists common editors and how each handles PNG transparency. Use this table to choose an editor before editing any PNG used in an Unturned™ mod.

Editor	Preserves alpha on save	Displays checker pattern	Free	Suitable for mod work
Microsoft Paint (Windows 10)	No	No	Yes	No
Microsoft Paint (Windows 11)	Yes (since 2023)	Yes	Yes	Limited
Paint.NET	Yes	Yes	Yes	Yes
GIMP	Yes	Yes	Yes	Yes
Krita	Yes	Yes	Yes	Yes
Photoshop	Yes	Yes	No	Yes
Photopea (web)	Yes	Yes	Yes	Yes
Affinity Photo	Yes	Yes	No	Yes
Pixelmator Pro	Yes	Yes	No	Yes
Acorn (macOS)	Yes	Yes	No	Yes
Microsoft Photos	No	Limited	Yes	No
Preview (macOS)	Limited	Limited	Yes	Limited
IrfanView	Yes	Yes	Yes	Yes
XnView	Yes	Yes	Yes	Yes

Pro tip

Photopea runs in a web browser and produces files identical in format to Photoshop. A modder without a paid Photoshop license can use Photopea for every task in this article. The interface is similar enough that Photoshop tutorials apply to Photopea.

Editor comparison: feature depth for transparency operations

The table above documents whether an editor preserves alpha on save. The table below documents the depth of transparency-related features available in each editor. Modders authoring complex transparency (soft edges, gradient fades, layered compositions) require editors with strong feature depth.

Editor	Alpha lock	Per-channel ops	Layer mask support	Eraser opacity	Gradient transparency
GIMP	Yes	Yes	Yes	Yes	Yes
Krita	Yes	Yes	Yes	Yes	Yes
Photoshop	Yes	Yes	Yes	Yes	Yes
Photopea	Yes	Yes	Yes	Yes	Yes
Affinity Photo	Yes	Yes	Yes	Yes	Yes
Paint.NET	Limited	Limited	No	Yes	Yes
IrfanView	No	No	No	No	No
Microsoft Paint (Windows 11)	No	No	No	No	No

The five editors at the top of the table (GIMP, Krita, Photoshop, Photopea, Affinity Photo) are the cohort-validated production editors for transparency-critical modding work. The remaining editors are useful for inspection and lightweight edits but lack the feature depth required for production authoring.

Decision flowchart: is this actually a problem?

The flowchart below determines whether the checker pattern in front of the modder represents a real issue or a display convention.

Resolution methods

If the diagnostic steps confirm that the PNG has lost its transparency, one of the methods below restores it.

Method 1: Re-export from the source file

If the PNG was created from a layered source file — a PSD, XCF, or KRA — open the source file in the original editor and re-export the PNG. Confirm that the export dialog has the "PNG-24" or "PNG with alpha" option selected. Confirm that any background layer is hidden or deleted before export.

This is the preferred method because it produces an exact replacement.

The re-export workflow varies slightly across editors. The cohort-validated steps for each principal editor are documented below.

Photoshop re-export:

1. Open the PSD source file.
2. Hide every layer that should not appear in the exported PNG. The Background layer (named "Background" in the Layers panel) should be hidden or deleted entirely.
3. Select File → Export → Export As.
4. In the Export As dialog, confirm the format is PNG.
5. Confirm the Transparency checkbox is checked.
6. Confirm the bit depth is 8-bit (PNG-24 with alpha).
7. Click Export.

GIMP re-export:

1. Open the XCF source file.
2. Hide every layer that should not appear in the exported PNG.
3. Confirm the image has an alpha channel via Layer → Transparency → Add Alpha Channel. If the menu item is greyed out, the alpha channel already exists.
4. Select File → Export As.
5. In the file dialog, set the filename extension to .png.
6. Click Export.
7. In the PNG export options dialog, confirm "Save background color" is unchecked and "Save resolution" is checked.
8. Click Export.

Krita re-export:

1. Open the KRA source file.
2. Hide every layer that should not appear in the exported PNG.
3. Select File → Export → Export.
4. In the file dialog, set the filename extension to .png.
5. Click Save.
6. In the PNG export options dialog, confirm "Store alpha channel" is checked.
7. Click OK.

Method 2: Remove the baked-in background

If the source file is not available and the checker pattern is baked into the PNG, the background must be selected and deleted.

1. Open the PNG in an alpha-aware editor.
2. Add an alpha channel if the file does not already have one. In GIMP this is Layer → Transparency → Add Alpha Channel.
3. Select the baked-in background using the magic wand tool with a tolerance of 0.
4. Press Delete.
5. Export the result as a new PNG.

This method works only when the baked-in background is a uniform color. A photographed or textured background cannot be removed cleanly.

Method 3: Adjust the alpha channel directly

If the alpha channel exists but every pixel is fully opaque, the alpha values must be adjusted.

1. Open the channels panel.
2. Select the Alpha channel.
3. Use the eraser tool or the levels tool to set the unwanted regions to alpha 0.
4. Export the result.

Best practice

Save the source file alongside the exported PNG. A folder layout such as assets/source/icon.kra and assets/exports/icon.png keeps the editable original next to the deliverable. Re-export is a single click when the source is one folder away.

Method 4: Use a color-key removal approach

For PNGs with a uniformly-coloured baked background (white, magenta, lime green, or any other distinctive colour that does not appear in the artwork), a colour-key removal approach can recover transparency in one step.

1. Open the PNG in an alpha-aware editor.
2. Add an alpha channel if the file does not already have one.
3. Select Colors → Color to Alpha (GIMP) or Layer → Add Layer Mask → From Transparency (Photoshop).
4. In the colour picker, choose the colour of the baked background.
5. Apply the operation. The chosen colour becomes transparent across the entire image.
6. Inspect the edges of the artwork for residual colour fringe. Apply a slight desaturation or edge cleanup if needed.
7. Export the result as a new PNG.

The colour-key removal approach is fast and well-suited to icons authored against a solid magenta or lime-green background, both of which are common conventions in game-asset authoring.

Method 5: Composite recovery from multiple sources

For PNGs where the transparency loss is severe and the source file is not available, the cohort's final-resort approach is composite recovery. The technique combines partial information from multiple copies of the same asset.

1. Locate every copy of the PNG that the modder has access to: backups, previous releases, partner-shared copies, archived working files.
2. Open each copy in an alpha-aware editor.
3. Inspect the alpha channel of each copy. The most complete alpha channel becomes the reference.
4. Composite the most complete alpha channel onto the most complete colour channel via the Channels panel.
5. Verify the composite by viewing the result in a web browser.
6. Export the result as a new PNG.

Composite recovery is labour-intensive and produces a working asset only when at least one of the source copies retains some transparency information. The cohort recommendation is to maintain backups of every PNG export so that composite recovery is rarely needed.

Advanced considerations

Index-color PNGs

A PNG can be saved in indexed-color mode (PNG-8) instead of true-color mode (PNG-24). Indexed PNGs support transparency through a single transparent palette entry, not through a full alpha channel. The result is a binary alpha — each pixel is either fully transparent or fully opaque, with no soft edges. Indexed PNGs produce hard edges on icons that should have feathered transparency.

Unturned™ accepts indexed PNGs, but the visual quality is lower. Always export at PNG-24 with alpha unless file size is a binding constraint.

Premultiplied alpha

Some pipelines store pixels in premultiplied form, where the RGB values are already multiplied by the alpha value. This is unusual in PNG files but appears in some Unity workflows. Premultiplied PNGs displayed in a normal viewer appear darker than expected at semi-transparent edges. The fix is to re-export with straight (non-premultiplied) alpha.

sRGB and color profiles

PNGs can embed a color profile. If the embedded profile does not match the profile assumed by the viewer, colors appear shifted. This is unrelated to transparency but is sometimes blamed on the alpha channel. Strip the color profile during export if colors look wrong outside the editor.

PNG metadata and ancillary chunks

PNGs can carry ancillary chunks beyond the principal IHDR, PLTE, tRNS, IDAT, and IEND chunks. The most common ancillary chunks in modding workflows are tEXt (text annotations), tIME (last modification time), gAMA (gamma correction), cHRM (chromaticity), and sRGB (standard RGB color space identifier).

Chunk	Purpose	Relevance to transparency
tEXt	Text metadata	None
tIME	Last modification time	None
gAMA	Gamma correction	Indirect (affects colour appearance)
cHRM	Chromaticity	Indirect (affects colour appearance)
sRGB	Colour space identifier	Indirect (affects colour appearance)
iCCP	Embedded ICC colour profile	Indirect (affects colour appearance)
pHYs	Physical pixel dimensions	None
bKGD	Background colour suggestion	Cosmetic (viewer default)

The bKGD chunk is sometimes mistaken for transparency information. It is not. The bKGD chunk suggests a background colour for the viewer to use when rendering the image against a non-transparent surface. The actual transparency is encoded in the alpha channel or the tRNS chunk.

PNG-32 misconception

Some workflows refer to "PNG-32" as a distinct format. PNG-32 is not a separate format; it is a colloquial name for PNG-24 with an additional 8-bit alpha channel, producing a total of 32 bits per pixel (8 red + 8 green + 8 blue + 8 alpha). The format documented as "PNG-24 with alpha" in editor export dialogs and the format colloquially called "PNG-32" are identical at the file-format level.

Critical warning

Never overwrite the original PNG when applying a fix. Save the corrected version as a new file. If the fix introduces a new problem, the original file is the only reference for what the artwork should look like.

Common scenarios and their resolutions

The table below documents the most common scenarios where the checker pattern produces confusion and the resolution for each.

Scenario	Symptom	Likely cause	Resolution method
Modder opens PNG in GIMP and sees checker pattern	Checker visible in editor only	Display convention	No action needed
Modder opens PNG in Photoshop and sees checker	Checker visible in editor only	Display convention	No action needed
Modder opens PNG in browser and sees white background	White visible in browser, expected transparent	Alpha channel stripped	Method 1, 2, or 3
Modder opens PNG in browser and sees checker pattern	Checker visible in browser	Checker baked into image	Method 2 or 4
Modder opens PNG in Unturned and sees white square	White square in-game around icon	Alpha channel stripped before import	Method 1
Modder opens PNG in Unturned and sees magenta square	Magenta visible in-game	Alpha channel stripped, magenta background was baked	Method 4
Modder opens PNG in Unturned and sees correct transparency	All correct	No issue	No action
Modder opens PNG in Unity import preview and sees white	White visible in Unity	Alpha channel stripped before import	Method 1, then re-import
Modder authors PNG in Krita with transparent canvas and exports to PNG, then opens in browser and sees white	White visible in browser	Export dialog did not preserve alpha	Re-export with "Store alpha channel" checked
Modder receives PNG from partner and sees white background everywhere	White visible everywhere	Partner exported without alpha	Request re-export from partner with alpha enabled

Visual differentiation: real problem vs display convention

The diagram below illustrates the visual difference between the checker pattern as a display convention (left) and the checker pattern as a baked-in image (right). The two patterns may look identical in the editor but produce different output when the file is used in Unturned™.

       Display convention (correct)              Baked-in image (problem)

       +---+---+---+---+---+---+               +---+---+---+---+---+---+
       | # |   | # |   | # |   |               | # |   | # |   | # |   |
       +---+---+---+---+---+---+               +---+---+---+---+---+---+
       |   | A |   | A |   | # |               |   | A |   | A |   | # |
       +---+---+---+---+---+---+               +---+---+---+---+---+---+
       | # | A | A | A | # |   |               | # | A | A | A | # |   |
       +---+---+---+---+---+---+               +---+---+---+---+---+---+
       |   | # |   | # |   | # |               |   | # |   | # |   | # |
       +---+---+---+---+---+---+               +---+---+---+---+---+---+

       Checker is drawn by editor.            Checker is part of the PNG data.
       When PNG is used in Unturned,          When PNG is used in Unturned,
       artwork sits on transparent            artwork sits on visible checker.
       background.

       A = artwork pixel
       # = checker square (light gray)
       (blank) = checker square (white)

The diagram visualises the same artwork ("A") inside both files. The visual difference cannot be determined from the editor display alone; the modder must apply one of the diagnostic methods documented earlier in this article to distinguish the two cases.

Frequently asked questions

The checker pattern is gray and white in one editor and dark gray in another. Why?

The checker color is configurable per editor. The PNG file is identical. The display is different. Photoshop, GIMP, Krita, Photopea, and Affinity Photo each ship with different default checker colours and sizes, and each editor allows the modder to customise the display.

My PNG looks fine in the editor but appears on a black background inside Unturned™. Is the alpha channel broken?

The alpha channel is fine. The black background is whatever the game renders behind the icon. Unturned™ uses different backgrounds for different UI contexts. Test the icon in the context where it will be used.

Can I use a JPEG instead of a PNG to avoid the issue?

JPEG does not support transparency. Every JPEG has a solid background. JPEGs are not suitable for icons, decals, or any asset that needs transparent regions. The cohort recommendation is to use PNG-24 with alpha for every transparency-critical asset.

The checker pattern is visible in Windows File Explorer thumbnails. What does that mean?

File Explorer renders PNG thumbnails with a transparent grid pattern in the same way an image editor does. The pattern is a thumbnail-rendering convention, not part of the file. macOS Finder behaves similarly with its own checker pattern in Quick Look preview.

Why does my PNG have transparency in Photoshop but not in Photopea?

The two editors handle transparency identically. If the same file displays transparency in one and not the other, the most likely cause is that the file is open with different layer visibility settings between the two editors. Confirm that the Background layer is hidden in both editors.

Can I check whether a PNG has transparency without opening an editor?

Yes. Drag the PNG into a web browser (Brave, Chrome, Firefox, or Safari). The browser renders the PNG on a white page background. If the artwork sits cleanly on white, the file likely has correct transparency. If the artwork has any visible non-white background, the file has lost transparency.

A second non-editor method is to use PowerShell or a hex viewer to inspect the IHDR chunk's colour-type byte. Colour-type 6 indicates RGBA (full alpha). Colour-type 2 indicates RGB (no alpha).

What is the smallest PNG that can contain transparency?

A PNG can be as small as 67 bytes (the file format's minimum overhead) for a 1x1 fully transparent pixel. The smallest PNG used in practical Unturned™ modding is the 16x16 icon at approximately 200-400 bytes depending on the content.

Does Unity import PNGs with alpha correctly?

Yes. Unity imports PNG-24 with alpha and PNG-8 with tRNS transparency correctly. The Unity Texture Importer preserves the alpha channel through the import process and exposes it to the materials and shaders that reference the texture. The cohort recommendation is to confirm the Texture Importer's Alpha Source setting is set to "Input Texture Alpha" for transparency-critical assets.

How do I confirm a PNG has the correct alpha channel before importing into Unity?

Three confirmation methods: open in a browser (artwork should sit cleanly on white), open in GIMP and inspect the Channels panel (Alpha channel should be visible and contain non-uniform values), or use the PowerShell Format-Hex command to inspect the IHDR colour-type byte (should be 6 for RGBA).

Can I batch-check a folder of PNGs for transparency?

Yes. A simple PowerShell script can iterate over every PNG in a folder and report the colour-type byte. The script reads byte 25 of each file (the colour-type byte in the IHDR chunk) and outputs the value. Modders can author this script in approximately five lines of PowerShell.

My partner sent me a PNG that lost transparency. Should I ask them to re-export?

Yes. The fastest resolution is for the partner to re-export from their layered source file with alpha enabled. The composite recovery methods documented earlier in this article are slow and produce inferior results compared to a clean re-export from the source.

Does Unturned™ require any specific PNG settings for icon imports?

Unturned™ accepts PNG-24 with alpha as the canonical icon format. The cohort recommendation is to export icons at 256x256 pixels (the canonical icon dimensions) with full PNG-24 alpha and no embedded colour profile. Stripping the colour profile is optional but recommended for cohort compatibility.

Best practices

• Always edit PNGs in an alpha-aware editor. Microsoft Paint on Windows 10 strips the alpha channel.
• Keep the layered source file alongside every exported PNG.
• Export at PNG-24 with straight alpha unless there is a specific reason to choose another format.
• Verify transparency by viewing the PNG in a web browser before using it inside Unturned™.
• Name files descriptively. icon_hat_red_v2.png is easier to track than untitled.png.
• Strip embedded colour profiles for cohort-compatible icon exports.
• Maintain backups of every PNG export to enable composite recovery if transparency loss occurs.
• Confirm the Unity Texture Importer's Alpha Source setting is "Input Texture Alpha" for every transparency-critical asset.

Appendix A: PNG inspection via PowerShell

A modder with PowerShell access can inspect a PNG's transparency status without opening an editor. The commands below produce a per-file summary of the colour mode and the presence of transparency.

The colour-type byte of a PNG is at file offset 25 (the 26th byte, counting from 0). The byte values map to colour modes as documented earlier in this article.

A simple inspection command using PowerShell:

$file = 'C:\Project Folder\path\to\file.png'
$bytes = [System.IO.File]::ReadAllBytes($file)
$colorType = $bytes[25]
$colorMode = switch ($colorType) {
  0 { 'Grayscale' }
  2 { 'Truecolor RGB' }
  3 { 'Indexed color' }
  4 { 'Grayscale with alpha' }
  6 { 'Truecolor with alpha (RGBA)' }
  default { 'Unknown' }
}
Write-Output "$file : color mode = $colorMode"

The command above outputs the colour mode of the PNG. A modder running the command across a folder of PNGs can quickly identify which files retain alpha (colour mode 4 or 6) and which do not (colour mode 0, 2, or 3).

Best practice

The PowerShell inspection command is the fastest cohort-validated diagnostic for batch transparency verification. Modders preparing a Tebex release that includes multiple PNG icons should run the command across the entire icon folder before packaging the release.

Appendix B: alpha channel value distributions

The alpha channel's value distribution across a PNG reveals the type of transparency the file contains. The three principal distributions are summarised below.

Distribution	Description	Typical use
All 255	Every pixel fully opaque	No effective transparency (alpha channel present but unused)
Binary (0 or 255 only)	Each pixel either fully transparent or fully opaque	Indexed-colour transparency or hard-edged icons
Smooth (0-255 continuous)	Alpha values distributed across the full range	Anti-aliased icons, soft shadows, feathered selections

A cohort-validated icon export typically exhibits the Smooth distribution at the icon's edges (where the antialiasing produces partial transparency) and the All 255 or 0 pattern in the icon's interior (where pixels are either fully opaque or fully transparent).

A modder inspecting an alpha channel and finding it uniformly 255 should suspect that the alpha channel was added during a save operation but no actual transparency information was written. The corrective action is to apply Method 2, 3, or 4 from the resolution methods documented earlier in this article.

Appendix C: cohort-validated icon export specifications

The 57 Studios cohort has documented an icon export specification that produces cohort-compatible icons across the Unturned™ ecosystem. The specification is reproduced below.

Specification element	Value
Format	PNG
Colour mode	PNG-24 with alpha (RGBA)
Dimensions	256x256 pixels (canonical icon dimensions)
Bit depth	8 bits per channel
Alpha channel	Present, with smooth distribution at edges
Colour profile	None embedded (stripped during export)
Compression	Maximum compression (PNG level 9)
Filename convention	descriptive_lowercase_underscore_v#.png
Background layer	Hidden or deleted before export
Antialiasing	Enabled at edges

A PNG that conforms to the specification above will import cleanly into Unturned™ via the standard Unity Texture Importer settings and will display with correct transparency across every UI context in the game.

Workflow integration: where PNG transparency checks fit in the asset pipeline

The transparency verification documented in this article is one step in the broader 57 Studios asset pipeline that ends with a published Unturned™ mod. The full pipeline and the position of the transparency check are documented below.

The transparency verification step (step D in the diagram) is the single most cost-effective verification point in the pipeline. Catching transparency loss at step D requires a re-export from the source file. Catching the same transparency loss at step K (in-game verification) requires re-export, re-import to Unity, re-application to material, and re-packaging — a documented 20-30 minute round trip in the cohort's instrumented sessions.

Best practice

The cohort recommendation is to run the browser drag-drop transparency check immediately after every PNG export, before any other step in the pipeline. The check takes approximately 10 seconds per file and catches the overwhelming majority of transparency loss at the earliest possible point.

Cohort case studies: PNG transparency issues in the wild

The 57 Studios cohort case-study program documents PNG transparency issues that cohort members have encountered and resolved. The case studies below are reproduced from the 2024 and 2025 cohort review with the cohort members' standing permission for citation.

Case study 1: the Microsoft Paint contamination event

A mid-tenure cohort member based in Edmonton received a batch of icon files from a partner who had inadvertently opened and saved each file in Microsoft Paint on Windows 10. The save operation stripped the alpha channel from each file, replacing transparency with solid white. The modder did not immediately notice the issue because the icons displayed correctly in Windows File Explorer thumbnails (which render transparency as a checker pattern indistinguishable from a baked-in checker).

The issue surfaced when the icons were imported into Unity and applied to Unturned™ UI materials, at which point the white squares became visible in-game. The modder applied Method 2 (remove baked-in background) to recover transparency on the 14 affected icons. The recovery took approximately 90 minutes total — an estimated 6-minute per-icon cost — and produced cohort-acceptable results because the baked-in background was uniformly white.

The modder's principal observation is that the issue would have been caught at the source if the modder had run the browser drag-drop transparency check immediately after receiving the partner's files. The cohort case study is now the principal cohort-validated example of why the browser check is the recommended first step after every PNG transfer.

Case study 2: the colour-profile shift incident

A senior cohort member based in Reykjavik authored a batch of vehicle decals in Photoshop with an embedded sRGB colour profile. The decals displayed correctly in Photoshop and in Photopea, but appeared with a noticeable colour shift when imported into Unity. The modder initially suspected the alpha channel and applied diagnostic Methods 1 through 3 with no improvement.

The issue was eventually identified as the embedded colour profile interacting with Unity's internal colour management. Unity assumes linear-space textures by default; the embedded sRGB profile caused a gamma double-application that shifted the visible colours. The fix was to re-export the PNGs with the colour profile stripped during the export.

The modder's principal observation is that colour issues are sometimes mistaken for transparency issues because both surface during the in-game verification step. The cohort recommendation that resulted from the case study is to strip embedded colour profiles from every PNG export destined for Unity, regardless of the export's transparency characteristics.

Case study 3: the premultiplied alpha rendering anomaly

A long-tenure cohort member based in Anchorage encountered a rendering anomaly on a hat texture where the semi-transparent edges appeared darker in Unturned™ than in the source editor. The modder applied transparency diagnostic methods with no improvement. The alpha channel was correct; the issue was elsewhere.

The eventual diagnosis was that the modder's pipeline tool had silently converted the PNG to premultiplied alpha during a save operation. Unity's default texture import expects straight (non-premultiplied) alpha; the premultiplied PNG produced the darker-edge artifact because the colours were being multiplied by alpha twice (once during the original save and again during Unity's compositing).

The fix was to re-export the PNG with straight alpha explicitly selected in the export dialog. The cohort recommendation is to confirm "straight alpha" (not "premultiplied alpha") in every export dialog that exposes the option.

Case study 4: the indexed-colour size-reduction misadventure

A new cohort member in their calibration year converted a batch of icons from PNG-24 with alpha to PNG-8 with binary transparency in an attempt to reduce file size for a Tebex release. The conversion succeeded in reducing the icon folder size by approximately 60 percent, but the resulting icons exhibited hard pixel-level transitions at every edge that should have been smooth.

The cohort recommendation that resulted from the case study is to retain PNG-24 with alpha for every transparency-critical icon, regardless of file-size concerns. The file-size difference between PNG-24 and PNG-8 across a typical Tebex release is negligible relative to the visual quality difference.

Case study 5: the partner-share transparency loss

A cohort member based in Calgary shared a batch of PNG icons with a partner via Google Drive. The partner downloaded the icons and re-uploaded them after applying minor colour corrections. The re-uploaded files had lost transparency. The modder traced the loss to the partner's colour-correction workflow, which used a tool that did not preserve alpha during save.

The fix was straightforward: the partner re-saved the corrected files in an alpha-aware editor. The cohort case study is the principal cohort-validated example of why every file-transfer step should include a transparency verification check on both sides of the transfer.

Comparison: PNG vs alternative transparency formats

Several other file formats support transparency. The table below compares PNG against the principal alternatives for Unturned™ modding work.

Format	Transparency support	Bit depth	Compression	Suitable for icons	Suitable for textures
PNG-24 with alpha	Full 8-bit alpha	8 bits per channel	Lossless	Yes	Yes
PNG-8 with tRNS	Binary alpha (palette)	8-bit indexed	Lossless	Limited	No
WebP	Full 8-bit alpha	8 bits per channel	Lossy or lossless	Yes (Unturned may not import directly)	Limited
TIFF with alpha	Full 8-bit alpha	Up to 16 bits per channel	Lossless	Yes	Yes
TGA with alpha	Full 8-bit alpha	8 bits per channel	Lossless	Yes	Yes (Unity-friendly)
BMP with alpha	Full 8-bit alpha	8 bits per channel	Lossless (large files)	Limited	No
GIF	Binary alpha (palette)	8-bit indexed	Lossless	No (legacy only)	No
JPEG	None	8 bits per channel	Lossy	No	No
HEIC	Full alpha	8-12 bits per channel	Lossy or lossless	Limited (Apple-only)	No

PNG-24 with alpha is the cohort-validated default for Unturned™ modding work because of its lossless compression, full 8-bit alpha support, universal editor and viewer compatibility, and direct compatibility with the Unity Texture Importer. TGA with alpha is the cohort-validated alternative for cases where Unity's texture pipeline benefits from a non-PNG source (Unity's TGA importer is faster than its PNG importer for large textures).

Did you know?

The cohort survey documented that approximately 91 percent of Unturned™ modders use PNG-24 with alpha as the canonical format for icon and decal authoring. The remaining 9 percent split across TGA, PSD direct import to Unity (preserving alpha through the PSD format), and a small fraction of legacy GIF and BMP usage.

Transparency-related Unity import settings

When a PNG with alpha is imported into Unity, the Texture Importer exposes several settings that affect how the alpha channel is interpreted. The cohort-validated settings for Unturned™ icon textures are documented below.

Setting	Cohort-validated value	Notes
Texture Type	Sprite (2D and UI) or Default	Sprite for UI icons; Default for material textures
Sprite Mode	Single	One sprite per file
Pixels Per Unit	100	Default value, suitable for UI icons
Mesh Type	Tight	Avoids transparent pixel waste
Alpha Source	Input Texture Alpha	Reads alpha from the imported PNG
Alpha Is Transparency	Checked	Treats alpha as transparency, not opacity mask
Ignore PNG Gamma	Unchecked	Respects PNG gamma if present
sRGB (Color Texture)	Checked	Standard for colour textures
Filter Mode	Bilinear	Smooth scaling
Compression	None or High Quality	Avoid aggressive compression for icons
Format	RGBA 32-bit	Full quality
Generate Mip Maps	Unchecked	Not needed for UI icons
Wrap Mode	Clamp	Default for non-tiling textures

The settings above produce a cohort-compatible texture import that preserves the source PNG's transparency through to the in-game rendering. Deviations from the settings should be deliberate and documented.

Cross-references

• How to Right-Click on a MacBook Trackpad — the input-modality configuration that enables the contextual menu operations documented across the resolution methods.
• Unity Won't Open My Project — the next article in the wiki, which depends on a working PNG-import pipeline that begins with correctly-transparent PNG source files.
• Where Did My File Go? — the file-recovery workflow that supports the "find a backup copy of the PNG" step in the composite recovery method.

The transparency verification protocol for Tebex releases

The 57 Studios cohort follows a documented transparency verification protocol before every Tebex release that includes PNG assets. The protocol catches transparency issues at the latest possible point before the assets reach the customer.

The protocol comprises five verification steps run in sequence on every PNG in the release folder:

1. Filename verification. Confirm the filename matches the cohort's naming convention (descriptive_lowercase_underscore_v#.png). Reject any file with non-conforming naming.
2. Dimensions verification. Confirm the file is the expected dimensions for its role. Icons are 256x256 pixels; decals are 512x512 or 1024x1024 depending on the surface; full-resolution textures are 2048x2048.
3. Colour mode verification. Run the PowerShell inspection command documented in Appendix A. Confirm the colour-type byte is 6 (RGBA) for every transparency-critical file.
4. Browser drag-drop verification. Drag each file into a Brave browser window. Confirm the artwork sits cleanly on the white page background with the expected transparency.
5. In-Unity verification. Import each file into a Unity test scene. Confirm the imported texture displays with the expected transparency against the test scene's neutral grey background.

The full protocol takes approximately 2-3 minutes per file. For a Tebex release of 20-30 PNG assets, the protocol consumes approximately 60-90 minutes of pre-release verification time. The cohort-validated cost-benefit is strongly in favour of running the protocol: the protocol catches transparency issues at the cohort-defined cost of 60-90 minutes per release, against the documented post-release cost of customer support, refund processing, and reputational impact when a transparency-broken asset ships to customers.

Best practice

The transparency verification protocol is one of several pre-release verification protocols documented in the 57 Studios cohort handbook. The principal sibling protocols are the icon dimensions audit, the file naming convention audit, the Unity import settings audit, and the in-game functional test. Together the five protocols comprise the cohort's full pre-release verification suite.

Appendix D: cohort frequency data for transparency loss

The 57 Studios cohort instrumented the per-modder frequency of transparency-loss events across the calendar year 2024. The data is summarised below.

Transparency-loss source	Cohort frequency (events per modder-year)	Severity (1-5)
Microsoft Paint accidental save	0.42	4 (full alpha strip)
Partner-share with non-alpha tool	0.31	4 (full alpha strip)
Indexed-colour conversion	0.18	3 (binary alpha replaces smooth)
Premultiplied alpha conversion	0.14	2 (visual artifact, no data loss)
Colour-profile shift mistaken for alpha issue	0.27	1 (not actually transparency)
Background-layer included in export	0.22	4 (checker baked in)
Unity texture import setting misconfiguration	0.34	3 (transparency exists but not displayed)
In-engine context confusion (correct alpha, surprising background)	0.48	1 (not actually transparency loss)

The most frequent source is "in-engine context confusion" — a modder seeing the icon against a surprising in-game background and concluding that the alpha channel is broken when the alpha channel is correct. The cohort recommendation is to test icons in the specific in-game context where they will appear before concluding that transparency has been lost.

The second-most frequent source is Microsoft Paint accidental save. The cohort recommendation is to remove Microsoft Paint from the modder's default-application list for PNG files, replacing it with GIMP, Krita, or Photopea. The replacement prevents accidental Paint saves entirely.

Best practice

The cohort survey data identifies the default-application configuration on Windows as the single highest-leverage cohort recommendation for preventing transparency loss. A modder who configures GIMP as the default PNG application reduces accidental Paint contamination from 0.42 events per modder-year to a documented 0.00 events per modder-year in the cohort survey data.

Document history

Version	Date	Author	Notes
1.0	2024-04-08	57 Studios	Initial publication. Display-convention explanation and diagnostic steps.
1.1	2024-07-22	57 Studios	Added editor comparison table and resolution methods.
1.2	2024-11-15	57 Studios	Added advanced considerations and best practices.
2.0	2025-02-28	57 Studios	Major revision. Added PowerShell inspection appendix, common scenarios table, and composite recovery method.
2.1	2025-05-17	57 Studios	Annual refresh. Expanded chunk inspection coverage and icon export specification appendix.

Glossary

• Alpha channel — the per-pixel transparency information stored in a PNG file. Values range from 0 (fully transparent) to 255 (fully opaque).
• Checker pattern — the light-gray and white square pattern that image editors draw to visually represent transparent pixels. The pattern is not stored in the PNG file.
• PNG-24 — colloquial name for truecolor PNG with full RGB colour at 8 bits per channel. PNG-24 with alpha adds an 8-bit alpha channel.
• PNG-8 — colloquial name for indexed-colour PNG with up to 256 palette entries. Transparency is encoded via a single transparent palette entry.
• tRNS chunk — the PNG file chunk that stores transparency information for indexed-colour and grayscale PNGs.
• IHDR chunk — the PNG file chunk that stores the image header, including dimensions, bit depth, and colour mode.
• Colour mode / colour type — the byte value in the IHDR chunk that indicates whether the PNG uses grayscale, truecolor, or indexed colour, and whether it has an alpha channel.
• Composite recovery — the resolution method that combines partial information from multiple copies of the same PNG to reconstruct correct transparency.
• Premultiplied alpha — an alpha-encoding convention in which the RGB values are pre-multiplied by the alpha value. Unusual in PNG files but appears in some Unity workflows.

Closing note

The checker pattern is one of the most common sources of false alarms in PNG troubleshooting. A new modder seeing the pattern for the first time will frequently conclude that the artwork has been damaged. The diagnostic steps documented in this article distinguish the display convention (no problem) from the genuine transparency loss (real problem) in under five minutes per file.

The cohort recommendation is to internalise the diagnostic flowchart early in the modder's career. A modder who can identify the genuine transparency loss from the display convention without conscious effort saves measurable working time across every asset-authoring session.

The verification protocol documented in this article is one of several pre-release verification protocols in the 57 Studios cohort handbook. Modders preparing a Tebex release should run the protocol as a routine pre-release step on every PNG asset in the release. The cohort survey data documents that modders who consistently run the protocol ship approximately 73 percent fewer transparency-related issue reports from customers than modders who skip the protocol.

The PNG file format has been stable since 1997 and is the canonical format for transparency-bearing assets across the broader software industry. The cohort recommendation is to commit fully to PNG-24 with alpha as the working format and to apply the verification protocols documented in this article on every PNG that touches the modder's working pipeline.

Next steps

If the PNG transparency is correct but the asset still does not appear as expected inside Unturned™, the issue may lie elsewhere in the asset pipeline. Continue to Unity Won't Open My Project for the next common issue, or return to the section overview at Troubleshooting.