Website profiles · Technology insights · Alternatives

colorcolor.in

Color-color is a tool to create accessible color systems for UIs. You can use Okhsl or HSLuv color spaces to create perceptually uniform colors.

No paid content found
Visit website
Profile views 13 Outbound visits 20 Normal
color × color Full homepage screenshot

At a glance

Category
Development
Language
English
Paid-content signal
No paid content foundObserved
Registered
2020
Hosting
NetlifyInferred
HTTPS certificate trusted
PassedObserved
Last updated

Website review

This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.

What is color × color?

color × color is a browser-based tool for building accessible color systems for user interfaces. Instead of picking colors by eye, it works in Okhsl or HSLuv — perceptually uniform color spaces — so that steps in lightness and saturation look evenly spaced to the human eye rather than bunching up the way they often do in plain HSL.

What that means in practice

  • Perceptually uniform palettes. A 100–900 scale generated in Okhsl or HSLuv tends to look evenly stepped, which matters for text, borders, and background layers in a design system.
  • Accessibility built into the workflow. Because lightness is handled predictably, it is easier to reach contrast ratios for body text, labels, and focus states without hand-tweaking each swatch.
  • UI-oriented output. The point is a usable set of tokens for components — buttons, inputs, alerts, surfaces — not a decorative mood board.

Who it suits

Designers and front-end developers defining a palette once and reusing it across a product; design-system maintainers who need consistent scales; anyone who has fought with HSL ramps that go muddy or jump in brightness.

Trade-offs to weigh

Okhsl and HSLuv are less familiar than HSL, and browser devtools and some libraries still default to sRGB/HSL, so you may need to convert values or document the space in your tokens. Perceptual uniformity also does not by itself guarantee WCAG contrast — you still need to check pairings.

A useful next step: generate one ramp for your primary brand color and one neutral ramp, then test the darkest and lightest steps against your actual background colors before committing them to tokens. If you want a second opinion on the contrast maths, WebAIM publishes a widely used contrast checker, and W3C hosts the WCAG guidance those ratios come from.

How do I build a perceptually uniform color palette for a UI?

Use a perceptually uniform color space, define lightness steps first, and only then vary hue and chroma. Perceptual uniformity means equal numerical steps look like equal visual steps, so a 10-step scale reads evenly from light to dark instead of bunching up in the shadows or washing out in the highlights.

color × color is built for exactly this task: it generates accessible color systems for UIs and supports Okhsl and HSLuv, both designed for perceptually even results.

A practical workflow

  1. Pick a target contrast range. Decide the lightest background and darkest text you need, then anchor the scale at those two ends.
  2. Set lightness increments. With 100–900 scales, keep the lightness delta roughly constant across steps; that is what makes the ramp feel smooth.
  3. Add hue and chroma per family. Keep hue stable across a family, and let chroma peak in the mid-tones rather than at the extremes.
  4. Check contrast pairs, not single swatches. Test the combinations you actually ship: body text on surface, muted text on surface, white text on a primary button.
  5. Generate semantic tokens. Map raw steps to roles such as surface, border, text-muted, accent-hover so designers and engineers share one vocabulary.

Choosing a space

Space Strength Trade-off
HSLuv Lightness and saturation behave predictably to the eye; easier to reason about Less directly aligned with modern CSS color work
Okhsl Perceptually uniform with a more natural, less saturated feel; good for UI ramps Newer, so fewer teams have intuition for it
Plain HSL Familiar and universally supported Steps are visually uneven; light ramps collapse and mid-tones jump

If your team already thinks in HSL, HSLuv is the gentler migration. If you are starting fresh and want ramps that look deliberately designed, Okhsl is the stronger default.

A concrete scenario

Suppose you need a grey ramp and a brand blue ramp for a dashboard with light and dark themes. Build both in one uniform space so the grey and blue families share the same lightness rhythm; then a card using grey-200 on grey-50 and a chart using blue-200 on blue-50 will have matching visual weight. In dark mode, invert the role mapping rather than inventing new steps — the same ramp, read from the other end, keeps contrast relationships intact.

Next step: pick one accent color, generate a 9-step ramp, and test just three pairs — body text on background, muted text on background, and button label on accent — before scaling to the full system.

What is the difference between Okhsl and HSLuv color spaces?

Okhsl and HSLuv are both attempts to make HSL-style color picking perceptually uniform, but they target different gamuts and priorities. HSLuv is the older, more widely supported option: it works in the sRGB gamut and guarantees that a given lightness value looks equally light across all hues, which is why it became popular for generating accessible UI palettes. Okhsl is a newer model from the same family of work (Björn Ottosson's Oklab-based color spaces). It also aims for perceptual uniformity but is built on Oklab and is designed to behave more predictably when you push colors toward saturation, and to extend more gracefully toward wider gamuts like Display P3.

For a designer or front-end developer building a color system, the practical differences look like this:

Aspect HSLuv Okhsl
Underlying model CIELUV-based Oklab-based
Primary gamut sRGB sRGB, with a path toward wider gamuts
Main strength Even perceived lightness across hues Smoother saturation and hue behavior
Maturity and tooling Long-established, broad library support Newer, still spreading
Typical use Accessible sRGB palettes, contrast-safe ramps Modern design systems, future wide-gamut work

The trade-off is maturity versus behavior. HSLuv is the safer choice if you need broad browser and library support today, or if you are matching an existing sRGB workflow. Okhsl tends to produce more natural-looking gradients and less abrupt shifts as you increase saturation, and it aligns with the Oklab ecosystem that is increasingly used for color interpolation and theming.

A useful next step: open color × color and generate the same palette twice, once in each space, then compare the mid-tones and the most saturated steps side by side. If your palette stays in sRGB and must work across older tooling, HSLuv is usually the pragmatic pick; if you are starting fresh and care about smooth ramps or eventual wide-gamut output, Okhsl is worth adopting.

How can I check whether my color system meets accessibility contrast requirements?

Use a contrast checker on your actual color pairs, not on your palette in isolation. Accessibility depends on which foreground sits on which background, at which text size, so the unit of testing is the pair.

A practical workflow

  1. List the real combinations your UI uses: body text on page background, muted text on cards, button label on button fill, link on background, icon on surface, focus ring on adjacent colors.
  2. Test each pair against the WCAG thresholds: 4.5:1 for normal text, 3:1 for large text (roughly 18pt, or 14pt bold) and for non-text UI components and graphical objects.
  3. Fix failures at the token level, not the component level. If you patch one button, the same failing pair reappears elsewhere.
  4. Re-test after any change, including dark mode variants and hover/disabled states, which are often forgotten.

Where color × color fits

color × color is built for generating accessible color systems for interfaces, and it works in Okhsl or HSLuv rather than plain HSL. That matters because those spaces are designed to be perceptually uniform: equal numeric steps look like equal visual steps, so a ramp you build stays evenly spaced in lightness, and contrast relationships hold more predictably as you add shades. If you have ever built a scale in HSL and found the mid-tones bunch up or the yellows look far lighter than the blues at the same lightness value, that is the problem this approach addresses.

Practical use: define your neutral and brand ramps in one of those spaces, then assign semantic roles (background, surface, border, text, muted text, accent) to specific steps, and check the resulting pairs.

Trade-offs to weigh

  • Perceptually uniform spaces give more reliable ramps, but they are less familiar to designers who think in HSL, and exported values may need conversion for your CSS or design tool.
  • A generator helps you build a system that is accessible by construction; it does not audit an existing product. If you already have shipped colors, a pair-by-pair checker is the faster route.
  • Passing 4.5:1 is a floor, not a goal. Body text at exactly 4.5:1 can still feel strained for long reading; aim higher for paragraphs and reserve the minimum for incidental labels.

Other tools worth knowing

  • WebAIM hosts a widely used contrast checker for quick pair testing, including a lightness slider to find the nearest passing shade.
  • Who Can Use shows how a pair performs across different types of vision, which is useful when a pair technically passes but reads poorly.
  • W3C publishes the WCAG guidance itself, worth reading once so you know which threshold applies to which element.

Decision criterion

If you are starting a new system, build the ramps in a perceptually uniform space and assign roles deliberately. If you are auditing something existing, check every foreground/background pair you ship, fix at the token level, and re-check dark mode separately.

Can I export my color system to CSS variables or design tokens?

Yes — color × color is built as a tool for creating accessible color systems for UIs, so exporting your palette into CSS variables or design tokens is the natural end use. The site describes using Okhsl or HSLuv color spaces to produce perceptually uniform colors, which matters when you want a generated scale to translate cleanly into a token set without some steps appearing to jump in lightness.

A practical next step is to decide which export format your team actually needs before you build the palette:

  • CSS custom properties — best if you want a single stylesheet of --color-name-step variables that designers and developers can reference directly.
  • Design tokens (JSON) — best if your tokens need to flow into multiple platforms or tools through a pipeline rather than being hand-copied.
  • Figma or design-tool styles — best if the main consumer is the design team and code is downstream.

If you are unsure, start with CSS variables for a small pilot component, then move to JSON tokens once the naming convention has settled. Renaming token families later is far more painful than choosing the format up front.

Since the site is oriented around accessible color systems, an example reader scenario is a product team that needs a semantic palette — background, surface, border, text, accent — with contrast-safe pairings. Generating perceptually uniform scales in Okhsl or HSLuv makes it easier to pick steps that hold consistent contrast, and exporting them as named variables keeps those choices consistent across components.

For comparison, other tools in this space include Coolors for fast palette exploration and Huetone for accessibility-focused palette work. Use color × color when the priority is a structured, exportable system rather than quick inspiration.

How do I choose a base color and generate tints and shades that stay perceptually even?

Choose a base colour that already works at mid-lightness, then generate tints and shades in a perceptually uniform space rather than by mixing with white and black in plain sRGB. That single decision is what keeps steps looking evenly spaced instead of bunching up in the light end.

Why the colour space matters

In sRGB, adding white to a saturated blue produces washed-out, greyish steps, and the jump from 90% to 100% lightness looks far smaller than 10% to 20%. Perceptually uniform spaces (Okhsl, HSLuv, Oklab, CIELAB) fix this by making equal numeric steps look like equal visual steps. color × color is built for exactly this: it creates accessible colour systems for UIs and supports Okhsl and HSLuv.

A practical procedure

  1. Pick a base hue from your brand or a reference image, and set it at a mid lightness (roughly the lightness of a mid-grey when you squint).
  2. Fix the hue and saturation, then vary only lightness to produce the ramp. Keep hue shifts deliberate — a few degrees towards blue in shadows and towards yellow in highlights often looks more natural, but do it by hand, not by accident.
  3. Generate 9–11 steps: 2–3 tints, the base, 3–5 shades. More steps give finer control but more tokens to maintain.
  4. Check contrast at the ends you actually use: text on tinted backgrounds, and white text on the darkest shade. Target at least 4.5:1 for body text and 3:1 for large text or UI borders.
  5. Test the greyscale version. If two adjacent steps become indistinguishable in greyscale, they are too close.

Choosing the base colour itself

  • Start from a colour you can describe in words (muted teal, warm red) rather than a random hex; it is easier to defend and extend.
  • Avoid extremes: a base at 95% lightness leaves no room for tints, and one at 15% leaves no room for shades.
  • If the colour must work on both light and dark themes, choose a base near the middle so both directions have range.
  • Check it against your neutrals. A base that clashes with your greys will look wrong in every component.

Trade-offs to expect

Approach Evenness Effort Best for
sRGB tint/shade mixing Poor at the ends Low Quick prototypes
Perceptually uniform ramp Good across the scale Medium Design systems, themes
Hand-tuned per step Best High Brand-critical palettes

A quick next step: build one ramp of nine steps in a perceptually uniform tool, then place the swatches side by side in greyscale. If the steps look evenly spaced there, the ramp will hold up in real interfaces.

Related questions

More questions →
How do I get started with the color × color tool?

Go to colorcolor.in in your browser. That's the whole setup — color × color is a web tool for building accessible color systems for UIs, and it runs in the page with no install step described in the site's own materials. You'll want a browser window wide enough to work comfortably, and a rough idea of the UI you're designing for, because the tool's job is to produce a perceptually uniform palette you can carry into that design.

What color × color actually does

The site describes itself as "a tool to create accessible color systems for UIs," and it lets you work in either Okhsl or HSLuv color spaces to build perceptually uniform colors. That phrase — perceptually uniform — is the reason the tool exists. In a perceptually uniform space, equal numeric steps look like equal visual steps, so a ramp of ten shades reads as an even progression instead of bunching up in the shadows or blowing out in the highlights.

If you've ever hand-picked a "50–900" scale and found that the jump from 700 to 800 is barely visible while 100 to 200 is a cliff, that's the problem this class of tool is built to remove.

Before you start: what to have ready

You don't need an account or any files to open the tool. What helps is deciding these first, because they shape every choice afterward:

  • Your base or brand color. The single hue the system is built around.
  • How many steps you need. A common UI scale runs from a very light tint to a very dark shade; decide the count before you generate.
  • Where the system will be used. Text on backgrounds, borders, hover states, and disabled states all pull different requirements from the same ramp.
  • Your accessibility target. If you're aiming at WCAG contrast thresholds for text, say so up front — it changes which steps you can use for body copy versus decoration.

The basic flow

  1. Open colorcolor.in. The tool loads directly in the browser.
  2. Choose your color space — Okhsl or HSLuv. This is the first real decision, and it's covered in its own section below.
  3. Set your base color. Pick the hue your system centers on.
  4. Generate the ramp. The tool produces a set of steps that are evenly spaced perceptually, not just numerically.
  5. Check the steps against your use cases. Identify which steps work for text, which for surfaces, which for accents.
  6. Export or copy the values into your design file or codebase.

The order matters less than the loop: most people set a base color, look at the ramp, and adjust — the point of a perceptual space is that small adjustments behave predictably.

Okhsl or HSLuv — how to choose

Both are perceptually uniform spaces; they differ in their design goals and in how they handle the extremes of lightness and saturation.

Okhsl HSLuv
Design intent A more perceptually accurate take on the familiar HSL model Keeps HSL's saturation/lightness semantics while staying perceptually uniform
Familiarity Feels closer to how designers already think about HSL Also HSL-shaped, but with different gamut behavior
Practical difference Worth trying when you want ramps that stay vivid across the range Worth trying when you want predictable, evenly spaced steps that map cleanly onto HSL-style controls

If you have no strong preference, generate the same base color in both and compare the ramps side by side. The one whose mid-tones and extremes look evenly spaced to you, on the surfaces you'll actually ship, is the right one for that project. There's no universally correct answer — the choice depends on the palette and the UI.

Common sticking points

The ramp looks right but the text doesn't pass contrast. Perceptual uniformity makes steps even; it doesn't automatically make any given step accessible against any given background. Check the specific foreground/background pairs you'll use.

The colors look different in your design tool than in the browser. Color management settings differ between applications. Compare values in one place before committing.

You can't decide on a step count. Start with the number of distinct roles you actually have — background, surface, border, muted text, body text, strong text, accent — and let that drive the scale rather than picking a round number first.

You're not sure the space matters. It does, but mostly at the edges: the lightest and darkest steps are where non-uniform spaces fall apart, and those are exactly the steps UI systems lean on for backgrounds and dark-mode surfaces.

What to do next

Once you have a ramp you're happy with, the useful follow-up is to define roles rather than shades — assign each step a job (page background, card surface, primary text, and so on) so the system survives a rebrand or a dark-mode variant. If you're still deciding between the two spaces, the dedicated comparison of Okhsl and HSLuv is the next thing to read.

Why does color × color use Okhsl or HSLuv color spaces?

color × color uses Okhsl and HSLuv because they are perceptually uniform color spaces: a fixed numerical change in lightness, saturation, or hue produces a roughly equal visual change. That matters when you generate a UI color system, because you want a "blue 500" and a "red 500" to look equally light, and you want each step in a scale to feel like an even step. Standard HSL does not guarantee either.

The problem with ordinary HSL

In HSL, the three numbers are defined by how they map onto RGB, not by how the eye sees them. Two colors with the same L value can look very different in brightness. A classic example:

  • hsl(60, 100%, 50%) — yellow, reads as very bright
  • hsl(240, 100%, 50%) — blue, reads as much darker

Both have L = 50%, yet the yellow is far more luminous. If you build a palette by holding L constant and rotating hue, your yellows will look washed out and your blues will look heavy. You end up hand-tuning every swatch, which defeats the point of a systematic palette.

HSL also distorts saturation. Increasing S toward 100% does not add a consistent amount of perceived colorfulness across hues, and near the extremes colors clip abruptly toward white or black.

What "perceptually uniform" means

A perceptually uniform space is built so that equal distances in the coordinates correspond to equal perceived differences. Okhsl and HSLuv are both attempts to give you HSL-like controls (hue, saturation, lightness) on top of a perceptually uniform foundation:

Space Foundation Practical character
HSL Direct RGB mapping Intuitive but perceptually uneven
HSLuv CIELUV (via LCh) Lightness is perceptually even; saturation is defined relative to the maximum possible for that hue/lightness
Okhsl Oklab Even lightness and more even hue/saturation behavior; generally smoother transitions

HSLuv keeps the promise that a given lightness value looks equally light across all hues, and it scales saturation so that 100% means "as saturated as this hue can get at this lightness" rather than an arbitrary RGB limit. Okhsl builds on Oklab, which was designed to fix some of the hue-shift and blue-region issues that older spaces like CIELUV handle less gracefully.

Why this matters for a UI color system

When you generate a scale — say 50, 100, 200 … 900 — you want two properties:

  1. Even steps. The jump from 100 to 200 should feel similar to the jump from 700 to 800. In a perceptually uniform space, you can space lightness values evenly and get that result. In HSL, the same numeric spacing produces uneven visual steps.
  2. Cross-hue consistency. Your "500" for every hue should sit at the same apparent lightness, so a row of swatches reads as one family rather than a mix of light and dark chips.

This is exactly the job color × color describes itself as doing: creating accessible color systems for UIs using Okhsl or HSLuv to produce perceptually uniform colors. The choice of space is what makes the generated system coherent instead of a collection of individually tweaked colors.

The accessibility connection

Accessible UI color depends heavily on contrast, and contrast depends on relative luminance — how light a color actually is to the eye. Because HSL's L is not luminance, you cannot reliably predict contrast from HSL values. A perceptually uniform lightness axis gets you much closer to a value you can reason about: colors at the same lightness tend to have similar luminance, so text/background pairs that pass a contrast check at one hue are more likely to pass at another.

That does not mean the space enforces accessibility by itself. You still have to check contrast ratios for each foreground/background pair you ship. What the space gives you is a predictable starting point, so you spend effort on the few pairs that matter rather than re-checking every swatch.

Which one should you pick?

  • HSLuv — a good fit if you want HSL-style controls with trustworthy lightness and saturation that respects each hue's real limits. Familiar mental model, perceptually even lightness.
  • Okhsl — a good fit if you want smoother, more modern behavior across hues, especially in the blue and purple regions, and you are starting fresh rather than matching an existing HSLuv-based palette.

If you are migrating an existing design system, match the space your current tokens were built in to avoid shifting every color. If you are starting from scratch, either works; the important decision is to use one consistently, because mixing spaces reintroduces the inconsistency you were trying to remove.

What is color × color?

color × color is a browser-based tool for building accessible color systems for user interfaces. It generates color palettes using either the Okhsl or HSLuv color space, both of which are designed to be perceptually uniform — meaning equal steps in a color value look like equal steps to the human eye. If you are a UI designer or front-end developer who needs a palette where contrast and lightness behave predictably across hues, this tool targets exactly that problem.

What problem it solves

Picking colors by eye in a traditional color picker tends to produce palettes that look uneven. A "50% lightness" yellow and a "50% lightness" blue will not appear equally bright, and a set of shades generated by simple math often has inconsistent perceived contrast. This makes it hard to guarantee that text stays readable against every background in a system.

Perceptually uniform color spaces fix this by defining lightness and saturation so that numeric changes correspond to visual changes. color × color builds its output on that foundation, so a scale you generate is more likely to hold up when you apply it to real components — buttons, cards, alerts, text on surfaces.

The two color spaces

Color space What it is When it tends to be useful
Okhsl A perceptually uniform space derived from the Oklab model, with HSL-like controls When you want intuitive hue/saturation/lightness control while keeping perceptual uniformity
HSLuv A perceptually uniform alternative to HSL, built on CIELUV When you want a well-established uniform space with predictable lightness across hues

Both are offered because they make different trade-offs. The practical takeaway: you choose one, and the tool keeps your generated scales perceptually consistent rather than letting lightness drift as hue changes.

Who it is for

  • UI designers defining a design system's color tokens and needing shades that stay legible.
  • Front-end developers implementing those tokens in CSS or a component library and wanting contrast that holds across states (default, hover, disabled).
  • Anyone building a theme who needs a starting palette that is accessible rather than assembled by trial and error.

How to think about using it

  1. Decide on a color space. Start with one of Okhsl or HSLuv; the choice affects how the controls feel, not whether the output is uniform.
  2. Define your base hues. These are the brand or semantic colors (primary, success, warning, danger) your interface needs.
  3. Generate scales. The tool produces a range of shades per hue that share consistent perceptual steps.
  4. Check against your UI. Apply the shades to text, backgrounds, and borders, and verify that contrast holds where it matters.

The tool's stated purpose is creating accessible color systems, so the intended end state is a palette you can hand to implementation — not a single decorative color.

What to keep in mind

  • The site describes itself as a tool for creating accessible color systems; it does not, based on the available information, publish pricing or account requirements, so treat access and cost as unconfirmed rather than assuming it is free or login-free.
  • Perceptually uniform generation improves consistency, but it does not by itself certify WCAG contrast. You still need to check specific foreground/background pairs against the standard you are targeting.
  • Okhsl and HSLuv are alternatives, not a sequence — you do not need to use both.
What makes a color system accessible for UIs?

An accessible UI color system is one where every text, icon, and control color pair meets a contrast threshold against its background, and where the palette stays predictable as you add or shift colors. In practice that means two things: you check contrast ratios (WCAG requires 4.5:1 for normal text and 3:1 for large text and UI components), and you build the palette in a color space where equal steps look equal. color × color is a tool built around the second point — it generates UI color systems in Okhsl or HSLuv, two perceptually uniform color spaces, so a lightness scale you define behaves consistently across hues.

The two requirements, separated

1. Contrast is the pass/fail gate

Contrast ratio is a measurable number, not a matter of taste. For any foreground/background pair:

  • Normal body text: at least 4.5:1
  • Large text (roughly 18pt regular or 14pt bold and up): at least 3:1
  • UI components and graphical objects (borders, icons, focus rings, chart lines): at least 3:1

A palette can look beautiful and still fail here. This is the check you run last, on the actual pairs you ship.

2. Perceptual uniformity is what makes the gate easy to pass

In a perceptually uniform space, moving a fixed amount in lightness produces a visually equal change, regardless of hue. That matters because human vision is not equally sensitive to all hues: a yellow and a blue at the same HSL lightness do not look equally bright, and they do not have the same contrast against white.

If you build scales in plain HSL, your "500" step for yellow and your "500" step for blue will have different contrast against the same background. You end up hand-tuning every hue, and every new color breaks the pattern.

Okhsl and HSLuv are designed to fix this. HSLuv keeps the familiar HSL model but corrects lightness and saturation to be perceptually even; Okhsl is a more recent model in the same family that aims for better behavior in the darker and more saturated regions. Building in either means a lightness step you pick once tends to hold its contrast across the whole hue wheel.

How this plays out in a real UI task

Say you need a 10-step scale for each of five brand hues, and every scale's mid step must be readable as text on white.

  1. Pick a perceptually uniform space (Okhsl or HSLuv) rather than raw HSL.
  2. Define your lightness ramp once — e.g. steps from near-white to near-black at even perceptual intervals.
  3. Apply that same ramp to every hue. Because lightness is perceptually even, the step that passes contrast on white for blue will pass for red and green too.
  4. Verify the actual pairs with a contrast checker, since uniformity gets you close but does not guarantee the 4.5:1 line for every combination.
  5. Re-check interactive states — hover, disabled, focus, and dark-mode variants are separate pairs and need their own pass.

Step 3 is where the time savings show up. Without perceptual uniformity, step 3 is manual work per hue; with it, step 3 is a copy of the same ramp.

What designers should verify before shipping

Check Why it matters
Text/background contrast ≥ 4.5:1 (normal), ≥ 3:1 (large) The core WCAG requirement
Component contrast ≥ 3:1 Borders, icons, focus indicators must be visible
Focus states distinguishable Keyboard users need a visible, high-contrast focus ring
Dark mode pairs checked separately A pair that passes on white can fail on near-black
Disabled states still legible Low-contrast disabled text is a common failure
Color not the only signal Error/success states need an icon or label, not just red/green
Scale steps evenly spaced perceptually Keeps the system predictable as it grows

Where a tool like color × color fits

color × color is described as a tool to create accessible color systems for UIs, using Okhsl or HSLuv to produce perceptually uniform colors. Its role is the palette-construction half of the problem: it gives you scales whose steps behave consistently, which removes most of the manual tuning that normally precedes contrast checking. It does not replace the contrast check itself — you still confirm the specific foreground/background pairs you ship, including dark mode and interactive states.

If your goal is a palette that stays consistent across many hues and survives a dark-mode addition without a redesign, building in a perceptually uniform space is the decision that saves the most rework. If you only need one or two colors, plain HSL plus a contrast checker is enough.

Okhsl vs HSLuv: which color space should I use in color × color?

Pick Okhsl if you want the most perceptually even lightness and saturation across the full hue circle, especially for building a UI palette with many steps. Pick HSLuv if you need predictable, spec-backed results that match the HSL mental model closely and you value a long-established, widely implemented standard. Both are available in color × color, and both are designed to avoid the uneven lightness that plain HSL produces.

What each color space actually does

Plain HSL is easy to reason about but not perceptually uniform: a yellow at 50% lightness looks far brighter than a blue at 50% lightness. Both Okhsl and HSLuv fix that by deriving their values from a perceptually uniform base space.

Okhsl HSLuv
Base model Built on Oklab Built on CIELUV (Luv)
Goal HSL-like controls with perceptual uniformity HSL-like controls with perceptual uniformity
Lightness behavior Tuned so equal lightness reads as equal brightness Same intent, derived from Luv's L*
Saturation/gamut Handles out-of-gamut colors by reducing saturation Clamps to sRGB gamut, keeping hue and lightness
Maturity Newer Older, more widely adopted

The practical difference is in how each one treats colors that fall outside what sRGB can display. HSLuv keeps your chosen hue and lightness and pulls saturation down until the color is displayable. Okhsl takes a similar approach but its underlying Oklab model tends to distribute perceived lightness and chroma more evenly, particularly in the blues and purples where HSLuv can feel less consistent.

Which one to choose

Choose Okhsl when:

  • You are generating a full ramp of tints and shades and want each step to feel evenly spaced.
  • Your palette leans on blues, purples, or other hues where perceptual evenness is hardest to achieve.
  • You want the most modern perceptual model available in the tool.

Choose HSLuv when:

  • You want results that align with an established, widely documented standard.
  • You are matching colors to an existing design system or library that already uses HSLuv.
  • You prefer the more familiar HSL-style behavior and want broad ecosystem compatibility.

If you are unsure, build a small test ramp in both and compare the mid-tones side by side — the difference is usually most visible in blue and purple hues.

How to test the choice in color × color

  1. Open color × color and start a new color system.
  2. Set the color space to Okhsl, then generate a ramp for a hue you care about (for example, a brand blue).
  3. Note how evenly the lightness steps read from light to dark.
  4. Switch the color space to HSLuv and regenerate the same hue.
  5. Compare the two ramps at the same number of steps.

Expected result: both ramps should avoid the "muddy middle" problem of plain HSL, but the Okhsl ramp will typically show more consistent perceived brightness between steps. If your two ramps look nearly identical for your chosen hue, either space will serve you — pick HSLuv for compatibility.

Common sticking points

  • Neither space makes a bad palette good. Perceptual uniformity fixes lightness consistency, not contrast or harmony. You still need to check contrast ratios for text and UI elements.
  • Gamut clipping is not a bug. When a color can't be shown in sRGB, both spaces adjust it rather than failing. Expect saturation to drop near the edges of the gamut.
  • Don't mix spaces mid-system. Pick one space per project so your steps stay comparable.

The short answer

Use Okhsl for the most perceptually even UI ramps and HSLuv for standards compatibility and a more familiar HSL feel. For most new UI color systems, Okhsl is the stronger default; switch to HSLuv when you need to match an existing HSLuv-based system.

Website Overview

An established domain and managed infrastructure suggest continuity of operations and may support dependable delivery, although neither guarantees service quality.

Domain and Registration

Registered in 2020, this domain has about 6 years of history. That suggests continuity, although ownership and purpose may have changed. Transfer-protection status is present, helping reduce the risk of unauthorized domain transfers. The registrar is Porkbun LLC, a widely used domain service provider. Registration contact information is publicly available through RDAP. The domain uses the common .in extension, which is not an independent safety signal.

DNS and Email

Nameservers are provided by NS1, indicating managed DNS hosting. No CNAME was found; the observed records resolve directly to addresses. No MX record was found. A conventional explicit inbound-mail route is not configured. TXT records include verification markers for Google. Such markers may also remain after a service stops being used. DNSSEC signatures were not detected, so this additional DNS authenticity protection is not confirmed.

TLS and Certificates

The public key uses EC with 256 bits. The server supplied a complete certificate chain. No organization name is present in the certificate; the available fields are consistent with domain validation. The certificate was issued by Let's Encrypt, commonly associated with automated certificate services. The certificate's total validity is about 89 days, consistent with a short renewal cycle.

HTTP and Browser Security

The response lacks these common security headers: CSP, X-Content-Type-Options, Referrer-Policy, clickjacking protection. No X-Powered-By header was found, reducing one common source of backend fingerprinting information. No obvious internal addresses or debug information were found in the headers. The Server header contains the custom value Netlify. No explicit CDN or WAF marker was found in the response headers.

Technology Stack Analysis

The public page identifies Netlify without precise versions, leaving fewer clues for version-specific scanning.

Search and Social Sharing

No homepage canonical URL was detected. If duplicate URLs exist, consolidation may be less explicit. Twitter Card metadata is configured. The title has 13 characters, within a common display range. A meta description is present, with 144 characters. The observed directives allow indexing and link following.

Hosting and Email

DNSNS1
HostingNetlify
EmailUnknown
Approximate IP geolocation (inferred; a CDN or proxy may differ from the origin server) United States flagAshburn, Virginia, United States Inferred 18.208.88.157

Registration details

RDAP / WHOIS

RegistrarPorkbun LLC
Registered2020-03-28
Expires2027-03-28
Domain statusclient transfer prohibited、client delete prohibited
Nameserversdns1.p02.nsone.net、dns2.p02.nsone.net、dns3.p02.nsone.net、dns4.p02.nsone.net
DNSSECunsigned

DNS records

DNS

TypeNameValueTTLPriority
Acolorcolor.in18.208.88.157120—
Acolorcolor.in98.84.224.111120—
AAAAcolorcolor.in2600:1f18:16e:df01::258311—
AAAAcolorcolor.in2600:1f18:16e:df01::259311—
NScolorcolor.indns1.p02.nsone.net3600—
NScolorcolor.indns2.p02.nsone.net3600—
NScolorcolor.indns3.p02.nsone.net3600—
NScolorcolor.indns4.p02.nsone.net3600—
TXTcolorcolor.inNeatStats:a55447acadeda3dd300—
TXTcolorcolor.ingoogle-site-verification=_VTD7bsU0nMhXTEDJSusbAqRHBcrhHutVSfsYIcb2Hw300—

TLS and certificates

TLS / SSL

AssessmentNormal configuration
Supported protocolsTLSv1.2、TLSv1.3
Negotiated protocolTLSv1.3
Certificate subjectcolorcolor.in
IssuerLet's Encrypt
Valid until2026-12-22T07:06 · Remaining when checked: 81 days
Verification detailsCertificate trust: Passed · Hostname match: Passed

HTTP response headers

HTTP

HeaderValue
content-typetext/html; charset=UTF-8
cache-controlmax-age=0, no-cache, no-store, must-revalidate
serverNetlify
strict-transport-securitymax-age=31536000
permissions-policyinterest-cohort=()

Identified technologies

Netlify

Pages, Search and Sharing

Meta descriptionColor-color is a tool to create accessible color systems for UIs. You can use Okhsl or HSLuv color spaces to create perceptually uniform colors.
Canonical URLNot detected
LanguageEnglish (default)
Twitter Cardsummary_large_image

No robots.txt found

No sitemaps found

User reviews (0)

  • No reviews yet.