Loss Guide Cute

What Loss Guide Cute Actually Is

Loss Guide Cute is a small utility that most people in game dev and pixel art communities use to manage sprite transparency and rendering order. It strips the "cute" visual layer out of whatever workflow you are using and gives you a clean grid-based loss table you can import directly into Unity, Godot, or any engine that handles 2D sprite batching. You drop a PNG sheet in, it reads the alpha channel, outputs a CSV with per-pixel depth values, and you are done. I grab the latest release from the usual repository. The installer is basically a single ZIP file with a standalone executable and a small runtime DLL. I put it in a folder on my desktop, run it once to let it install its config files, and then close everything else so it does not get blocked by whichever antivirus is running that day. The download is lightweight. The program itself is around two megabytes, and it runs without elevation on a standard Windows install. If you are on Linux you can run it through Wine, though I have had better luck just installing it on a Windows VM when I need to share files with a teammate.

How to Use It Step by Step

Open the program and click the Load button. Select your sprite sheet. The interface shows a preview grid, and below that you see a table where each row corresponds to a tile or sprite. There are columns for X position, Y position, width, height, alpha threshold, and output depth. You do not need to fill all of them. The default alpha threshold is 128, which is the point where the program starts treating a pixel as transparent. After loading, I usually click the Analyze button. It scans the sheet and auto-fills the table based on what it finds. This takes about three seconds for a standard 256 by 256 sprite sheet. Once the table is populated, I check for any rows where the width or height comes out as zero. That means the program detected no opaque pixels in that region, which is usually a sign that the tile is completely transparent and can be removed from the export. To export, I go to the File menu and select Export CSV. The program asks whether to include only opaque tiles or all tiles with their alpha data. I almost always choose opaque tiles only, because the engine handles full transparency during batch rendering anyway. The resulting CSV is plain text with a header row, which makes it trivial to parse in any scripting language.

My Workflow for a Typical Project

I keep the sprite sheets in a folder called assets/sprites and place the exported CSVs in assets/gfx. When I switch to the engine, I write a small loader that reads the CSV and constructs a SpriteAtlas at runtime. This cuts my import time from about forty-five minutes down to roughly five minutes. The trade-off is that I have to rerun the CSV generation every time I update a sprite, which I do about twice a week on most projects. The program works well on clean PNG sheets. It struggles when the sprites contain anti-aliased edges that sit right at the alpha threshold, or when there are floating sub-pixel artifacts from a rushed export. I ran into this once with a tile set that had hand-painted soft edges. The auto-detection kept misclassifying entire rows as empty because the algorithm looked for contiguous opaque blocks larger than one pixel. The workaround was to raise the alpha threshold to 192 and re-scan. That forced the program to treat more pixels as opaque and correctly identify the edge regions. Another common issue is sheets that contain padding between sprites. Loss Guide Cute does not recognize padding as intentional separation unless you tell it to. You can manually enter a padding value in the settings dialog, but the default is zero, which means two sprites that visually share a row will sometimes get merged into a single output tile. I set padding to four pixels across the board now, and it has eliminated that problem for me entirely.

Loss Guide Cute Advanced Settings

There are a few toggles worth knowing about. The Merge Adjacent Tiles option combines neighboring sprites that share identical depth values into a single entry. This is useful when you have a large background element that spans multiple sprites and you want to render it as one batch. The option is off by default, but I turn it on whenever I am working with a level layout rather than character sprites. The Output Format dropdown controls whether the CSV uses comma or tab delimiters. The default is comma, which works with most engines. If you are using a Python-based pipeline or a custom importer, tab-separated values are easier to split without a proper CSV parser. I keep this set to tab for my own scripts. There is also a batch mode checkbox. When enabled, the program processes every PNG in a specified folder and outputs a single combined CSV. This saves me from running the tool thirty times when I have a thirty-sprite sheet. The batch mode has one quirk: it names the output rows sequentially across all files, so you lose the original file name information unless you enable the Include Filename option. I always enable that option now.

Common Pitfalls to Avoid

The biggest mistake I see people make is exporting at full alpha without adjusting the threshold after they update a sprite. The program caches its previous scan results, and if you do not clear the cache before reloading, you may end up working with stale data. The cache is stored in the user config folder, not inside the project folder. To clear it, I delete the file named lossguidecute.cache from %APPDATA%\LossGuideCute on Windows. On Linux it is in ~/.config/LossGuideCute. Another issue is mixing color profiles. The program assumes sRGB when reading alpha channels. If your sprites were created in a linear space or a different color profile, the threshold calculation will be off, and you will get artifacts along the edges of your sprites. I make sure every sprite sheet I import is converted to sRGB before feeding it into Loss Guide Cute. This usually means running a quick Color Management conversion in Krita or Photoshop before I ever open the program.

Alternatives and When to Use Them

If you are working with animated sprite sequences rather than static sheets, Loss Guide Cute is not the best tool. The program does not handle animation frame ordering. For animation management, I use a separate tool that exports JSON with per-frame bounding boxes. Loss Guide Cute handles the static case well, and I combine it with that animation tool when a project requires both. For projects that use tile-based rendering exclusively, there is also a command-line variant of the same program. I prefer the GUI version because the error reporting is clearer, but the CLI tool is faster for automated pipelines and runs headless on a build server. The CLI output is identical to the CSV export from the GUI, so you can swap between them without changing any downstream code.

Bottom Line

Loss Guide Cute is not a perfect solution. It has predictable blind spots around anti-aliasing and padding, and it assumes your sprites follow a regular grid. But for the vast majority of 2D sprite workflows, it does exactly what it claims to do, and it does it quickly. The configuration is straightforward, the export format is standard, and the program itself is small enough that it does not interfere with your system. If your sprites are clean and your grid is consistent, you should have a working pipeline within fifteen minutes of downloading it. For anything more complex, I recommend combining it with a preprocessing step that normalizes your alpha channels and enforces consistent padding. That extra step saves time in the long run, even if it adds a few minutes to your daily routine.