viol3's Texture Pixelizer: Bake PSX-Style Dithered Pixel Art in Unity

On November 1, 2026, independent developer viol3 announced viol3's Pixelizer, a Unity editor tool that bakes a dithered pixel-art look directly into a material's textures. The pitch is pointed: “Think of it as a free, open-source alternative to Puck's Pixelizer,” says the GitHub README. The tool is free and MIT-licensed, downloadable from viol333.itch.io/viol3s-pixelizer and installable from the git URL via Unity's Package Manager.

A note on sourcing, stated up front: this is a launch announcement, and the feature claims come from the author's own channels (the itch release post, the itch product page, and the GitHub README, all verified on the morning of publication). We found no independent hands-on review yet. Where the article says “according to the author,” it means exactly that.

Before / after from the author's README (github.com/viol3/texture-pixelizer, retrieved November 3, 2026). Scene model by elbolilloduro (CC0).

The Key Idea: Tones Come From the Texture Itself

The tool is aimed at retro / PSX-style 3D scenes, and its headline design decision is the Tone Bands mode. Instead of posterizing brightness against the fixed 0–255 range, it keeps the hue and splits brightness into a few bands across the texture's own brightness range (by default, the 1st to 99th percentile, with a minimum-range guard so nearly flat textures do not turn into pure noise). The result, in the author's words: “Soft shading on white objects becomes visible dithered bands instead of collapsing into one flat color.”

That is the exact failure mode of naive posterize-and-dither filters: a texture that lives entirely between brightness 220 and 255 falls into a single global band, so the dither pattern has nothing to work with and the surface goes flat. Spread the bands over the texture's own range and the same surface keeps its shading — visible as ordered-dithered bands between adjacent tones. The demonstration below is self-made, not tool output, but it encodes the same concept the tool implements:

Self-made demonstration of the concept, not tool output. Gradient spans brightness 185–255.

The dithering itself is ordered between the two nearest tones, so the pattern stays clearly visible even where the tones are close together. If you want the full theory on how ordered dithering threshold maps work, our ordered dithering deep dive covers Bayer matrices from first principles.

Palette, Patterns, and Downsampling That Keeps Detail

The Adaptive Palette mode builds a palette from the texture's own colors using k-means — the same clustering idea behind the median-cut and k-means quantization workflows we covered in our color quantization guide. Two more color modes are on offer: fixed levels per RGB channel, and a pixelation-only mode with no color reduction at all.

The dither pattern menu is generous: Bayer 2x2 / 4x4 / 8x8, blue noise, Floyd–Steinberg, and Atkinson, plus a randomness control to break up the regular grid, adaptive dithering that eases off in busy areas, and a seed for the random parts. Downsampling defaults to the Representative mode, which picks the real texel closest to each block's average instead of blending the block — the average would smear detail, and the center texel would jitter. Output textures are imported with Point filtering and no compression, because compression would smear the dither pattern. There are also the practical touches: Hard Alpha cutoff, optional mipmaps, and brightness/contrast/saturation adjustments applied before color reduction.

The Workflow: Component, Tune, Apply

Using it follows a short loop. Select an object, add the viol3 → Texture Pixelizer component, optionally drag in a source texture, tune the settings with the inspector's live preview, and press Apply. The tool writes <name>_pixelated.png next to the source texture and assigns it to the material's texture slot. It is non-destructive: the source texture is stored on the component and every Apply starts from it again, so you can re-tune freely; Revert to Original puts the source back. Multiple objects can be selected and applied at once, and material changes support undo.

Requirements are worth stating plainly, because this is not a universal pixel filter. You need Unity 2022.3 or newer (developed and tested on Unity 6), and the model must be UV-mapped with a real image texture on its material. Flat-color materials, vertex-colored models, and palette-atlas textures where each face maps to a single color cell are explicitly not supported — there are no tones inside a cell to dither, so faces stay flat. The tool works with any render pipeline, detecting the main texture automatically.

Scriptable — Including for AI Coding Agents

Everything the inspector does is available from code. A one-call C# API pixelizes assets or scene objects with a preset:

using Viol3.Pixelizer;
using Viol3.Pixelizer.Editor;

// A texture, material, prefab/model or a whole folder:
PixelizerApi.PixelizeAsset("Assets/Environment",
    PixelizePresets.Create(PixelizePreset.Strong));

// Add the component so it can be fine-tuned later in the inspector:
PixelizerApi.AddPixelizerComponent(myObject,
    PixelizePresets.Create(PixelizePreset.Organic));

There is also a batch-mode entry point that runs with the Unity window closed, so CI or scripts can pixelize whole prefabs or folders; the README notes you should not pass -nographics because reading textures needs a GPU device. Presets include Default, Subtle, Strong, Chunky, Organic, and LimitedPalette.

Most unusually, the repo ships AGENTS.md — instructions aimed directly at AI coding agents (Claude Code, Cursor, Copilot, Codex), telling them how to install the package into the user's project, run the batch pipeline, pick settings from natural-language requests (“bigger pixels→ pixelSize up”), and check results. The tooling itself is editor-only and has no runtime cost in builds. The rules are sensible: shared materials warn you before you edit them, embedded FBX/OBJ materials must be extracted first, and running Apply again always starts from the original.

Verdict: The Right Niche, Priced at Free

This is not a competitor to paint-it-yourself tools — it is for the specific, common problem of giving a 3D Unity scene a coherent retro look without hand-pixelizing every texture. The tone-band insight is the kind of small, correct idea that suggests the author has actually fought the white-object problem, and the non-destructive Apply loop plus batch scripting makes it fit production texture pipelines, not just one-off experiments.

The honest caveats: it is v0.0.5, launched two days ago, with no independent reviews yet — and the texture must exist in the first place, so vertex-colored and atlas-mapped workflows are out of scope. But the MIT license means there is no cost to trying it, and the GitHub repo documents every setting in full. If you are building a PSX-style scene in Unity, this is worth an afternoon of experimentation.