04 Chroma – Palette Editor

Where you build, sort, deduplicate, and export palette assets – from adding swatches one at a time to bulk-importing a history strip and turning a multi-select into a gradient in a single right-click.

Summary

A palette is just a ColorPaletteAsset (see Palette and Gradient assets) with an ordered list of entries; the work is in building that list, keeping it disciplined, and getting it out to other systems. Chroma’s Palette tab is built around that workflow. Pick a swatch from the Color Editor and drop it in with one click, give it an ID, and optionally assign it a semantic role. Once the picking is done, sort the whole palette by hue, deduplicate, and export.

Two views share the same underlying asset. The grid view is the fast browse mode: a flex-wrap of swatches that either fits as many per row as the pane allows or holds to a column count you pin. It supports multi-select with Shift-click and Cmd/Ctrl-click, dragging swatches out to other tabs, and a right-click context menu on each swatch. The list view is the metadata mode: tabular columns for Color, ID, Color Name, Hex, and Role. Click any column header to sort by it, or double-click a cell to edit it in place. Toggle between the two from the toolbar; the active palette is the same in both views.

The Palette tab covers:

• Build a palette by piping colors from the Color tab into the Palette tab via the Add button (one at a time) or Shift+Click Add (the recent history strip plus the Old/New preview in a single click).
• Multi-select, sort, and deduplicate a palette without leaving the swatch grid.
• Give swatches IDs and semantic roles so the rest of the project can address them by intent instead of by index.
• Preview sorts by hue, saturation, value, lightness, luminance (Oklab perceptual color space), chroma (Oklch colorfulness axis), alpha, role, color name, ID, or similarity, and write the order into the palette only when you apply it.
• Convert a multi-select of swatches into a brand-new gradient asset in one menu action.

Features

• Two interchangeable views. Grid (responsive flex-wrap, the fast browse mode) and List (MultiColumnListView with Color / ID / Color Name / Hex / Role columns, the metadata mode). Toggle from the toolbar; both edit the same underlying asset.
• Toolbar with seven controls. New (Shift+Click unloads the active palette without creating a new one), Add (Shift+Click bulk-adds the recent color history strip plus Old and New colors), Replace (single selection only), Sort (dropdown of nine stackable sort keys, an exclusive By Similarity, a Reverse modifier, plus None and Apply Sort), Actions (dropdown grouped as New from Recent / Add from Recent, then New from Clipboard / Add from Clipboard, then Remove Duplicates, then Clear Recent Colors, plus Import / Export submenus), Columns icon button (grid view only; Auto or a fixed count from 2 to 32), Grid / List view toggle.
• Per-swatch context menu. Right-click any swatch (or any selected swatch, when multi-selected) for Duplicate / Duplicate N Entries, Replace with Active Color (single-select only), To Gradient (multi-select only, two or more entries required), Copy Selected As (a six-format submenu), To Mixer Color A / To Mixer Color B (one entry selected) or To Mixer Colors (exactly two selected), and Remove / Remove N Entries.
• Copy Selected As (multi-color copy). A swatch context-menu submenu that copies every selected swatch to the clipboard, one color per line in palette order, in any of six text formats: Hex (#RRGGBB / #RRGGBBAA), Unity Color, Unity Color32, CSS rgb() / rgba(), HLSL float4, and JSON (one object per line). Available for any selection of one or more swatches. Per-color output is identical to the Color tab’s single-color Copy menu – both paths share one formatter. The status bar confirms with Copied N colors as <format>.
• Multi-select. Click to select a single swatch, Shift+click to extend a contiguous range, Cmd/Ctrl+click to toggle individual swatches. The active selection is shared between grid and list view, so a selection made in grid persists when switching to list and back.
• No manual reordering. Swatches cannot be dragged to a new position within the same palette. To change the stored order, use Sort and Apply Sort. Dragging a swatch out of the grid is for dropping it onto other targets, such as the gradient bar or a library swatch collection.
• Inline ID editing. Double-click the ID cell in list view to edit the swatch ID in place; commit on Enter or focus-loss. The palette’s own name and description are also editable in place at the top of the swatch area.
• Unique swatch IDs. A swatch’s ID is the key your code uses to look the color up, which is why it stays put when you change the color. No two swatches in one palette may share an ID, compared case-insensitively. An edit that collides is refused and the previous ID comes back, with the reason in the status bar. Everything that adds a swatch (Add, Duplicate, drag from the Library, extraction, import) suffixes the ID instead: Teal, Teal 2, Teal 3. Changing only the casing of an ID is allowed, since a swatch never collides with itself.
• Portable names. Palette and gradient names and swatch IDs are restricted to characters every filesystem accepts, because renaming a palette also renames its .asset file. Illegal characters (< > : " / \ | ? *) are stripped as they’re typed, and trailing periods and spaces are trimmed on commit. A name that is empty after that, or matches a Windows reserved device name (CON, NUL, COM1, and the rest), is rejected on commit and rolls back. Spaces, accented letters, and apostrophes are all fine.
• Per-swatch metadata. Each entry carries a Color, an ID (given a starting value from the nearest named-color match on add, editable in list view), and a Role (an optional ColorRole enum slot for semantic intent like Primary / Secondary / Accent). The runtime entry also has an IsLocked flag, which is set per entry in the palette asset’s Inspector; the Palette tab has no control for it. The grid marks a locked entry with a small dot in its corner, and the Palette tab treats it as read-only: its color, ID, and role cannot be edited, Replace with Active Color is disabled, and Remove, Delete, and Remove Duplicates leave it in place and say so in the status bar. Sorting still moves a locked entry, since that changes its position but not the entry itself. The list view also shows a read-only Color Name, the nearest named color from your color name list. It is derived from the color, never stored in the palette, and changing a swatch’s color updates it without touching the ID.
• Palette-level tags. The palette asset carries a list of tags. Double-click the Tags label below the palette name to edit them as a comma-separated string. The Library sidebar uses these tags for filter dropdowns.
• Stackable sort keys, previewed until applied. The Sort dropdown reorders what’s shown without touching the palette: By Hue (grayscale-aware, achromatic entries block before chromatic ones), By Saturation, By Value (Brightness), By Lightness (HSL), By Luminance (Oklab), By Chroma (Oklch), By Alpha, By Role, By Color Name, and By ID (always applied last). Each is a checkbox and several can be on at once, applied in the order they were ticked. By Similarity is an eleventh key that arranges the colors into a smooth nearest-neighbor walk; it cannot combine with the others, so it is exclusive. Reverse is a modifier rather than a key: it flips the whole order end to end, on top of whatever the keys produce, the Similarity walk, or the stored order when nothing is ticked. None (Stored Order) clears the keys and the reverse; Apply Sort writes the previewed order into the palette as one Undo step. The same sort drives the grid and the list view.
• Remove Duplicates. Collapses every group of entries that share the same color into the first occurrence, preserving the first occurrence’s ID, role, tags, and lock flag. A later duplicate that is locked is kept. Comparison uses the byte-quantized Color32 representation, so colors authored to the same hex always collapse even if sub-ULP float drift crept in. Reports the number of removals in the status bar; auto-reverts the message after three seconds.
• Convert to Gradient (multi-select). Right-click two or more selected swatches and choose To Gradient. Chroma creates a fresh ColorGradientAsset with the selected swatches placed as evenly-spaced stops, opens it in the Gradient Editor, and selects it in the library sidebar’s Gradients sub-tab.
• Drag swatches into the Gradient Editor. Drag any swatch (or multi-select) from the Palette tab’s grid view directly onto the gradient bar in the Gradient tab to insert stops at the drop position. The just-inserted stops are auto-selected.
• Asset-level Undo / Redo refresh. The panel subscribes to Unity’s undo-redo callback, so Cmd/Ctrl+Z / Y immediately rebuilds the grid and list view. There is no manual refresh button because there does not need to be one.

Recipes

None of the recipes below rely on one another, so skip to whichever covers the task at hand. If the Palette tab is new to you, though, work through the first recipe before the rest: it covers getting a palette loaded, which every other recipe takes for granted.

Create or load a palette

Problem. You want to start a new palette for a game jam sprint or pick up an existing one. The tab shows a placeholder until something is loaded.

Solution. Click New in the Palette toolbar to create a fresh ColorPaletteAsset under the configured palette directory (default Assets/Scylla/Resources/Color/Palettes/, configurable under Project Settings > Scylla). The new palette loads immediately and appears selected in the Library sidebar’s Palettes sub-tab. To give it a name before adding colors, double-click the title field above the swatch area and type a new name, then press Enter or click away.

To load an existing palette, click any entry in the library sidebar’s Palettes sub-tab, or double-click a palette asset in the Project window (with the auto-open preference enabled). Chroma persists the loaded palette’s GUID, so reopening the window restores it automatically after a Unity session restart or project reopen.

Shift+click the New button to unload the active palette without creating a new one. This is the right move when you want to load a different palette from elsewhere and don’t need the current one to remain the next-loaded asset.

Add swatches to a palette

Problem. You’ve assembled a set of reference colors in the Color tab and want to commit them to the palette – either one at a time as you finalize each color, or all at once after sampling a batch from a screenshot.

Solution. The fastest single-color path is to pick a color in the Color Editor and click Add in the Palette toolbar. The active color becomes a new entry at the end of the palette. The entry’s ID starts out as the nearest entry in the configured named-color database, so a deep blue lands as something like “Navy Blue” rather than a generic placeholder. Edit the ID in list view if you want something more meaningful to your code, such as PlayerHull.

For bulk add, Shift+click the Add button. This pushes every color in the recent history strip (oldest first), then the Old preview swatch, then the New preview swatch onto the palette in a single Undo step. Use this after sampling several reference colors from a reference image so you commit them as a set without adding each one individually.

You can also drag swatches from the recent history strip, from another loaded palette, or from a ColorSwatchCollectionAsset in the Library directly onto the grid. Dropped colors are appended to the end of the palette.

Pin the grid to a fixed number of columns

Problem. The palette is ordered to mean something – families of five, a ramp of eight, pairs of light and dark – but the grid wraps to whatever fits the pane, so that structure breaks across rows and changes again every time the window is resized.

Solution. In grid view, click the Columns button at the right of the toolbar, next to the Grid and List icons, and pick a count. It carries the horizontal-bars icon, completing the set the two view toggles use: a grid for grid view, stacked rows for list view, side-by-side bars for columns. Auto (fit width) is the default and keeps the original behavior: square 28px swatches, as many per row as fit. Any count from 2 to 32 pins the grid to exactly that many columns, and the swatches stretch to keep filling the pane, so cells become wider than they are tall rather than leaving a ragged margin on the right. Resizing the window keeps the count and re-stretches the cells.

The setting is per user rather than per palette, so it applies to whichever palette you open and survives an editor restart. The current count is on the button’s tooltip and is checked in the menu, and the button disappears in list view, where a column count means nothing. Like the Color tab’s view settings, it is returned to Auto by the window’s Reset action.

Edit a swatch’s metadata

Problem. You’ve added a swatch but its starting ID is wrong, or you want to assign a semantic role so code can look up the “Primary” color by ID rather than by index.

Solution. Switch the view to List (toolbar) to edit metadata efficiently. Each row has five columns:

• Color. Inline color picker. Click the swatch to open the color picker; or switch to the Color Editor, pick the desired color, and use the swatch context menu’s Replace with Active Color.
• ID. The identifier your code uses to look the swatch up. Double-click to edit in place. Commit on Enter or focus-loss; Escape cancels. Characters that no filesystem accepts are filtered out as you type, and an ID already used by another swatch in the same palette is refused on commit. Changing a swatch’s color never changes its ID, so a lookup written against "Primary" keeps working after you adjust the color.
• Color Name. Read-only. Shows the nearest named color from the color name list selected in Preferences, for example “Navy Blue” for a deep blue. It updates whenever the color changes and is never stored in the palette. Sorting by it orders alphabetically.
• Hex. Read-only, showing the swatch as #RRGGBB, or #RRGGBBAA when it carries alpha. It follows the Color column, so an edit there updates it immediately. Double-click the value to copy it to the clipboard; the status bar confirms with Copied #RRGGBB. Sorting by it orders by red, then green, then blue. For several swatches at once, use the context menu’s Copy Selected As > Hex.
• Role. Dropdown of ColorRole values (None, Primary, Secondary, Accent, Background, Foreground, and others). Optional; defaults to None.

Work with multi-select

Problem. You need to act on several swatches at once: remove a batch, duplicate them, copy them as text, or turn them into a gradient.

Solution. In Grid view, click any swatch to select it. Hold Shift while clicking to extend a contiguous range; hold Cmd / Ctrl to toggle individual swatches in and out of the selection. Press Cmd/Ctrl+A to select all swatches at once.

Multi-select carries into the context menu: Duplicate becomes Duplicate N Entries, Remove becomes Remove N Entries, and To Gradient unlocks once two or more entries are selected.

The arrow keys cycle through swatches (wrapping at the end), Home / End jump to the first / last swatch, and Delete / Backspace removes the current selection. Locked swatches in the selection are kept, and the status bar reports how many were removed and how many were kept.

The selection is shared between grid and list view, so a range made in grid persists when you switch to list and back.

Sort a palette, and decide later whether to keep it

Problem. You’ve picked a full palette and the swatches are in sampling order, which is visually noisy and hard to hand off. You want to try a few arrangements without committing to any of them, and the one you want is “group by color family, then run each family light to dark”, which is two criteria rather than one.

Solution. Click Sort in the toolbar and tick the keys you want. Every key is a checkbox, so several can be on together, and nothing is written to the palette while you experiment: the grid and the list show the entries in the sorted order. For the arrangement above, tick By Hue first, then By Luminance: the first key you tick is the primary sort, and the next breaks its ties.

The keys are:

• By Hue. HSV hue, ascending. Compared on hue alone, so colors of the same hue tie and a key stacked after it (Luminance, Value, and the rest) orders within each hue family. Grayscale-aware: achromatic entries form a block ahead of the chromatic ones, ordered among themselves by brightness, because a gray has no meaningful hue angle to sort on.
• By Saturation. HSV saturation, ascending.
• By Value (Brightness). HSV value, ascending.
• By Lightness (HSL). HSL lightness, ascending.
• By Luminance (Oklab). Oklab perceptual luminance, ascending. Usually the one that matches how light a color actually looks.
• By Chroma (Oklch). Oklch chroma (colorfulness), ascending.
• By Alpha. Alpha, ascending.
• By Role. Semantic ColorRole, by its underlying value.
• By Color Name. Alphabetical by the nearest named color. Color names can repeat, so this key stacks like the color keys: ticked with By Hue, it orders colors that share a hue by name.
• By ID. Alphabetical, case-insensitive. Listed last of the stacking keys because it is always applied last (see below).
• By Similarity. Arranges the colors into a smooth walk, each next to its nearest neighbor in Oklab (perceptual) space, starting from the darkest. Unlike the others this is a whole-sequence arrangement rather than a per-color key, so it cannot be combined: ticking it clears the rest, and ticking any other key clears it. It is the one to reach for when you want the palette to flow like a gradient rather than step along a single axis.
• Reverse. Not a sort key but a modifier that flips the whole order end to end. It applies on top of whatever is above it, so it turns a light-to-dark ramp into dark-to-light, reverses the Similarity walk, or, with no keys ticked at all, reverses the palette’s stored order. Because it stands on its own it stays on as you toggle keys, and None (Stored Order) clears it along with the keys.

When you are happy with the arrangement, Apply Sort at the bottom of the menu writes it into the palette as a single Undo step, then clears the keys and the reverse: the palette now genuinely is in that order, so there is no preview left to describe. A reverse on its own is enough to enable Apply, so flipping the stored order can be baked in as easily as any sort. None (Stored Order) clears the keys and the reverse without writing anything and returns both views to the palette’s stored order.

Clicking a column header in the list view is another way in: it sets the sort to that single key, so the toolbar’s checkmarks always describe what both views are showing.

Strip duplicate swatches

Problem. A palette accumulated duplicates over several sessions – colors added from different reference images that happen to be the same hex value, or near-duplicates that crept in through gamma round-trips. You want to collapse them down to one occurrence of each color.

Solution. Click Actions in the toolbar and choose Remove Duplicates (the item is disabled when no palette is loaded). Chroma walks the palette in order, keeps the first occurrence of each color, and removes subsequent duplicates. The first occurrence’s ID, role, tags, and lock flag are preserved. A locked duplicate is never removed, so a palette keeps two swatches of the same color when the later one is locked; the status bar adds how many locked duplicates were kept.

The comparison uses the byte-quantized Color32 representation: each channel is rounded to its 0-255 integer value and packed into a single 32-bit key. Two swatches authored to the same hex always collapse, even if floating-point drift crept in from a gamma round-trip or a hex-parse rounding.

The status bar surfaces the result (“N duplicate colors removed” or “No duplicate colors found”), auto-reverting the message after three seconds.

Turn a multi-select into a gradient

Problem. You’ve settled on four colors that should form a ramp – say a sky transition from deep midnight blue to golden hour orange – and you want a ColorGradientAsset from them without manually placing stops in the Gradient Editor.

Solution. In Grid view, select two or more swatches (Shift+click or Cmd/Ctrl+click), right-click, and choose To Gradient. Chroma does the following in one step:

• Creates a new ColorGradientAsset under the configured gradient directory (default Assets/Scylla/Resources/Color/Gradients/).
• Inserts the selected swatches as evenly-spaced color stops (first selection at offset 0, last at offset 1, the rest distributed linearly between).
• Opens the new gradient in the Gradient Editor.
• Selects the new gradient in the library sidebar’s Gradients sub-tab.

This is the canonical way to bootstrap a gradient from an existing palette. The reverse path – sampling a gradient at N points into a new palette – lives on the Gradient tab’s Actions > To Palette entry; see Gradient Editor.

Copy a selection of swatches as text

Problem. You want to hand a group of palette colors off as text – into a shader’s float4 constants, a CSS stylesheet, a JSON config, or a C# script – without copying each swatch one at a time through the Color tab.

Solution. Select one or more swatches in Grid or List view (Shift+click for a range, Cmd/Ctrl+click to toggle, Cmd/Ctrl+A for all), right-click, and choose Copy Selected As, then pick a format:

• Hex – #RRGGBB, with the alpha pair appended only for non-opaque entries.
• Unity Color – new Color(...) literals with linear-space float arguments.
• Unity Color32 – new Color32(...) literals with 0-255 byte arguments.
• CSS rgb() – rgb(...) for opaque entries, rgba(...) for translucent ones.
• HLSL float4 – float4(...) with sRGB floats.
• JSON – one {"r":..,"g":..,"b":..,"a":..} object per line.

The colors land on the clipboard one per line, in palette order, and the status bar confirms Copied N colors as <format>. Each line is byte-identical to what the Color tab’s single-color Copy menu produces for that color, because both share the same formatter.

Drag swatches directly into an existing gradient

Problem. You already have a gradient loaded in the Gradient tab and want to insert one of your palette’s swatches at a specific position on the bar, rather than creating a brand-new gradient from scratch.

Solution. Drag any swatch (or multi-select) from the Palette tab’s grid view directly onto the gradient bar in the Gradient tab. The drop position on the bar determines the stop offset; the just-inserted stop is auto-selected so the Stop Inspector reflects it immediately. Multi-select drag works too – each dragged swatch becomes a separate stop at the drop position.

This pattern keeps the gradient authoring loop tight: dragging the same swatch to two positions on the bar reuses the swatch’s exact color twice without needing to re-enter the hex value.

Export a palette to ASE, GPL, or other formats

Problem. You’ve finished a palette in Chroma and need to get it into Photoshop, GIMP, Aseprite, or another tool – or you want to reference the colors from CSS or from a C# constant file in a game project that doesn’t use Chroma at runtime.

Solution. Click Actions > Export and pick a format. The export formats available are:

• Adobe Swatch Exchange (.ase) – readable by Photoshop, Illustrator, Sketch, Figma, and most other professional design tools.
• GIMP Palette (.gpl) – a plain-text format natively supported by GIMP, Krita, Aseprite, Inkscape, and many others.
• Lospec Palette (.json) – the JSON format used by Lospec’s palette browser.
• CSS Custom Properties (.css) – exports each swatch as a CSS (Cascading Style Sheets) custom property (CSS variable).
• C# Color Constants (.cs) – exports each swatch as a static Color field in a C# file.
• Chroma Palette JSON (.cpalette) – Chroma’s own round-trip format, the right pick for archiving a palette or sharing it between Chroma installations.

The full format matrix with color spaces, round-trip fidelity, and known limitations is on the Import and Export page.

Build a palette from whatever is on the clipboard

Problem. The colors you want are in a message, a stylesheet, or a config file rather than in a palette file: a block of CSS custom properties from a design handoff, a Tailwind theme, a JSON array from a palette generator, or five hex codes someone pasted into chat.

Solution. Copy the text, then choose Actions > New from Clipboard. The item names how many colors it found, so you can see what you are about to get before you commit to it, and it is grayed out when the clipboard holds nothing Chroma recognizes. The result is a new palette asset that loads straight into the tab. If a palette is already open and you want to append rather than start fresh, Add from Clipboard in the same menu adds the parsed colors to it, keeping each color’s ID.

Recognized formats:

• CSS custom properties and SCSS variables, taking the variable name as the swatch ID, so --fresh-sky: #00a6fbff becomes a swatch with the ID Fresh Sky.
• Tailwind color config, including nested shade ramps. A shade is named after its family as well as itself (Fresh Sky 500). DEFAULT keys are skipped, since each one repeats its family’s 500 shade.
• Hex in any arrangement: a JSON array, a quoted list, a comma-separated line, several lines, or bare codes with no # at all. #RGB, #RGBA, #RRGGBB, #RRGGBBAA, and 0x prefixes all parse.
• CSS functions: rgb(), rgba(), hsl(), hsla(), in both the comma syntax and the modern space-separated form with a slash before alpha. Percentages are accepted.
• CSS color names, such as tomato or rebeccapurple.
• Everything the Copy Selected As submenu produces: hex, Unity Color, Unity Color32, CSS rgb(), HLSL float4, and the JSON object form. Copy a set of swatches out of one palette this way and paste them straight into another.
• A pasted GIMP palette block, the R G B Name lines from a .gpl file.

Colors that arrive without a name of their own get an ID from the nearest known color, the same way the Add button does for a new swatch, and a repeated ID is suffixed rather than refused.

Capture a session’s colors as a palette

Problem. You have been picking colors on the Color tab for a while, and the ones worth keeping are sitting in the recent-colors strip and the Old / New preview swatches rather than in a palette.

Solution. Choose Actions > New from Recent. It builds a new palette asset from every color in the recent strip plus the current Old and New swatches, oldest-first, and loads it straight into the tab. The item names how many colors it will capture. Each color gets an ID from its nearest known color, the same as the Add button. Colors that recur (the New swatch is often already the newest in the strip) are kept as separate entries rather than merged, so run Remove Duplicates afterward if you want them folded. To append the same set to a palette that is already open instead of creating a new one, use Add from Recent in the same menu.

To start a clean session once you have captured what you wanted, Actions > Clear Recent Colors empties the recent strip and resets the Old and New preview swatches to black and white, without the full window Reset.

The Import submenu in the same dropdown handles the reverse direction. Import formats are:

• Adobe Swatch Exchange (.ase)
• GIMP Palette (.gpl)
• Lospec Palette (.json)
• Photoshop Color Table (.act) – Adobe’s binary color table format
• Hex List (.hex, .txt) – a plain text list of hex color codes, one per line
• Chroma Palette JSON (.cpalette)

Imported palettes become new ColorPaletteAsset files under the configured palette directory and load into the editor automatically.

Keyboard shortcuts

Key	Action
Left / Right	Cycle the selection through the swatch grid (wraps at the end).
Home / End	Jump the selection to the first / last swatch.
Delete / Backspace	Remove the current selection.
Cmd/Ctrl+A	Select all swatches in the active palette.
Shift+Click	Extend the selection to a contiguous range.
Cmd/Ctrl+Click	Toggle individual swatches in the selection.
Cmd/Ctrl+Z / Y	Undo / Redo (rebuilds the grid and list view immediately).

Tips and pitfalls

• The grid and list views share state. Multi-selection, the active selection index, and the loaded palette are common; only the rendering differs. Switching views in the middle of a multi-select keeps the selection intact.
• “None (Stored Order)” shows the palette as it is stored. A sort is only a preview until Apply Sort writes it, so choosing None never loses anything. Once a sort is applied, that order is the stored order; use Cmd/Ctrl+Z to undo the Apply itself.
• “Remove Duplicates” uses byte-quantized equality. Two swatches differing only in the fourth decimal of a float channel are considered duplicates. This is intentional; it deduplicates hex round-trip drift. Swatches differing in alpha are not duplicates because alpha is part of the comparison key.
• Tags belong to the palette, not to individual swatches. The inline tags field below the palette title edits the palette’s tag list, the same list the Library sidebar uses for its filter dropdowns. Individual swatches are not tagged in Chroma.
• Name rules exist because a palette name is also a filename. Renaming a palette or gradient renames the backing .asset file, so a name that is legal on one platform and not another produces a project that does not open everywhere. The rule is applied on all platforms, which is why ?, * and | are rejected on macOS and Linux even though both accept them.
• Swatch ID uniqueness is enforced, not merely suggested. ColorPalette builds a case-insensitive ID-to-index map and its constructor throws on a collision, so an asset with two swatches sharing an ID cannot be loaded at all. Chroma prevents that at every write path rather than letting it reach the asset. An imported file whose format allows repeated swatch names (a GIMP .gpl with several unnamed swatches, for instance) is not rejected; the repeats are suffixed on the way in.
• A palette that still has duplicates says so. An asset authored before those checks existed, hand-edited in the Inspector, or merged badly can carry duplicate IDs. Selecting it shows the reason and the offending ID in place of the swatch grid, the entry count reads “N colors (cannot be displayed)”, and the same message goes to the console. It stays listed in the Library under its asset name so it can be found and repaired. Earlier versions rendered it as an empty palette, which read as the swatches having disappeared.
• The “Replace with Active Color” context menu only appears with a single swatch selected. With two or more selected, the entry hides itself rather than guessing which swatch was meant.
• The “To Gradient” context menu requires two or more selections. A single swatch can’t describe a gradient; the entry hides itself with a single selection.
• “Copy Selected As” copies in palette order, not click order. The submenu appears for any selection of one or more swatches, and the copied lines follow the swatches’ positions in the palette rather than the order they were clicked. Each line matches the Color tab’s single-color Copy menu exactly.
• Drag-drop from the history strip does not preserve an ID. History slots are bare colors without metadata; a dropped history color becomes a new swatch with a starting ID taken from the nearest named color. Favorites cannot be dragged; click one to make it the active color, then use Add.
• The status-bar message for Remove Duplicates auto-reverts after three seconds. It is not written to the Console.
• Palette renames in the Project window do not break Chroma’s library link. The library sidebar tracks palettes by GUID, not by path; renames, moves, and asset folder reorganizations are transparent.

Related

• 01 Scylla Chroma
• 03 Chroma – Color Editor
• 05 Chroma – Gradient Editor
• 12 Chroma – Library
• 14 Chroma – Import / Export