Why I Stopped Sending Design Tokens to the Cloud

I used to spend about twenty minutes a week manually tweaking hex codes. It wasn’t just the clicking; it was the anxiety of opening a tab to a cloud-based palette generator, worrying that my proprietary brand colors were being fed into a black-box API, and then realizing the result still didn’t quite fit the specific contrast ratios I needed for accessibility.

We’ve been trained to think that "AI" means sending data to a server. But for a task as local and immediate as color theory, that round-trip latency and privacy risk feel like unnecessary friction. I built ChromaCore to solve that specific wedge: a tool that generates brand-compliant palettes entirely in your browser using WebGPU. Nothing leaves your machine. If you disconnect your Wi-Fi, it still works.

The WebGPU Advantage for Color Math

The core idea was simple: if we can run large language models in the browser, we can certainly run color harmony algorithms there. The challenge wasn’t the algorithm—it was the performance. Traditional JavaScript loops struggle when you’re iterating through thousands of potential color combinations while checking for WCAG 2.1 compliance in real-time.

WebGPU changes the game here. By offloading the heavy lifting to the GPU, we can calculate complex color relationships—like analogous, triadic, or split-complementary schemes—without blocking the main thread. The result is an interface that feels instant. You adjust a slider, and the palette updates. There is no "loading" spinner. There is no network request.

This isn’t just about speed; it’s about trust. When I’m working on a client’s rebrand, I don’t want to think about where their data lives. I want to know that the only place my hex codes exist is on my local machine.

Building for the Browser, Not the Backend

Writing this kind of tool required a shift in mindset. Usually, when we build "AI" features, we’re thinking about API keys, rate limits, and server costs. With ChromaCore, the architecture is inverted. The intelligence lives in a small model that runs in your browser.

Here is how the core generation logic looks conceptually. It’s not magic; it’s math running on your graphics card:

// No fetch calls. No API keys.
// Just direct GPU computation via WebGPU shaders.

const generatePalette = (baseColor, harmonyType) => {
  // 1. Convert baseColor to HSL
  // 2. Apply harmony offset logic on GPU
  // 3. Filter for WCAG AA/AAA contrast against background
  // 4. Return compliant hex codes
  return gpuShader.run(baseColor, harmonyType);
};

The beauty of this approach is that it scales with the user’s hardware. If you have a modern laptop, it’s instantaneous. If you’re on an older device, it’s still fast enough to be usable, and crucially, it never fails because a cloud service is down.

The Trade-offs of Local AI

It’s important to be honest about what this means for the user. Because the processing happens locally, the "AI" isn’t a massive, generic model trained on the entire internet. It’s a specialized, lightweight engine optimized specifically for color theory and brand compliance.

This is a paid tool, though it comes with a 7-day trial so you can test it with your own design systems. (If you’re more into the experimental side, the companion games have free turns to test the generation logic). I chose this model because maintaining a high-quality, privacy-first experience requires resources. I’m not subsidizing this with ads or data collection.

Rethinking "Smart" Tools

I’ve been surprised by how often developers default to cloud solutions for problems that are inherently local. We assume we need the cloud because we’ve been told that AI is too heavy for the browser. But with WebGPU and WebAssembly, that line is blurring.

ChromaCore started as a way to save me twenty minutes a week. It evolved into a proof of concept: that some of the most useful "AI" tools don’t need to be connected to the internet to be intelligent. They just need to be fast, private, and accurate.

I’m curious to hear from other builders here: What’s a task in your daily workflow that you’ve been sending to the cloud, but you suspect could actually run locally on your machine?