WearProof

WearProof measures your skin, hair, and eye color and scores your outfit against your palette, if clash --> generates the right top and tries it on you. Skin AI and VTO as one loop, not two features.

Comment

Inspiration

I've been into fashion tech for a long time. About ten years ago, I already wanted to build an app that could look at me — not a model, not a mood board — and tell me whether a color actually worked on my face, then show me a better option on my body. Not a quiz. Not “you might be an autumn.” Something that could see my skin, my hair, my eyes, and my outfit in one flow.

The idea never left, but the stack wasn't there. Reliable face analysis, garment virtual try-on, and fast image generation were either research-lab territory or required a team I didn't have. A solo side project couldn't close the loop: measure → diagnose → fix → prove. So the concept sat in my notes while styling apps stayed subjective — vibes, sliders, generic advice.

This hackathon felt like the moment the pieces finally aligned. YouCam API brings production-grade Skin AI and Apparel VTO behind one door. fal.ai fills the gap YouCam can't: reading an outfit from a photo and generating a replacement garment image to try on. For the first time, I could build the app I imagined ten years ago — alone, and make Skin AI and VTO feel like one product, not two demos stitched together.

What it does

WearProof is a wear proof, not fashion advice.

You upload two photos: a close-up face scan and an outfit shot. The app measures your coloring with YouCam face attribute analysis (skin, hair, and eye hex values) and skin analysis (facial redness). It reads your outfit with a vision model — garment type, category, perceived color — then scores harmony against a personal palette derived from real color science, not a chatbot opinion.

It finds the single worst clash — for example, a warm red top amplifying measured facial redness — then fixes it: generates a palette-correct garment and runs YouCam cloth-v3 virtual try-on on your photo. The match score climbs live. In our flagship demo, a clash scores 53; after one tap, the fix scores 96. The wow moment isn't a paragraph of styling tips. It's a number that moves after you see yourself wearing the fix.

How we built it

I built WearProof with Next.js 16 (App Router), React 19, TypeScript, and Tailwind v4. All API keys stay server-side; the browser only talks to my route handlers.

The core is a small pipeline — analyze, apply fix, optional restyle — that orchestrates YouCam and fal.ai clients behind interfaces with a demo-mode fixture layer. That let the full loop run before my API key arrived and during demos without burning units.

The part I'm most proud of is the color engine. YouCam returns hex colors. I convert through sRGB → XYZ → CIELAB, then to LCh for hue and chroma logic. From measured skin, hair, and eye colors I compute four axes — undertone, value, chroma, and contrast — and classify into one of twelve seasons, each with a flattering palette.

Palette fit uses perceptual color distance. From YouCam hex outputs we derive CIELAB coordinates (L*, a*, b*), classify a season from those four axes, then score each garment with CIEDE2000:

$$ \Delta E_{00} = \sqrt{ \left(\frac{\Delta L'}{k_L S_L}\right)^2 + \left(\frac{\Delta C'}{k_C S_C}\right)^2 + \left(\frac{\Delta H'}{k_H S_H}\right)^2 + R_T \left(\frac{\Delta C'}{k_C S_C}\right)\left(\frac{\Delta H'}{k_H S_H}\right) } $$

I validated the implementation against the Sharma et al. (2005) reference test suite — fourteen canonical pairs, all passing. When Skin AI reports high facial redness, warm reds near the face incur an additional penalty, so the worst clash is grounded in measured skin signal, not a chatbot guess.

Every YouCam endpoint I use accepts a public image URL. User photos go to fal storage once; the same URL feeds vision perception, face analysis, skin analysis, and try-on. That removed a fragile upload dance and kept the UX to two taps.

Beyond the color fix, I added a style playground on four measured axes — structure, formality, embellishment, boldness. "Edgier" and "classier" are directional moves along those axes that still pick colors from the user's season palette, so style exploration doesn't drift off-palette.

To protect a solo hackathon budget, I added in-memory caching for identical inputs, a per-process unit guard, and a zero-cost probe script to verify API keys and print per-feature unit costs before spending credits.

Challenges we ran into

Skin AI and VTO have different capture needs, so I chose a two-step UI — face close-up plus outfit shot — instead of one photo and fragile cropping.

YouCam VTO needs a garment image, not a text prompt, so fal.ai generates the corrected garment and YouCam tries it on. That two-vendor pipeline was deliberate, not accidental.

Tuning the redness rule took iteration. Warm brick-red wasn't always caught as "warm red," and in-palette cool accents in warm seasons were sometimes over-penalized. Expanding hue detection and gating temperature penalties fixed the demo's score climb from modest improvement to a dramatic 53 → 96.

Building without keys first was another challenge. Fixture clients mirroring real response shapes meant the pipeline, UI, and tests were green before the API key arrived — essential for a solo build on a clock.

Accomplishments that we're proud of

The color engine described above.

What we learned

The biggest lesson was that operate beats advise. The wow factor wasn't three bullet points about my undertone. It was watching a clash get fixed on my own photo while a score climbed. Closing the loop changes how people trust the product.

I also learned to split deterministic layers from AI layers. Vision models are excellent at what someone is wearing; they're unreliable at whether a color is scientifically harmonious. Putting CIELAB math underneath the verdict made the app defensible and debuggable. When the demo brick-red wasn't triggering the redness rule, I could trace it to a hue threshold — not re-prompt a model and hope.

YouCam's async task-and-poll pattern is correct for heavy inference, but easy to get wrong — timeouts, invalid task IDs if you stop polling too soon. Wrapping poll logic once in a client and building demo fixtures early saved hours.

The hackathon time limit was a gift. I couldn't ship body-type detection, full color science, VTO, and style axes in sixteen hours. Cutting body shape — I spec'd it separately for a future MediaPipe side project — and keeping one spine (worst clash → fix → prove) made the story legible to judges in two minutes.

What's next for WearProof

Ten years ago I couldn't build this alone. Today, WearProof is the app I always wanted: your measured colors, your worst clash, your fix, on you — with math and APIs I can actually ship. I will definitely continue buidling in FashionTech space and will try to integrate WearProof in some more advanced application, as well as try to validate it with end-users.

References

  1. CIE (2004). Colorimetry (CIE 015:2004), 3rd edition. Commission Internationale de l'Éclairage. Defines CIELAB (L*, a*, b*) and related colorimetric transforms used in the pipeline.

  2. Luo, M. R., Cui, G., & Rigg, B. (2001). The development of the CIE 2000 colour-difference formula: CIEDE2000. Color Research & Application, 26(5), 340–350. https://doi.org/10.1002/col.1050

  3. Sharma, G., Wu, W., & Dalal, E. N. (2005). The CIEDE2000 color-difference formula: Implementation notes, supplementary test data, and mathematical observations. Color Research & Application, 30(1), 21–30. https://doi.org/10.1002/col.20010

  4. Perfect Corp. YouCam API documentation — Skin AI (face-attr-analysis, skin-analysis) and Apparel VTO (cloth-v3). https://docs.perfectcorp.com/

  5. fal.ai. Model APIs used for outfit perception (any-llm/vision) and garment image generation (flux/schnell). https://fal.ai/models

Built With

Share this project:

Updates

Submission history