Introduction
You are in the color suite at 2 AM. The director just emailed a .cube LUT from the colorist and wants to know if it works on the dailies before tomorrow morning's review. You could launch DaVinci Resolve, wait for the project to load, import the LUT, apply it to a frame grab, and export a still. That is 15 minutes of overhead for a 5-second question. Or you could drag the .cube file and a JPEG into this tool and see the result instantly, right in your browser.
The LUT Previewer applies 3D .cube LUTs to any reference image using WebGL2 hardware acceleration. No server upload, no software install, no account. Your footage stays on your machine. Drop a .cube file, drop an image, and drag the split slider to compare before and after in real time.
What This Tool Calculates
The tool takes two inputs and produces a graded preview:
**LUT input:** A .cube file (Adobe/IRIDAS specification 1.0) containing a 3D lookup table. The parser reads the LUT_3D_SIZE keyword to determine the cube dimension (typically 17, 33, or 64), extracts TITLE, DOMAIN_MIN, and DOMAIN_MAX metadata, and loads the RGB data array. The data is ordered with Red varying fastest, then Green, then Blue, per the specification.
**Image input:** A JPG, PNG, or WebP file, or one of four built-in preset reference images (color checker, gradient ramp, skin tones, HDR scene). The image is uploaded as a WebGL2 texture.
**Outputs:** A real-time graded preview rendered via a WebGL2 fragment shader using a sampler3D texture for hardware trilinear interpolation. The tool provides a before/after split slider (horizontal wipe), an intensity mix slider (0 to 100%), a histogram (before and after), LUT metadata display (title, size, domain), and PNG/JPEG export of the graded image.
The Formula and How It Works
A 3D LUT maps every possible RGB input color to a new RGB output color. The LUT is stored as an n x n x n grid of RGB samples, where n is the LUT size (commonly 33 or 64). For an 8-bit image with 256 values per channel, the LUT grid is much coarser than the full color space, so interpolation fills the gaps.
The tool uses **trilinear interpolation** via the GPU's hardware texture sampling unit. The WebGL2 fragment shader samples the 3D LUT texture using a sampler3D uniform with LINEAR filtering, which performs trilinear interpolation in hardware. The coordinate mapping follows the approach described in GPU Gems 2, Chapter 24 ("Using Lookup Tables to Accelerate Color Transformation"):
`lutCoord = scale * color.rgb + offset`
Where `scale = (lutSize - 1) / lutSize` and `offset = 1 / (2 * lutSize)`. This mapping ensures that input color values (0.0 to 1.0) map correctly to texel centers in the 3D texture, avoiding edge artifacts.
The intensity mix is a simple linear blend: `result = mix(original, lutColor, intensity)`. At 100% intensity, the LUT is applied fully. At 50%, the effect is blended halfway with the original image.
The .cube format is defined by the Adobe/IRIDAS .cube LUT Specification 1.0. The trilinear interpolation approach matches the reference implementation in FFmpeg's vf_lut3d.c.
Worked example: A 33x33x33 LUT contains 35,937 RGB samples (33^3). Each sample maps a specific RGB input to a new RGB output. For an input pixel with RGB (0.5, 0.3, 0.7), the shader computes the 3D texture coordinate as `scale * (0.5, 0.3, 0.7) + offset` where scale = 32/33 = 0.9697 and offset = 1/66 = 0.01515. The resulting coordinate (0.4999, 0.3061, 0.6939) is used to sample the 3D texture, and the GPU performs trilinear interpolation between the 8 nearest LUT grid points automatically.
Real-World Examples
Example 1: Previewing a Log-to-Rec.709 Show LUT on Set
A DP shooting on a Sony FX3 in S-Log3 is testing a show LUT provided by the post house. The LUT is a 33x33x33 .cube file that converts S-Log3/S-Gamut3.Cine to Rec.709 with a slight contrast boost and warm tint. During a lighting setup, the DIT grabs a frame from the camera, opens this tool, drops the .cube LUT and the frame grab, and checks the split view.
The before side shows the flat, desaturated S-Log3 image. The after side shows the Rec.709 conversion with correct skin tones and contrast. The DIT adjusts the intensity slider to 80% to see a slightly flatter version that preserves more highlight detail for the colorist. He exports a PNG and sends it to the DP for approval. Total time: 30 seconds. No Resolve, no project setup, no media import.
Example 2: Comparing Creative LUTs for a Commercial Grade
A colorist is preparing three creative LUT options for a car commercial. The client wants a "golden hour" look, a "teal and orange" look, and a "monochrome warm" look. Each LUT is a 33x33x33 .cube file. The colorist loads the hero frame (a wide shot of the car on a desert road) into the tool, then loads each LUT one at a time.
For the "golden hour" LUT, the split view reveals that the LUT pushes shadows toward blue while lifting midtones into the 0.6 to 0.8 range, creating a warm/cool split that suits the car's silver paint. The histogram shows the red channel shifting right by about 15 bins while the blue channel compresses in the shadows. The colorist exports a JPEG at 95% quality for each LUT option and sends all three to the client for review. The client picks the golden hour look, and the colorist proceeds with that LUT as the starting point in Resolve.
Example 3: Checking a LUT for Banding on a Gradient
A filmmaker is building a custom LUT for a sci-fi short and wants to verify it does not introduce banding in smooth gradients. She loads the built-in gradient ramp preset image, then drops her 64x64x64 .cube LUT into the tool. The gradient ramp goes from pure black (0,0,0) on the left to pure white (255,255,255) on the right.
At 100% intensity, she notices visible stepping in the midtones around the 40% to 60% brightness range. The histogram confirms this: the luma channel shows gaps between adjacent bins in that region, indicating that the LUT is quantizing the gradient too aggressively. She goes back to her LUT generation tool, applies a light smoothing pass to the LUT curve, regenerates the .cube file, and reloads it. The banding is gone. The entire diagnostic took under 2 minutes in the browser, compared to 10+ minutes of importing and scrubbing in a full grading application.
LUT Previewing Tools Compared (2026)
| Tool | Price | Browser-Based | No Upload | Split View | Intensity Mix | Export | WebGL2 GPU |
|---|---|---|---|---|---|---|---|
| Tools for Film (this tool) | Free | Yes | Yes (100% client-side) | Yes (drag slider) | Yes (0-100%) | PNG, JPEG | Yes (sampler3D) |
| arayofsunshine.dev LUT Preview | Free | Yes | Yes | Contact sheet | Yes | JPG, .cube | Yes |
| Color.io LUT Converter | Free | Yes | Yes | No | No | Multiple formats | Yes |
| alestemple.net LUT Analyzer | Free | Yes | Yes | Yes (split-view) | No | No (analysis only) | Yes |
| EditKit Color Grader | Free | Yes | Yes | No | Yes | Yes | Unknown |
| DaVinci Resolve LUT Browser | Free (with Resolve) | No (desktop app) | N/A | Yes (split-screen grid) | Yes | Yes | N/A (native GPU) |
| Lutify.me Previewer | $59/year | Yes | No (server upload) | Yes | Yes | Yes | Yes |
| IWLTBAP Previewer | Paid desktop | No (desktop app) | N/A | No | Yes | Yes | N/A |
Pro Tips and Common Mistakes
Pro Tips
- Always test a LUT on a color checker chart before applying it to footage. The 24-patch X-Rite ColorChecker is the industry standard reference. If the LUT shifts neutral patches (white, gray, black) toward a color cast, you will see it immediately on the chart. This tool includes a built-in color checker preset for exactly this purpose.
- Use the gradient ramp preset to check for banding. A well-constructed LUT should produce a smooth gradient without visible stepping. If you see banding at 100% intensity, try reducing the intensity to 80 or 90%. If banding persists, the LUT itself may need smoothing in whatever tool generated it. Banding is especially visible on 8-bit deliverables like H.264 web streams.
- When previewing log-to-Rec.709 conversion LUTs, make sure your reference image was actually shot in that log format. Applying an S-Log3 show LUT to a Rec.709 JPEG will produce an incorrectly graded image because the LUT expects log-encoded input values, not scene-referred Rec.709 values. The LUT will crush the already-contrasty image further.
- Check the DOMAIN_MIN and DOMAIN_MAX values in the LUT metadata panel. Most LUTs use the default domain of 0,0,0 to 1,1,1. But some log conversion LUTs specify a domain like 0.0,0.0,0.0 to 0.98,0.98,0.98 to account for legal range (narrow range) vs full range. If the domain does not match your image encoding, the grade will look wrong.
- Export as PNG when you need lossless quality for client review or as a reference frame in your grading session. Export as JPEG when you need a smaller file for email or messaging. PNG preserves exact pixel values, while JPEG at 95% quality introduces subtle compression artifacts that can mask fine color differences.
Common Mistakes
- Applying a 1D LUT (.cube with LUT_1D_SIZE) to this tool. This tool only supports 3D LUTs (LUT_3D_SIZE). 1D LUTs operate on each channel independently and cannot represent cross-channel color transformations like hue shifts. If your .cube file contains LUT_1D_SIZE, the tool will display an error. Convert 1D LUTs to 3D format using a tool like Color.io or lut-conv before previewing.
- Using a LUT size larger than your GPU supports. Most modern GPUs support 3D textures up to 2048 per dimension, but some older or integrated GPUs may be limited to 256 or 512. If your LUT is 65x65x65 and your GPU max 3D texture size is 64, the tool will reject it. Check the LUT metadata panel for the size and use a smaller LUT (33x33x33 is the most common size and works on virtually all GPUs).
- Confusing creative LUTs with technical conversion LUTs. A creative LUT (like a film emulation or stylized look) should be applied after technical conversion (log to Rec.709). If you apply a creative LUT directly to log footage without the technical conversion first, the results will look nothing like the intended grade. Always apply the camera manufacturer log-to-Rec.709 LUT first, then layer the creative LUT on top.
Frequently Asked Questions
What is a .cube LUT file?
A .cube file is a plain-text ASCII file that stores a 3D lookup table in the Adobe/IRIDAS .cube LUT Specification 1.0 format. It contains a header section with keywords like TITLE, LUT_3D_SIZE, DOMAIN_MIN, and DOMAIN_MAX, followed by RGB data lines (three floats per line). For a 3D LUT of size n, there are n^3 data lines ordered with Red varying fastest, then Green, then Blue. The format is open and widely supported by DaVinci Resolve, Premiere Pro, Final Cut Pro, and other grading applications.
How does trilinear interpolation work in a 3D LUT?
A 3D LUT stores a grid of color samples (for example, 33x33x33 = 35,937 samples). Since an 8-bit image has 256^3 = 16.7 million possible colors, the LUT grid is much coarser. Trilinear interpolation finds the 8 nearest grid points surrounding the input color, then blends them based on the fractional position within the grid cell. This produces smooth color transitions without visible stepping. In this tool, the GPU performs trilinear interpolation in hardware via the WebGL2 sampler3D texture with LINEAR filtering.
Is my image or LUT uploaded to a server?
No. This tool runs entirely in your browser using WebGL2. Your image files and .cube LUT files are processed locally on your machine. No data is transmitted to any server. You can verify this by opening your browser's developer tools Network tab and confirming that no requests are made when you load files. This is especially important for unreleased footage under NDA or proprietary LUTs that you do not want to share.
What LUT sizes are supported?
The tool supports any 3D LUT size that your GPU can handle as a 3D texture. Common sizes are 17x17x17 (fast, lower precision), 33x33x33 (standard, used by most grading applications), and 64x64x64 (high precision, larger file size). The tool checks your GPU MAX_3D_TEXTURE_SIZE at startup and rejects LUTs that exceed it. Virtually all modern GPUs support at least 256 per dimension, so 33x33x33 and 64x64x64 work on nearly all devices.
Can I use this tool with video files?
Not in the current version. This tool processes static images (JPG, PNG, WebP). Video support (MP4, WebM) with frame-by-frame LUT application is planned for a future release. For now, export a frame grab from your video and preview the LUT on that still image. Most NLEs and color grading tools can export a single frame as a JPEG or PNG.
Why does my LUT look different than in DaVinci Resolve?
The most common cause is a mismatch between the color space of your reference image and what the LUT expects. If the LUT is designed for S-Log3 input but your image is already in Rec.709, the result will look wrong. Another cause is domain mismatch: some LUTs use legal range (64-940 in 10-bit, or 16-235 in 8-bit) while others use full range (0-255). Check the DOMAIN_MIN and DOMAIN_MAX values in the metadata panel. Finally, this tool applies the LUT directly without any color space transformation, while Resolve may apply the LUT within a specific color space tag context.
Start Calculating
Previewing a LUT before committing to a full grading session saves time and prevents costly mistakes. Whether you are a DP checking a show LUT on set, a colorist comparing creative looks for a client, or a filmmaker verifying that a custom LUT does not introduce banding, this tool gives you an instant answer without launching a full grading application.
What LUT do you use most often on your projects, and have you ever discovered a problem with a LUT only after you were already deep in the grade? Drop your .cube file and a frame grab above, drag the split slider, and see exactly what your LUT does before you commit to it.
Some links in this post are affiliate links. If you purchase through them, Tools for Film earns a small commission at no extra cost to you. This support helps us keep our calculators and tools free.
