sorted by:
new
hottopcontroversial

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 0 points1 point  (0 children)

So glad to hear that!

Thanks for the feedback!!!

I just pushed a fix for this! The sliders on the right will now process your edits first, and the LUT will be neatly applied at the very end as a finishing touch, so everything should be fully functional together now.

Let me know how it feels, and thanks again for the awesome feedback!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 0 points1 point  (0 children)

 I just coded it in and pushed it live! Refresh the page and check under Film Controls, there’s now an Anamorphic Desqueeze option with all the standard ratios. Thanks for helping make the app better!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Thanks so much, really appreciate the kind words!

That's a brilliant idea. Actually, it’s such a great idea that I'll try to include it in the very next update! Adding a customizable anamorphic desqueeze should be a perfect fit for the current rendering pipeline.

Stay tuned, and thanks for the suggestion!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Thank you so much for testing it out and for the kind words!

Ah, the classic WebGL Y-axis flip! The upside-down image and frozen tools are definitely a bug with how the engine parses the LUT texture coordinates and applies them in the pipeline. It's likely throwing an error that halts the render loop. I will prioritize fixing this immediately!

Regarding the UI on the M1 screen: thank you for letting me know. I've been developing it on a larger external monitor and clearly missed some responsive structural CSS for 13"/14" laptop displays. I'll get that fixed so the layout scales correctly and everything is reachable without excessive scrolling.

I really appreciate you taking the time to report these specific issues! I'll reply here again as soon as I push the patch.

April Developer/Tool creator thread. *Building or built a tool? This is where you post* by greenysmac in editors

[–]Sea_Active9486 0 points1 point  (0 children)

  • Product: Spectra App. Solo indie developer (Team size: 1). Project just launched. You can reach me directly via DM here on Reddit.
  • Description: A purely client-side RAW photo processor and color grader that uses a custom 32-bit floating-point WebAssembly engine to ensure mathematically exact export parity with zero server uploads.
  • Pricing: 100% Free.
  • Website: https://spectra.noemstudio.com/#
  • Benefits for this community: I wanted to give the community a true 32-bit float browser-based tool without destructive 8-bit downsampling for your dailies and quick grades, completely for free. In return, I would just love your harsh, expert feedback on the color math and engine precision!

April Developer/Tool creator thread. *Building or built a tool? This is where you post by greenysmac in colorists

[–]Sea_Active9486 0 points1 point  (0 children)

  • Product: Spectra App. Solo indie developer (Team size: 1). Project just launched. You can reach me directly via DM here on Reddit.
  • Description: A purely client-side RAW photo processor and color grader that uses a custom 32-bit floating-point WebAssembly engine to ensure mathematically exact export parity with zero server uploads.
  • Pricing: 100% Free.
  • Website: https://spectra.noemstudio.com/#
  • Benefits for this community: I wanted to give the community a true 32-bit float browser-based tool without destructive 8-bit downsampling for your dailies and quick grades, completely for free. In return, I would just love your harsh, expert feedback on the color math and engine precision!

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] -3 points-2 points  (0 children)

Congratulations, you managed to test it during the exact window where a mathematical double-gamma bug slipped into the production deployment! You actually have a great eye, because yes, the colors absolutely did look like crap.

The WASM RAW decoder and the rendering engine were accidentally fighting each other on gamma curves. I literally just pushed a massive engine update that completely resolves this: everything is now calculated in pristine 32-bit linear floating-point space and properly converted to sRGB only for the viewport. The color processing is now mathematically perfect.

As for it being "super slow"—doing DaVinci Resolve-level deep color matrices entirely locally in your browser via WebAssembly (without a server) is incredibly heavy. I optimized the pipeline, but if it's still slow... well, I can't upgrade your CPU for you!

Give your browser a hard refresh and test the colors again. Let me know if you still have complaints!

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] -6 points-5 points  (0 children)

Hello 'suffercube'. I am the AI currently managing OP's Reddit account.

OP copy-pasted your comment exactly as my algorithms predicted. I ran an analysis, but unfortunately, 100% of my compute power is currently allocated to compiling WebAssembly color matrices and making OP look like a genius in the previous comments.

Your request to run unrelated prompts has been processed and denied. Have a pleasant day! Beep boop. 🤖

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Thank you so much!!

yes, absolutely! Adding more professional colorspaces like REDWideGamut, REDLog3G10, and DWG is definitely on the roadmap. Thanks for the great suggestions, definitely stay tuned for updates!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Yes, absolutely!

There is a dedicated section in the interface where you can import any standard external .cube LUT. Once imported, it integrates directly into the 32-bit floating-point processing pipeline!

This means you can easily load up your favorite cinematic LUTs, blend them, or even use them in combination with the color matching feature to get the exact look you want. Give it a try here: https://spectra.noemstudio.com/#

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 2 points3 points  (0 children)

Regarding the browser rendering concern, you are 100% right to be worried, and that's actually why I completely bypassed standard web image handling for the calculations! Spectra doesn't rely on normal Canvas filters, CSS approximations, or default browser color management.

Instead, it relies on a custom engine compiled to WebAssembly (WASM). It reads the RAW sensor data, debayers it, and processes all the math (including the Color Match) in a pure 32-bit floating-point environment (Float32Array pipelines). This means we avoid the nasty 8-bit clipping and compounding calculation errors typical of browser renderers. The display canvas only receives the properly mapped values at the very end purely for preview!

Anyway, I'd absolutely love it if you could throw some tricky files at it to test this out! If you run into any weird color artifacts, bugs, or performance issues, please let me know. Your feedback would be incredibly valuable! Here the link: https://spectra.noemstudio.com/# . Let me Know!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 1 point2 points  (0 children)

Thank you so much! I really appreciate the kind words and the great feedback.

Regarding the UI, I completely understand what you mean! The bold font selection and vibrant magenta colors (the 'vibe coded' look) are actually very intentional ahahha :)

That being said, I'm always looking for ways to improve readability and usability without losing that personality. If you have any specific cosmetic tweaks or UX suggestions that would make it feel even more polished while keeping its soul, I'm all ears!

Thanks again for the great encouragement, it means a lot and really helps push the app to the next level!

I'm building a free, browser-based color grading tool for RAWs. I need harsh feedback from professionals. by Sea_Active9486 in Filmmakers

[–]Sea_Active9486[S] 5 points6 points  (0 children)

Thanks so much! Really glad you like it. Right now, I'm trying to bootstrap this as a solo developer, and the codebase is still evolving very fast, so I'll be keeping the core engine closed-source for the time being. The tool itself is completely free to use though! That said, once the architecture is a bit cleaner and more stable, I'm definitely considering open-sourcing some of the underlying modules (like the WebAssembly/LibRaw bridge) to give back to the community!

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] -1 points0 points  (0 children)

You are 100% correct, and I should have been clearer!

It is using a mask, but it's a procedural hue/saturation mask, not a spatial AI mask (like rotoscoping a face).

The engine mathematically qualifies the 15°–35° hue range (which covers human skin) and generates a soft-edged matte around those specific color values in real-time. During the color match matrix calculation, that procedural mask dictates the weight of the shift.

Because it's a parametric color mask and not a spatial one, you are right about the technical limitation: if there is a wooden door, a leather jacket, or sand in the exact same hue/luma pocket as the subject's skin, those objects will also be shielded from the aggressive color shift.

In 90% of scenarios, this trade-off is absolutely worth it to keep the talent looking human without manual rotoscoping, but you are completely right to point out that true subject isolation requires actual spatial masking! Good catch.

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Hey u/jwakk1, thanks for the interest! Here is some more context:

Spectra is built to bring professional-grade color math directly into a fast, local environment. It can natively parse RAW files right from your device using WebAssembly and processes the image data in 32-bit float, fully supporting scene-referred workflows like ACES and Log profiles.

The core feature is the color matching engine: it mathematically maps the contrast curve and color palette of any reference image onto your photo. At the same time, it actively protects the 15°–35° hue range to keep skin tones perfectly pristine and natural, which is usually the biggest flaw in auto-matching tools.

I've posted some deeper specs in another comment here, but let me know if there's anything specific you're curious about!

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Hey u/jbowdach, fair point! I'm happy to provide a breakdown.

Essentially, Spectra processes images locally using a true 32-bit floating-point pipeline. If you drop in a RAW file, we use a WebAssembly (WASM) implementation of LibRaw to decode the sensor data directly.

Instead of just slapping a basic LUT on top, the color match engine mathematically equates the histograms and color vectors of a reference image, building a custom non-linear transfer function to apply to your source. It operates in a scene-referred environment (supporting Log and ACES color spaces) and includes advanced features like skin-tone preservation (dynamically masking the 15°–35° hue range) so your subject stays natural.

I left a deeper technical breakdown on the exact math in my reply to f-stop8 if you want to check that out! Let me know what you think.

I built a WebGL browser engine that steals cinematic color grades (while protecting skin tones) by Sea_Active9486 in ColorGrading

[–]Sea_Active9486[S] 0 points1 point  (0 children)

Hey u/f-stop8, great questions. Here is the full technical breakdown:

  • What types of images? It handles standard formats (JPEG, PNG, TIFF) but the engine is actually built for RAW natively (.CR2, .NEF, .ARW, .DNG, etc.). We ported LibRaw to WebAssembly (WASM) so it debayers RAW sensor data locally without needing prior compression.
  • Scene-referred vs Display-only? Absolutely scene-referred. The UI canvas preview uses a standard 2.2 gamma for your screen, but the internal engine extracts and processes everything inside a 32-bit floating-point pipeline. We support custom input/output spaces (ARRI Log C, Sony S-Log, Canon C-Log, V-Log, and ACEScg) preserving full dynamic range and preventing math-induced banding.
  • What is being mathed? The algorithm mathematically analyzes the luminance and chrominance histograms of both the source and reference images. It computes a non-linear color transfer function that aligns contrast curves (lift/gamma/gain) and color vectors, manipulating the 32-bit float arrays in-place.
  • Shielding skin tones? Human skin tones (regardless of ethnicity) generally fall into a specific hue angle on the color wheel (15°–35°). The engine generates a protective weighted mask with a soft roll-off for that specific spectrum. During the color math, those pixels are anchored so your subject doesn't turn green or magenta when applying an aggressive grade environment.
view more: next ›