Ultimate Colorizer - Palette Swap, Recoloring & Material Variants

Create faction colors, rarity variants, outfit dyes, palette swaps, material variants and reskinned Tilemaps without duplicating your source art.

Ultimate Colorizer is a non-destructive recoloring and runtime character-customization toolkit for Unity. Define changes once in a reusable RecolorProfile, then apply them through no-code components, Editor tools, batch processing or the documented C# API.

Demo Showcase | View Online Documentation

Your original assets stay untouched:

• Runtime material recoloring uses MaterialPropertyBlock, so shared materials are not mutated.

• Texture operations generate new copies and leave source textures unchanged.

• Tilemap colors are stored per cell instead of being written into shared tile assets.

• Material variants are created as separate materials.

When the base artwork changes, rerun the profile to regenerate its color variants.

Use Ultimate Colorizer for texture and sprite recoloring, team or faction colors, rarity palettes, equipment dyes, character creators, cosmetic systems, material variants and recolored tilesets.

Try it before you buy it.

The interactive WebGL showcase contains eight hands-on labs covering live texture recoloring, mask previews, palette and harmony generation, shader analysis, mesh and Tilemap recoloring, character dye channels, cosmetic slots, batch processing and SDK discovery.

No-code or fully scripted

For the shortest setup, add an Ultimate Colorizer component, assign a target, choose a color or profile, enable Apply On Start, and press Play.

The same recoloring engine is available through a documented C# API. Automatic application defaults to off and does not overwrite a state already applied from code, so existing customization systems can adopt the package gradually.

Texture and sprite recoloring

Create deterministic texture and sprite variants with:

• Color replacement with configurable tolerance

• RGB, weighted RGB and CIE76-approximation distance modes

• Palette remapping

• Hue, saturation and value adjustments

• Tint and multiply

• Gradient maps

• 1D LUT mapping

• Sprite-rect and sprite-sheet recoloring

• Contact-sheet generation

Masks are first-class data, with threshold, channel, UV-rectangle, dilate, erode and combine operations.

All texture processing runs locally on the CPU. The same source, profile and settings produce the same output, making the workflow suitable for repeatable Editor jobs and automation.

Palettes and local color analysis

Create reusable PaletteAsset libraries with named, role-tagged colors, contrast checks and duplicate validation.

Ten harmony and palette-generation modes are included: complementary, analogous, triadic, monochrome, value ramp, split-complementary, tetradic, saturation ramp, warm and cool.

PaletteJsonUtility imports and exports the same JSON format used by the runtime API, so palettes can move between projects and tools.

Smart color analysis clusters a texture's dominant colors and classifies practical starting roles such as skin, cloth, metal, emission, shadow, highlight, warm, cool and neutral. It runs locally and is not a hosted or generative-art service.

Shader-aware material recoloring

Ultimate Colorizer analyzes the shader assigned to a material and reads its available color and texture properties instead of assuming one fixed naming scheme.

Included profiles cover:

• Built-in Standard

• URP Lit

• HDRP Lit through the adapter system

• Shader Graph

Base color and emission properties are resolved automatically for common pipeline shaders. Runtime tinting uses MaterialPropertyBlock, while Editor workflows can generate separate material variants and reusable material presets.

Unusual production shaders can be supported through a custom shader profile or SDK adapter.

Meshes and Tilemaps

Mesh tools include vertex-color replacement, UV-island and UV-rectangle data, submesh descriptors, material-slot maps, channel maps, skinned-mesh helpers and renderer-hierarchy scanning.

Tilemaps can be recolored with per-cell replacement, palette swaps, HSV shifts, multiply, tint, global tint and color extraction. Colors are stored on the Tilemap, allowing one shared tile asset to appear differently in separate cells.

Runtime character dyes and cosmetics

Build character creators and cosmetic systems with:

• Named dye channels such as skin, hair, cloth, armor and weapon

• Renderer and material-property bindings

• Palette-constrained color choices

• Cosmetic slots that toggle GameObjects

• Saved looks and PlayerPrefs persistence

• uGUI slider integration

• Deterministic seeded randomization

• Human-readable JSON state

• Compact synchronization-oriented state with a checksum

Invalid compact payloads are rejected with a failure result and message rather than throwing an unhandled exception.

Batch processing, SDK and CI

RecolorBatchProcessor supports deterministic output naming, dry runs, progress, cancellation, skipped-item and per-item error reporting, plus JSON and CSV reports.

The extension SDK supports custom:

• Shader profiles

• Recolor processors

• Palette generators

• Validators

Headless validation and batch workflows can be called from CI through -executeMethod, and tests can run through -runTests.

Editor tooling

Included tools:

• Recolor Studio

• Palette Browser

• Material Preset Library

• Batch Processor

• Preset Marketplace

• Welcome window

Ready-wired GameObject menu commands create a material-tint cube, material-tint sphere, sprite-tint object or runtime dye controller with full Undo support.

Evidence you can inspect

• The WebGL showcase executes the real runtime API and displays live processing, shader-analysis, state-validation, batch and SDK output.

• Full C# source is included across the Runtime, Editor and UI assemblies.

• No managed DLLs, obfuscated code, native plugins or hidden hosted processing layer.

• EditMode and PlayMode tests are included and run in Unity's Test Runner or headlessly.

• Five focused sample scenes cover texture recoloring, material variants, mesh recoloring, runtime cosmetics and character customization.

Known limitations

Stated up front, because discovering them after purchase is worse.

• HDRP is adapter-based, not certified. Built-in and URP are supported and verified. Test the included HDRP adapter and profile in your own HDRP project before relying on them in production.

• Custom shaders may need a profile. Standard pipeline shaders and Shader Graph are covered, but a heavily customized shader may require an SDK profile or adapter.

• Texture processing is CPU-side. This makes output deterministic and automation-friendly, but large textures take real processing time. The WebGL showcase uses 256×256 samples for responsiveness.

• Smart analysis does not art-direct. It clusters and classifies colors as a starting point; final palette choices remain creative decisions.

• No generative art or cloud processing. The package does not create imagery, upload assets or require a hosted service.

• Editor windows do not run in WebGL. The browser showcase demonstrates runtime systems and generated output; the Editor windows themselves are included in the Unity package.

• Mesh vertex recoloring requires mesh data. The mesh needs a vertex-color channel, and runtime mesh access requires Read/Write to be enabled.

Requirements

Unity 6000.0 or newer.

Built and uploaded from Unity 6000.0.62f1.

Render-pipeline support:

• Built-in Render Pipeline — supported and verified

• Universal Render Pipeline — supported and verified

• High Definition Render Pipeline — adapter-based and not certified

Support

szekipapa77@gmail.com