Download on Patreon
I recommend downloading the 10-bit videos and importing them directly into Resolume. If you convert the 10-bit videos to DXV then banding artifacts will be introduced into the gradients. The DXV-HQ codec will result in excellent quality gradients but it creates extremely large files. As of Resolume v7.24, 10-bit color is supported. Check out the documentation to learn more about 10-bit signal chain requirements. Otherwise download the 8-bit videos and convert them to DXV.

Let’s swim in the lush gradient of an alien sunset sky. Such a simple but beautiful part of nature. I’ve always been disappointed with how gradients render out when using the default 8-bit color depth and so I’ve long been curious to experiment with gradients when using the 10-bit color depth. Introducing some James Turrell flavor to the stage!

This VJ pack is useful for a bunch of different use-cases such as re-colorizing footage, combining with masks, layering for complex gradients, LED strings/arrays, backgrounds for content with alpha, or obviously just pure vibes. This is a toolkit for playing with color.

Suggestions for jamming in Resolume:

• Need to add a color palette into a video clip? Apply the “Tint” effect, tweak the "White To" and “Black To” colors, and play with the "Tint Opacity" slider.
• Need to push a video clip towards a specific color? Apply the “Colorize” effect and play with the opacity slider.
• Need some surprising colors? Apply the “Delay RGB” effect and play with the RGB sliders.
• Need to tweak the dark, mid, and bright tones? Apply the “Levels” effect. There is a lot of exposure latitude in the 10-bit videos.
• Need to remove a specific color? Apply the “Add Subtract” effect and play with the RGB sliders.
• Need to continually change the existing colors in a video clip? Apply the “Hue Rotate” effect and use an envelope to automate the hue slider.
• Add automation to any of these effects to get interesting variations to the BPM.

Or here's another suggestion for the more adventurous among you. Suppose you wanted to create animated gradients on the fly while performing in Resolume. This would allow you to change the timing of each layer and create ever evolving gradients. Here’s how:

1. Import the LumaPattern1-47 video clips into Resolume and put into Layer 3. Apply the “Colorize” effect to Layer 3 and set the color to be perfect red (R:255, G:0, B:0) . Set Layer 3 to use the “Luma is Alpha” or “Difference” blend mode.
2. Import the LumaPattern1-47 video clips into Resolume and put into Layer 2. Apply the “Colorize” effect to Layer 2 and set the color to be perfect green (R:0, G:255, B:0) . Set Layer 2 to use the “Luma is Alpha” or “Difference” blend mode.
3. Import the LumaPattern1-47 video clips into Resolume and put into Layer 1. Apply the “Colorize” effect to Layer 1 and set the color to be perfect blue (R:0, G:0, B:255) . Set Layer 1 to use the “Luma is Alpha” or “Difference” blend mode.
4. Now you can trigger a video clip on each of the RGB layers and get some animated gradients that you can play with to your hearts content. Jam with the opacity sliders on each layer.

• Variation A: Try out different layer blend modes. They are essential to this technique.
• Variation B: Swap out the “Colorize” effect for the “Tint” effect on each layer to get even more complex gradients happening while using the “Difference” blend mode. The “Tint” effect allows you to select two colors which will be mapped onto the video clip. So be careful when selecting the "White To" and “Black To” colors since overlapping similar colors will result in blackness when using the difference blend mode.
• Variation C: To get an animated gradient which can be controlled directly, swap out the “Colorize” effect for the Smart Colorizer effect and then apply some automation to the phase slider, which will animate where the color is applied onto the LumaPattern video clip.
• Variation D: If you want to further smooth out the layered gradients, create a Layer 4, set the blend mode to “Alpha”, and set Opacity:100 for Layer 4. Now you can add a video router to Layer 4, trigger the video router, and apply the “Blur” effect onto the video router to make the resulting gradient look super smooth. I’d recommend blur settings such as Blur X Distance:1, Blur Y Distance:1, and Quality:1.
• Variation E: If you want to create a really advanced setup, then you can create another three layers of LumaPattern1-47 video clips and use them as masks for the RGB layers that are described above. This is useful for introducing more dark areas within your animated gradients.

Back to the tech notes. There was a bunch of research and testing that had to happen before I could start working on this VJ pack. First off I researched color spaces and it turns out that Resolume only supports the Rec709 standard. Also Rec2100 only works correctly when the software is set to use this specific color space and so that means the videos would be out of whack when just previewing them, which is quite confusing for VJs. Golly HDR is so confusing, but it's not a thing in the VJing world for many reasons. But I realized that the 10-bit color depth was the important factor here and so I decided to stick with the pervasively supported Rec709 color space. For instance, 8-bit video allows for 16.7 million colors and 10-bit video allows for 1.07 billion colors. So it makes a huge difference in terms of color fidelity.

The most critical aspect was the codec selection since this directly affects the quality of the gradients in the final exports. So I did a series of tests rendering out using ProRes, H264, DXV, and DXV-HighQuality. I did not consider the NotchLC codec since it's not natively supported by Resolume at this time. The 10-bit ProRes export was absolutely pristine and had a decent file size. The 10-bit H264 export had some acceptable banding artifacts and had a small file size. The DXV codec only supports 8-bit and so the export resulted in hideous banding artifacts which were not acceptable for this project. But interestingly the 8-bit DXV-HighQuality export was excellent yet had an extremely large file size. And since Resolume fully supports the ProRes codec, it seemed like the obvious choice and so I rolled with it.

From here I was curious and did some further tests comparing resolution of 3840x2160 versus 1920x1080 and then looked at the quality of the gradients when scaled up to 3840x2160. I was very surprised to find that the visible difference was barely noticeable, but the file size savings were significant. I believe that since I’m working at 10-bit color depth and therefore have no banding artifacts, then these video clips can easily be stretched and interpolated rather gracefully. So I decided to work at 1920x1080 at 60fps for this VJ pack. I suspect the video clips can be stretched even further and would look great on an ultrawide setup. And plus, if there is any noise/banding visible when stretched then you could just add a blur effect to smooth it out.

Knowing that 10-bit color depth usage is not common among VJs, I knew that I also wanted to render out 8-bit versions of each video clip. So that required me to do even more testing so that I could see what that process looked like. I had thought that this would require me to color grade each manually, but it ended up being an easy solution of just setting my export settings to “Output Depth: Millions of Colors” for the 8-bit renders. Due to color depth limitations, there is a visual difference between the 10-bit and 8-bit versions of the video clips. I’m sure that VFX people will wince at me just letting the AE render engine automatically handle the color grading, but I was pleased with these exports and also had 578 individual comps to consider. Yours truly, the KISS principle.

To give myself some options for possibly revisiting these comps in the future for HDR purposes, I used 32-bit bit depth for the After Effects project settings. So that left me with final renders that used the following export settings from After Effects. For the 10-bit exports I used “Output Codec: ProRes 422 Standard” and “Output Depth: Trillions of Colors”. For the 8-bit exports I used “Output Codec: H264” and “Output Depth: Millions of Colors”. Although there was a nasty surprise since I was using 32-bit bit depth for the project settings. While doing the final renders I saw a ton of data being written to my NVMe main drive, which I realized was from leaving the After Effects disk cache enabled... And by the end of the renders it had written about 40TB of data! Yikes, it used up 3.3% of the 1,200 TBW from my NVMe. Ya live and ya learn.

I thought carefully about my overall workflow prior to creating the animated gradients so as to give me the most freedom to create various combinations. So my approach was to first create the LumaPattern comps as a mapping space for the animated gradients to be applied onto. For the LumaPattern comps I simply used the built-in “Gradient Ramp” effect in AE and created 47 animated variations.

From there I used the BFX Map Ramp plugin since it had a unique implementation. I realized that its Cycle attribute could be set to lower than 1 and then only a small window of the overall gradient would be applied onto the mapping space comp. Then I could animate the Offset attribute and adjust that window to create an animated gradient. So the LumaPattern comps acted as a mapping space of how the gradient should be applied to the canvas and the BFX Map Ramp took care of the animated gradient colors. It took some mental gymnastics to figure out but it’s not actually difficult to pull off. Also the BFX Map Ramp plugin treated alpha differently within the gradient and I loved how it affected the color falloffs. The built-in Colorama effect in AE is quite good but it’s missing some things in this specific use-case.

But I was having trouble creating the color gradients that I had in mind. I was trying to directly create the animated gradients using the BFX Map Ramp plugin by keyframing the colors but it just wasn’t looking quite right. After spinning my wheels for a bit, I realized that I should really think backwards of how light actually functions in reality. When white light is passed through a prism then it becomes a gradation of rainbow colors. That led me to decompose the gradients into their RGB values and then combine them in the next step of the pipeline. So I created blue/black, cyan/black, green/black, magenta/black, red/black, and yellow/black versions of the LumaPattern comps and named these “Ramp1” (282 comps total). I also created blue/cyan, blue/magenta, green/cyan, green/yellow, red/magenta, and red/yellow versions of the LumaPattern comps and named these “Ramp2” (282 comps total). And then just for fun I also created cyan/magenta/yellow, red/green/blue, and rainbow versions of the LumaPattern comps and named these “Ramp3” (141 comps total). In this way I was able to create a decomposed full spectrum of colors within this collection of 705 comps.

Now I had the difficulty of trying to combine 705 comps together in interesting ways. Doing this manually was not only slow to prep but also slow to collage the many different comps together. So I used ChatGPT to create a JSX script for After Effects that would randomly select a comp from each of the folders, layer them into a new comp, set the layers to use the difference blend mode, create a top most adjustment layers and add gaussian blur with a value of 500, and then repeat this process 300 times. From there I created a few variations of this JSX script which combined the Ramp1, Ramp2, and Ramp3 comps in different ways. Such as “DiffStack” contains 6 different comps, “DualStack” contains 2 different comps with each having a different track matte applied, and “RainbowStack” contains 2 different comps. And I was able to determine the pool for random sampling by just moving comps in or out of the Ramp1, Ramp2, and Ramp3 folders. This allowed me to generate about 3,000 different comps with no stress. This technique saved me a huge amount of time and let me focus my energy on curation instead.

It was slow going to curate through the huge amount of comps since they were randomly generated and so many of them needed manual tweaks to make them really shine. Sometimes I disabled certain layers, changed the blend mode, tweaked the track matte, or such. It was particularly interesting to use a single track matte so that it affected multiple Ramp# layers, yet one track matte was inverted and therefore created a shared space between different Ramp# comps. Gradients within gradients controlled by gradients of gradients. By the end of the process I ended up with 578 finalized comps containing the animated gradients that I’ve been dreaming of. It’s amazing to me that I was able to do all of these steps within After Effects without needing to pre-render anything out.

This project has me thinking about permutation spaces and why I'm so obsessed with exploring variations. As a kid I thought that everything had already been done and explored, only to find that there is a vast landscape of things that have never even been seen or imagined. And so now that my skills can visualize many of the ideas that I dream of, and knowing that one person's trash is another person's treasure, I feel this urge to explore as much of a landscape as I can and see what interesting surprises emerge. There is a certain satisfaction knowing that I pushed a project as far as was useful, not necessarily to the max, but in the context of what is useful for other artists to use as a springboard for their own creative experimentations. When in doubt, chill out.

Released April 2026