Working With Sophie Kodjoe’s Film Tech Pipeline
Sophie Kodjoe has been quietly rebuilding how some production companies handle their color grading and virtual cinematography workflows. If you've been following her work on X or her GitHub repos, you've probably noticed the pattern. She's not selling a product. She's publishing pipelines that just work, and people are starting to actually use them. I spent about three weeks last month integrating her open-source VFX compositing node into a mid-budget indie project. The documentation was sparse, which is typical for her. But the code itself was clean. What I want to talk about here is the actual implementation process, the gotchas, and what it feels like when it finally clicks into place.
The Power Of Vision How Sophie Kodjoe Is Shaping The Future Of Film Technology
Her approach to real-time camera tracking combined with procedural look development is what separates her from the usual tutorial-happy crowd. Most people in this space are rehashing Nuke or After Effects workflows. Kodjoe is building tools that run on Linux, use Python 3.11 as the scripting backbone, and talk directly to DaVinci Resolve via its native API. That integration layer is where most of her early work lives, and honestly, it's the part that matters most for independent productions. The core idea is straightforward. You feed raw camera data into her tracking module, it spits out a scene graph that your DCC app can consume, and then her procedural LUT generator creates on-the-fly color science that matches your source material. No more manually building LUTs frame by frame. The system learns your palette from a reference still and propagates it through the entire shot. I found this alone cut my grading prep time from roughly 45 minutes per shot down to about six. There's a subtlety that beginners miss. The tracking module doesn't actually do traditional feature-matching. It uses optical flow combined with depth priors from a single RGB pass. That means it works on footage that doesn't have distinct visual features, like foggy exteriors or shallow depth of field shots where most trackers fail. I ran into this specifically on a night scene that was heavily diffused. Traditional planar trackers were losing the lock after frame 30. Kodjoe's method held steady through the whole take without drift. The trick is making sure your input footage has at least some visible texture, even if it's soft. Pure smooth gradients will confuse the flow estimation.
Here's what the actual setup looks like on my end, broken down without the usual hand-waving: First, you grab the repo from her public GitHub. The main branch is usually stable enough for production use, but I always pull the release tag version for anything I'm delivering to a client. Clone it, then run the setup script. It installs dependencies into a dedicated virtual environment. Don't skip that step. The conda env handles the CUDA bindings cleanly, and mixing it with your system Python is how you end up with silent import failures that look like bugs but are just dependency conflicts. After installation, you configure the paths. The config file is at ~/.kodjoe_pipeline/config.yaml. You'll set your Resolve project path, your tracking GPU device ID if you're running multiple GPUs, and the output directory for your scene graph files. Keep it simple. I once pointed it at a network drive with high latency and the tracking became unusably slow. Local NVMe storage makes a noticeable difference here, especially on longer takes.
Get the Full Details
The workflow itself has three stages. Stage one is camera tracking. You drop your RAW or ProRes footage into the input folder, set the frame range, and run the tracker. It outputs a .scene file with camera solves and point cloud data. For a typical two-minute shot at 24fps, this takes about 90 seconds on an RTX 4090. Resolution matters. Running at half res speeds it up dramatically with negligible quality loss for most uses. Stage two is the LUT generation. Feed it a single reference image, specify the target color space, and it builds a 3D LUT that matches your footage to that reference. This is where Kodjoe's actual contribution shows. She uses a perceptual loss function rather than simple chromaticity matching. The result looks closer to what your eye expects, not just what the math says should happen. I tested this against a commercial service that charges per minute of footage, and the Kodjoe pipeline came within visual parity on 80 percent of my tests. The remaining 20 percent needed minor manual adjustment in Resolve anyway, so the time savings were still there. Stage three is the compositing node. This drops into your Nuke or Resolve Fusion page as a custom node. It reads the .scene file and reconstructs the camera movement so your VFX elements track properly. The node is written in Python with a C++ backend for the heavy math. It's fast enough for real-time playback on modern hardware. I've used it on shots with heavy particle effects and the tracking held within a pixel or two across 500 frames.
One thing the documentation doesn't cover well is handling multiple cameras. If you're shooting dialogue with two or more angles, you need to process each camera separately and then merge the scene graphs. There's a merge utility in the repo at tools/merge_scenes.py. It aligns the coordinate systems automatically based on overlap regions. You'll want to ensure at least three common features between any two shots for this to work reliably. I learned that the hard way on a three-camera setup where two angles barely overlapped in frame. The merge produced a 12-degree rotational offset that I caught during review. Adding a few static reference cards between setups solved it completely. Performance-wise, the pipeline scales linearly with resolution up to 4K. Beyond that, you'll want to consider running the tracking in tiles. The repo includes a tiling option, though it's marked as experimental. It works fine for most cases. I ran a 6K HDR sequence through it last month and the tile merge introduced a subtle banding artifact at the boundaries. Dithering the final output in Resolve fixed it, but it's something to watch for. The biggest limitation I've found is that the system assumes a relatively static lighting environment within each shot. If you're doing practicals that change intensity or color temperature mid-take, the LUT generation will struggle to maintain consistency. Kodjoe acknowledged this in a recent issue on GitHub and has a branch in progress that splits the shot into zones and generates separate LUTs per zone. It's not merged to main yet, but testing it on a short scene showed promising results. If your production involves dynamic lighting, you may want to fork that branch and try it out.
For people just getting started, I'd recommend beginning with a single-camera, well-lit sequence. Get comfortable with the tracking output and the LUT generation before adding complexity. The tool is powerful, but it rewards understanding over brute force application. Once you internalize how the tracking and color stages interact, you'll find yourself making fewer mistakes and spending less time debugging than most people do in their first few projects. The broader impact here is worth noting. Most independent filmmakers are locked into expensive proprietary solutions or spend countless hours doing manual work that automation could handle. Kodjoe's work is deliberately structured to be adopted by small teams without enterprise budgets. The tools are free, the code is documented enough to fork and modify, and the community around it is active on Discord. It's not going to replace professional grading suites, but for the right projects, it's genuinely competitive.
