If you grade in DaVinci Resolve, you have probably seen .dctl files in tutorials, plug-in packs and forum threads - and wondered how they differ from the LUTs and PowerGrades you already use. DCTLs are one of the most powerful and least understood tools in Resolve: they give you the precision of real color math with the convenience of a one-click apply.
This guide covers everything: what a DCTL actually is, how it compares to a LUT, a PowerGrade and an OFX plug-in, why colorists reach for them, exactly how to install them on macOS, Windows and Linux, how to use and even write your own, what works in free Resolve versus Studio, and the troubleshooting questions that trip people up.
What is a DCTL?
A DCTL - DaVinci Color Transform Language - is a small program that runs directly on your GPU and transforms the color of every pixel inside DaVinci Resolve. The file extension is .dctl, and the language itself is a close cousin of C, CUDA and OpenCL.
That single idea is what makes a DCTL different from almost everything else in your color toolkit. A LUT is a stored result. A DCTL is the recipe that produces the result - calculated fresh, at full bit depth, on every frame.
The language behind the name
Blackmagic exposes a simplified subset of GPU programming so colorists and tool-makers can write transforms without building a full plug-in. You get math operators, conditional logic, Resolve's built-in color functions, and a way to define your own on-screen controls (sliders, checkboxes, drop-downs). When Resolve renders a frame, it runs your DCTL once per pixel in parallel across thousands of GPU cores.
Built for your GPU: Metal, CUDA and OpenCL
DCTLs are GPU-native. Resolve compiles the same .dctl to whichever framework your hardware uses: Metal on Apple silicon and modern macOS, CUDA on NVIDIA cards, and OpenCL on AMD. You write the transform once; Resolve handles the rest. That is why a well-written DCTL adds almost no overhead even at high resolutions - it runs on the same GPU pipeline that drives the rest of your grade.
Why "transform" matters
The middle word is the important one. A DCTL is fundamentally a transform: red, green and blue go in, and a new red, green and blue come out. Because that transform is computed rather than looked up, it can do things a fixed table cannot - respond to a slider, branch on luminance, work in a different color space internally, and stay artifact-free no matter the resolution. Since DaVinci Resolve 19.1, DCTLs can even carry an alpha channel, opening the door to compositing and motion-graphics uses on the Fusion page, not just color work.
DCTL vs LUT vs PowerGrade vs OFX
These four terms get used interchangeably, but they solve different problems. Here is the honest breakdown - including the one detail most guides get wrong: where each one actually runs.
LUT (Lookup Table)
A LUT is a fixed table that maps input colors to output colors. It is universal (works in almost any app), fast, and great for display transforms and shipping a baked look. The trade-off: it is a frozen result. You cannot tweak it node-by-node after the fact, and aggressive LUTs can band or clip because they interpolate between stored points instead of computing the exact value. LUTs work in both free Resolve and Studio.
PowerGrade
A PowerGrade is a saved node tree (.drx) - a snapshot of an entire grade with every node still live and editable after you apply it. It is Resolve-specific and fully transparent: you can open it up, see how it was built, and change anything. PowerGrades are a standard Resolve feature, so you can create and apply them in free Resolve too - though a PowerGrade that contains a native DCTL or a Studio-only effect will only fully render in Studio.
OFX plug-in
OFX (OpenFX) is a cross-host plug-in standard used by Resolve, Nuke, Vegas and others. In Resolve, OFX effects appear in the OpenFX panel and you drag them onto a node. Crucially, third-party OFX plug-ins run in both free Resolve and Studio - the OpenFX panel is present in the free edition. (What needs Studio is Blackmagic's own premium ResolveFX.) That makes OFX the most reliable way to get a pro color tool working for every Resolve user.
DCTL
A DCTL sits between these worlds. Like a LUT it is a single file you drop in and apply. Like a PowerGrade it stays "live" - it recomputes every frame and can carry its own controls. The catch: native DCTLs require DaVinci Resolve Studio. The free edition has no DCTL support - no DCTL entry in the LUT menu, no DCTL OFX node. This is exactly why the best commercial tools ship the same look in more than one format (more on that below).
| LUT | PowerGrade | OFX | DCTL (native) | |
|---|---|---|---|---|
| What it is | Baked color table | Saved node tree (.drx) | Compiled plug-in | GPU transform code |
| Editable after apply | No | Yes (every node) | Via its controls | Via its controls / the code |
| Live sliders | No | Yes (nodes) | Yes | Yes |
| Full-precision math | Interpolated | Yes | Yes | Yes |
| Free or Studio? | Both | Both | Both | Studio only |
| Portable to other apps | Yes | No | Yes (OFX hosts) | No (Resolve only) |
The takeaway: a native DCTL is a Studio feature, but the look a DCTL produces can also be delivered as an OFX plug-in that runs everywhere. Smart tool-makers ship both so nobody is locked out - which is the whole idea behind multi-format delivery.
Why use DCTLs?
If a LUT is "good enough" for a quick look, why do professional colorists keep reaching for DCTLs? Four reasons.
Full-precision math, not approximation
A LUT stores a limited grid of points and interpolates everything in between. Push it hard and you get banding or clipping. A DCTL calculates the exact output for every pixel, so transforms stay smooth even under heavy adjustment - critical for hue work, tone mapping and film emulation.
Resolution independence
Because the result is computed rather than sampled from a fixed table, a DCTL looks identical whether you are working on a 1080p proxy or an 8K master. There is no grid resolution to "outgrow."
GPU speed, across every page
DCTLs run on the same GPU that drives the rest of Resolve's color pipeline, so they hold up in real-time playback where a stack of heavy nodes might not. Applied through the DCTL OFX, they can be used on the Color page and - with alpha support - on the Fusion and Edit pages too.
Real controls, not a frozen look
This is the big one. A DCTL can publish its own user interface - sliders for intensity, drop-downs for modes, checkboxes for options - using Resolve's UI parameter system. That turns a complex color operation into a simple, art-directable tool, while a LUT gives you exactly one setting: on or off.
How to install DCTLs in DaVinci Resolve
Installing a DCTL means putting the file where Resolve looks for it: the LUT folder. You can do this by hand, or skip the folder-hunting entirely with the PixelTools Installer.
Find your LUT folder (macOS, Windows, Linux)
The default paths are:
-
macOS:
/Library/Application Support/Blackmagic Design/DaVinci Resolve/LUT/ -
Windows:
C:\ProgramData\Blackmagic Design\DaVinci Resolve\Support\LUT\(ProgramData is hidden - enable "Hidden items" in File Explorer) -
Linux:
/home/resolve/LUT/
Copy your .dctl file into that folder (or a subfolder - subfolders show up as categories in Resolve, which is handy for staying organized).
The version-proof shortcut: let Resolve show you the folder
Paths change between Resolve versions and install types. The reliable way to find the exact folder Resolve is reading: open Project Settings → Color Management and click Open LUT Folder. Resolve opens the correct location in Finder or File Explorer. Drop your DCTL there and you can't get the path wrong.
The one-click way: the PixelTools Installer
Manually chasing hidden folders gets old fast - especially when you own DCTLs, OFX plug-ins and PowerGrades that each live in a different place. The PixelTools Installer app installs your purchased PixelTools DCTLs, OpenFX plug-ins and PowerGrades into the right DaVinci Resolve folders in one click. It is Apple-notarized and code-signed, and runs on macOS and Windows (it uses Resolve's scripting API, so it requires DaVinci Resolve Studio 20 or later). On Linux or iPad, you download your files and add them by hand - everything still works, it is just a manual install.
Make Resolve see your new DCTL
After the file is in place, tell Resolve to rescan: open Project Settings → Color Management and click Update Lists, use the … menu in the Color page's LUTs panel to Refresh, or - the most reliable fix - restart DaVinci Resolve. If a new DCTL does not appear, or your edits to one are not reflected, a restart almost always sorts it. Your DCTL then appears alongside your LUTs, ready to apply. (Remember: a native .dctl only shows up in Studio. In free Resolve you'd install the OFX version instead.)
How to use (and write) a DCTL
Once installed, a native DCTL can be applied two ways - and if you're curious, opening one up is less intimidating than it looks.
Apply it as a LUT or in a DCTL OFX node
The quick way: right-click a node in the Color page, choose LUT, and pick your DCTL from the list - exactly like applying a LUT. The flexible way: add the DCTL effect from the OpenFX panel onto a node, then select your file in the effect's settings. The DCTL OFX node is what exposes any custom sliders the tool defines, so reach for it whenever a DCTL has controls. (Both methods are Studio-only; a tool delivered as its own OFX plug-in works in free Resolve too.)
Anatomy of a .dctl file
A DCTL is plain text. At minimum it defines one transform function that receives a pixel's red, green and blue and returns the new values:
__DEVICE__ float3 transform(int p_Width, int p_Height, int p_X, int p_Y,
float p_R, float p_G, float p_B)
{
float3 rgb = make_float3(p_R, p_G, p_B);
float gain = 1.1f; // simple +10% exposure
rgb.x *= gain;
rgb.y *= gain;
rgb.z *= gain;
return rgb;
}To give it a slider, declare a UI parameter and reference it inside the transform:
DEFINE_UI_PARAMS(gain, Gain, DCTLUI_SLIDER_FLOAT, 1.0, 0.0, 2.0, 0.01)Now "Gain" shows up as a slider on the DCTL OFX node. That is the whole trick behind professional DCTL tools: real math under the hood, friendly controls on top.
DCTL vs DCTLE: editable vs encrypted
You'll also see the extension .dctle. That's an encrypted DCTL: inside Resolve Studio it behaves exactly like a normal one, but the source is locked so it can't be opened or copied. It's how most paid tools protect their color science. Every PixelTools DCTL - free or paid - ships as an encrypted .dctle, so you get the exact look while the color science stays protected. So if you buy a DCTL and can't read the code, that's by design - you got a .dctle. (Either way it's still a DCTL, so it still needs Studio - encryption changes nothing there.)
Edit and live-reload
Open any editable .dctl in a code editor, change a value, and save. Back in Resolve, click Update Lists (or restart) and the change reloads - no recompiling, no reinstalling. That tight loop is what makes DCTLs a joy to experiment with. (Encrypted .dctle files can't be edited.)
Free vs Studio: what works where
This is where most guides get it wrong, so let's be precise.
Native DCTLs need DaVinci Resolve Studio
The native DCTL feature - dropping a .dctl into the LUT folder and applying it, or using the built-in DCTL OFX node - is a Studio feature. The free edition of DaVinci Resolve does not load DCTLs at all. This is a hard requirement for every DCTL - .dctl or encrypted .dctle - and encryption has nothing to do with it: a DCTL is a DCTL, and a DCTL needs Studio. Also Studio-only: Blackmagic's premium ResolveFX, the Neural Engine (Magic Mask, advanced noise reduction), multi-GPU processing, and timelines above UHD.
How to use these tools in free Resolve: OFX
Here's the good news. Because third-party OFX plug-ins run in both free Resolve and Studio, the same color tool can reach everyone when it's shipped as an OFX. That's where multi-format delivery helps: select PixelTools tools are also available as an OFX (with more on the way), so where an OFX build exists you get the same look on the free edition as on Studio - the DCTL itself always needs Studio.
Setting exposure? Middle gray, false color and the free Checker & ExposureChart DCTLs get their own deep dive in Exposure & Middle Gray in DaVinci Resolve - including a middle-gray reference value for every major camera log curve.
Best DCTLs for DaVinci Resolve
The "best" DCTL is the one that removes a step you do on every project. A few categories earn their place in almost any colorist's toolkit:
- Foundational grading - clean, controllable contrast and primary tools that behave better than stock curves, like Filmic/Contrast and Prime/Grade.
- Color character - split-toning, hue-shaping and film-process emulations that give footage a signature without a heavy node stack, like Split/Tone and Three/Strip.
- Workflow utilities - exposure, balance and gamut helpers that standardize the boring-but-critical setup steps, like Hue/Shift and Exposure/Tool.
PixelTools builds DCTLs in exactly these categories - the same tools used by colorists on Disney+, Apple TV+ and Netflix titles - and ships every one with an OFX build alongside the DCTL, so the same look runs in free Resolve as well as Studio (the DCTL itself always needs Studio). The bundle is the most economical path to the full set.
Want to try before you buy? PixelTools gives away the Checker and ExposureChart DCTLs free, and offers watermarked demos on every product page - the fastest no-risk way to see how a DCTL behaves on your own footage.
