Readable app themes from 10,000 video covers
Bibel TV has over 10,000 videos in its catalog and a team too small to hand-pick a theme color for each one. A larger operation might do that as part of its artwork pipeline; here the colors had to come from the artwork itself. I built the engine that does it, in OKLCH, tuned to the brand's own needs.
A readable theme from every artwork, computed instead of picked
- The setting
- Bibel TV, a German broadcaster moving from linear TV to apps and streaming. More than 10,000 videos, not every one with professional cover art, and an app redesign in which light mode had to look good too.
- My part
- I built the color engine and Color Lab, the configuration tool that keeps the engine's settings in design's hands. Both are live.
- What changed
- Measured on 14 real artworks through the production API: the engine held every dark card panel at OKLCH lightness 0.25–0.27 and every light one at 0.84–0.87, and every card cleared contrast with its text. imgix's palette ranged from 0.16 to 0.57 on dark, and one card fell below 4.5:1. In the 6.0 release build (in beta), the page gradient on Home and the detail views is computed from the artwork.
- Three takeaways
- Run the off-the-shelf tool on real images before you build. When output looks uneven, check the color space before the algorithm. Give the people who own the brand the settings.
The first attempt was one URL parameter
Bibel TV already serves its images through imgix, and imgix returns a color palette for any image if you add one URL parameter. Because we basically had it for free, it won stakeholder buy-in for colors taken from the artwork. In October 2025 we tested it on 100 images.
The first attempt, October 2025: imgix's named palette for one image, six colors from one URL parameter. On this still of green water and sand, all six land in brown, rose and cream.
The four palettes on a content card. The test's verdict: text colors taken from the palette were not reliably accessible; fixed text colors over the palette color were.
Two problems showed up. The colors collapsed: dark mode drifted toward beige and brown, light mode toward pink and rose, so different artworks ended up with too-similar themes. And the colors were not perceptually uniform. Some cards came back heavy, others washed out, and the uneven weight added noise to the interface.
Images that were mostly white came back white.
Nobody hand-picks colors for 10,000 videos
On a streaming home screen the artwork supplies the picture and the theme color frames it. Premium streamers color their interfaces from the artwork to varying degrees.
Bibel TV's catalog isn't the problem; Netflix's is bigger. Capacity is, and not every video has professional cover art.
If your product shows thousands of images you didn't make, the arithmetic is the same: the color has to be computed, and computed color has to hold up without a person checking each card.
Light mode was where generic extraction broke
The app redesign had moved toward light mode after a concept survey named brightness and readability as the core need; that story is told in the redesign study. For color, it meant light mode had to look really good too.
Dark mode wasn't as difficult. In light mode, anything generic struggled. As I read it, an extractor picks an image's most prominent colors, and in artwork full of people those are often skin tones. Certain hue ranges showed up far too often.
I didn't raise the issue before I had a solution. I built my own engine first, in a few iterations of Claude Code sessions against real images, and started the conversation once it worked.
A perceptual color space made the weight controllable
imgix's colors were not perceptually uniform: equal distances in its numbers did not look like equal distances to the eye, so cards came out at uneven visual weights. I built the engine in OKLCH, where lightness and chroma track how people see. That let the engine clamp every card to a narrow band of perceived lightness.
Fourteen artworks, imgix's panel above the engine's, with the WCAG contrast of each panel against its text. imgix's dark panels span OKLCH lightness 0.16 to 0.57, and one falls to 4.2:1 against white text; its light panels run from mid-tone to pure white. The color engine, from its production API, holds every dark panel at 0.25 to 0.27 and every light one at 0.84 to 0.87.
Dark card panels, fourteen artworks: imgix spans OKLCH lightness 0.16 to 0.57, the color engine 0.25 to 0.27.
The hues needed their own handling. I added filter settings that exclude problem ranges, fall back to other colors from the image that meet the criteria, and boost certain hues.
Concretely: on dark, a color that lands in muddy brown is skipped, and the next most common color in the image gets its turn. On light, the same happens to pink. Only when nothing qualifies does the engine shift a color's hue, as a last resort.
From artwork to theme in six steps
The engine takes an image and returns a light and a dark palette for it. A Figma plugin was also built against the same API, to put an artwork's colors or gradient on the selected layers.
From artwork to a JSON theme, in six steps.
-
Load the artwork
The API takes the artwork's image URL, or the image file itself.
-
Count the dominant colors
The image is shrunk to 64 by 64 pixels and its colors are counted. The most common ones become up to 15 candidates.
-
Normalize in OKLCH
Each candidate's lightness and chroma are clamped into a narrow band per mode. The hue stays.
-
Check contrast
The text colors are fixed: white on dark, near-black on light. The engine darkens or lightens the base in small steps until it clears the luminance threshold for that text; on dark, that means at least 7:1 against white.
-
Fall back
A color that lands in muddy brown on dark, or pink on light, is skipped for the next one. If none qualifies, the engine shifts the hue.
-
Return the theme
A dark and a light palette in hex: base, accent, text colors and a page gradient that ends on the app's own background color.
Design kept the settings
The settings inside the engine decide what the brand looks like on every card, so I kept them in design's hands. Color Lab is the configuration interface for that. It runs the same extraction code as the live API, so a setting tuned there gives the same result. It keeps the API flexible, so the team can fine-tune it on findings from real data and on user feedback.
The range runs from soft pastels to rich and vibrant. Early user feedback didn't want it too vibrant, so the team started in the middle of the road. What works best across the board remains to be seen.
The engine is bespoke to one brand, not a generic per-brand tool. It went live when I handed my GitHub repository to the backend team and they put it on a server. It runs on the backend and stores a color and gradient for every video, computed from its cover image.
A text-color option, held back on mobile
The engine also offers a text-color option. On mobile it was validated as too much color, so the mobile app goes without it.
The option stays in the engine for possible use on other platforms, or even on-air, where color picking is currently a manual process.
Live, measured on fourteen artworks, and still being tuned
What comes next is tuning in Color Lab, on findings from real data and on user feedback: where on the range from soft pastels to rich color the cards should sit.
One artwork, two themes. In the 6.0 release build, the page gradient on Home and the detail views is computed from the image: peach in light mode, deep green in dark.
- Readable text
- On the 14-artwork test, every engine card cleared contrast: 14.6–16.9 against white text on dark, 10.8–11.3 against dark text on light
- Even weight, measured
- Dark card panels at OKLCH lightness 0.25–0.27, light panels at 0.84–0.87, against imgix's 0.16–0.57 dark and 0.70–1.00 light, with two light tiles effectively white
- In the app
- The engine and Color Lab are live. On the backend, the engine stores a color and gradient for every video, computed from its cover image. In the 6.0 release build (in beta), the page gradient on Home and the detail views is computed from the artwork; one artwork yields a light and a dark theme, and six heroes give six themes.
One depth on dark, one lightness on light
Put the same fourteen artworks through the same card again. On dark, panels that once ran from near-black to bright green sit at one even depth. On light, panels that once ran to pure white hold one readable value, and no one checks them by hand.
The cost is in the same picture: the light panels bunch into beige and pale blue. That is the next job for the settings in Color Lab.
Rules for theming artwork you don't control
-
Run the off-the-shelf tool on real images before you build.
One URL parameter and a test on 100 images showed what a custom engine had to solve. Look at a whole grid of results, not one card at a time; uneven weight only shows across many.
-
When output looks uneven, check the color space before the algorithm.
If your pipeline reasons in RGB, distance in the numbers is not distance to the eye. Move the extraction into a perceptual space such as OKLCH, then see what is left to fix.
-
Give the people who own the brand the settings.
Hue filters, boosts and the pastel-to-vibrant range are taste decisions. Test it: can someone outside engineering change one and see the result without a deploy?
Dozens of images need a spot check, and nothing more
If your product renders dozens of images rather than thousands, an off-the-shelf extractor and a spot check are the right amount of system. A bespoke engine would be maintenance without a payoff.
The same holds if nobody on your side will own the settings. An engine nobody tunes is a black box.
Want to hear more?
- How many images does your product show that nobody on your team chose? And who decides the color around them today? Those two answers tell you whether you need an engine or a spot check.