My first impressions from Cavalry
A few days ago, I asked a user who said they use #Cavalry instead of After Effects how it actually holds up in real-world work and what kind of design tasks it covers — because until that moment, I had no idea Cavalry even existed. Nobody gave a straight answer. Just vague buzzwords like "2.5D, blah-blah, #mograph, blah-blah" — stuff you could read on the back of the product brochure. That's not what I was asking. So I decided to test it myself a few days ago. This thing deserves a proper deep dive, and I might write a review later. For now, these are just some first impressions, still a bit emotional and all over the place.
In a nutshell, I'd describe Cavalry as Cinema 4D in 2D, wrapped in an After Effects-like interface and built around something like Houdini's philosophy. Because it's essentially a node-based editor where layers only matter for visual hierarchy, beyond that, they're purely organizational. This feels weird at first, and you keep thinking a node graph would be useful, but eventually you get used to it.
Of course, this isn't pro-grade software for industrial video production. It has some fundamental technical limitations you can't overcome without external tools: no HDR, no 32-bit color depth (and even 16-bit support is limited), no LUT support, and, perhaps most importantly, no NLE functionality whatsoever. The layer-based interface might suggest otherwise, but Cavalry simply isn't a video editor. Layers don't even have indices, it's just object array. You can't move them back and forward in timeline (manually).
Its 2.5D is also nothing like After Effects' 2.5D. There's no actual 3D space, meaning no lights, normals, shadows, or anything of the sort. There's a 2D lighting filter, but it behaves so strangely that I can barely imagine using it outside some very specific animation styles. You could try to simulate some of this stuff programmatically, but for practical applications, you'd be better off using Blender.
And yet, Cavalry covers so many different design tasks, with so much freedom, that it's impossible to ignore even if you have no interest in video production at all.
For the first time in 20 years, I'm seriously questioning how indispensable Adobe Illustrator really is for some kind of vector graphics work. Of course, Cavalry isn't a drop-in replacement for Illustrator, and some of its limitations become obvious as soon as you look beyond motion graphics. For certain operations, such as outlining strokes or performing offset, Cavalry relies on polygonal approximations. This makes them fast on GPU and accurate enough for motion graphics, but it's a different story when you're producing vector artwork where precision and path optimization really matter. Illustrator has spent decades refining this side of vector editing, and it's exceptionally good with it, even compared with other dedicated vector editors.
I tend to use this kind of thing as a litmus test for every new piece of software that's supposed to be an "Adobe killer." So far, the verdict has usually been the same. Cavalry, however, is a more interesting case because of how extensible it is. If an analytical algorithm is missing where you'd actually need one, you can potentially implement it yourself and turn it into a custom tool that fits into your workflow like any other. The way you invoke it might be a little different, but the important part is that you're not necessarily stuck with the functionality the developers chose to provide.
And even with these flaws, Cavalry's non-destructive and generative tools are impressive. Blend effects, morphing, Boolean operations, deformers, replicators, generators... A lot of things I used to write monstrous Illustrator scripts for can be done here natively. You don't have to explain what a circle is and how you want it drawn 800 times. Cavalry has already made those 800 circles for you. All you need to do is orchestrate them.
What's surprising is how intuitive the whole thing becomes once you understand its underlying logic. Cavalry doesn't try to imitate any particular application; it borrows good ideas from different tools and adapts them to its own philosophy.
Take the coordinate system, for example. Cavalry uses pixel coordinates, like a regular graphics editor, but follows the compositing convention of placing the origin at the center of the composition. In a 1920x1080 comp, X ranges from -960 to 960 and Y from -540 to 540. Compositing software typically uses normalized coordinates instead, ranging from -1 to 1 (or from 0 to 1 in Fusion, for example). So Cavalry combines a familiar compositing-style origin with pixel-based coordinates where you'd normally expect normalized values. You may need to write coordinate transforms when moving between systems, but for motion graphics, Cavalry's approach can actually be more convenient.
The technical side is where Cavalry really shines. Its expressions and scripting system is incredibly powerful, and it uses vanilla JavaScript rather than the JS-flavored scripting you get in After Effects. The API is relatively straightforward, too. The workflow is so seamless that it almost feels like magic.
Missing safe frames? Drop in a JS Shape node in Wireframe mode and write a script. You don't even need to know how to draw anything in JavaScript. Cavalry handles the drawing; you just describe what you want, and voilà, it's on screen, with dynamically controlled parameters.
Need a custom tool for precise pivot alignment that the interface doesn't support? Write a script, and you can build a functional panel right inside Cavalry, tailored to that exact task. Everything happens in real time, with debugging in the console. Don't need the panel anymore? Save your snippets and access them later as simple commands. AI makes the whole process even faster. If something can be described programmatically, you can probably make it happen in Cavalry. Honestly, I wish all software worked this way. 😀
You can even write your own nodes — there's a pretty straightforward, well-documented SDK for it. Everything looks polished: custom icons, an attribute panel, installs as a plugin, and drops right into the main layers pool. You might not even notice the difference. Most third-party plugins are indistinguishable from the built-in tools.
The same philosophy extends to raster graphics. Cavalry covers most basic color correction and post-processing tasks, but some things are missing. The workaround is to use shaders and perform transformations or post-processing programmatically using #SkSL. SkSL is partially compatible with #GLSL, there's plenty of #shader code online, and AI can write it for you, too. Want a VHS effect? You don't necessarily need a plugin (but free plugin is also exists on GitHub) or a complicated template rig. Since Cavalry uses #GPU rendering, you can see the results of your code almost instantly in the viewport even during playing the composition.
Another thing I really appreciate is that project files aren't proprietary binary black boxes. They're plain, or at least mostly human-readable, #JSON. Both humans and AI can inspect and modify their contents directly, and the files work well with version control systems. Say your client's brand name changes and you have several projects that use it. You can just search and replace the name in the project files with a text editor instead of opening every project and changing it manually, let alone writing a script to automate the process. It's a small detail that makes a big difference when you're building automated workflows.
So, to wrap up this increasingly long "first impression," Cavalry seems ideal for infographics, eCommerce, generative art, and web design. Want a gazillion "unique" product videos of boots for your eStore in different resolutions for different platforms? Load your assets into a smart asset folder, import a CSV, set up data-driven procedural animations, configure incremental rendering, and let Cavalry do the rest. More complex workflows can be scripted, too. Everything is supported natively, without generating thousands of XML files or building elaborate server → script → application pipelines. And while we're talking about servers, Cavalry can act as one itself, exposing an API that lets external applications send it POST requests.
For web animation, you can export to Lottie, but the export is lossy. Cavalry effectively bakes the scene into frame-by-frame content to reproduce features that Lottie doesn't natively support, rather than preserving the original scene as editable vector animation. You can also export SVG sequences or bake vector animations into assets for use elsewhere. These options are useful, but they come with different trade-offs. Combined with Cavalry's procedural capabilities, the potential applications are limited only by your imagination.
It's a genuinely unique product. Not an "After Effects killer", but potentially an excellent companion to anything involving vector graphics and 2D animation. Cavalry also has frame-by-frame drawing tools and onion skinning, though the workflow seems better suited to rough animation and early-stage motion studies than to producing polished drawings. You can certainly push it further, but it doesn't strike me as the most convenient or productive environment for that kind of work.
P.S. Stability is a bit of a question mark. During my first few days, Cavalry crashed five times in a row, then went on to run for dozens of hours without major issues. Even when I loaded a compressed 8K sequence and it ran out of memory, it didn't crash. I still have no idea what triggers the instability.
Or, for example, you can crank through video sequences and throw on dozens of shaders without breaking a sweat, but the moment you subdivide a vectorized path stroke, the GPU suddenly kicks into overdrive like you just launched Battlefield 6 on it.😀