MOPs: a motion graphics operator layer for Houdini packed primitives

A toolkit for manipulating many copies of something

MOPs stands for Motion OPerators for Houdini and the project describes itself as a motion graphics toolkit. Its stated intent is to be an easy way to manipulate lots of copies of things, and it does that by leveraging Houdini's packed primitives.

The audience is described in two ways, and both matter for whether you will like it. The first group is motion graphics artists migrating from other platforms, for whom the goal is a familiar and fast workflow. The second group is more experienced Houdini artists who want a toolkit to quickly design and execute new effects.

The design bet is that the tedious part of moving a thousand copies of an object around is not the transform, it is the bookkeeping. MOPs handles that bookkeeping in a consistent way so an artist can think in terms of falloff, sequencing and instancing instead of writing attribute wrangling for every effect.

The repository layout matches how Houdini packages things. The otls/ directory holds the digital assets, toolbar/ holds the shelf tools, scripts/ holds the Python that ties the tools together, icons/ and mops_logo_01.png hold the artwork, OPcustomize holds the operator customisation data, dev/ holds development material, and MOPS.json at the root is the file that tells Houdini where the toolkit lives. The examples/ directory is large, with more than twenty .hip files covering falloffs, animating instances, pivot handling, vellum constraints, KineFX aiming and redshift proxies, and the README explicitly recommends studying those included setups as one of the best ways to understand both MOPs and Houdini.

Each node also ships with embedded help cards, so the documentation travels with the tool rather than living only on the wiki.

The Apply Attributes and Extract Attributes pair is the core

MOPs is built on an internal framework of nodes that convert point attributes to packed primitive intrinsic attributes and back again, and the README says this is what makes it easy for technical artists to develop new MOPs modifiers.

The developer section explains the mechanism directly. MOPs is essentially a front end for manipulating the transformations of Houdini points and packed primitives. The main node handling those transformations is the MOPs Apply Attributes SOP. It takes input packed primitives together with a matching set of input points carrying typical instancing attributes such as p@orient and v@scale, and uses those attributes to modify the primitive intrinsics of the packed primitives in a predictable way. The MOPs Extract Attributes SOP works in the other direction, taking the primitive intrinsics and generating instancing point attributes from them.

That round trip is the architectural idea. You author with familiar point attributes, and MOPs applies them to the actual geometry, or reverses the process when you need to read a state back into point space. A new modifier is a node that participates in this translation rather than a new system.

The Falloff nodes complete the model. They create a point attribute called @mops_falloff on the points, which MOPs Apply Attributes then uses to weight the applied effects. So an effect is not switched on or off uniformly, it is weighted per point by a falloff value you control.

The reserved attributes section documents the namespace. f@mops_falloff is the falloff value generated by the Falloff nodes, and a value of 0 implies that no effect takes place. i@mops_index is the index attribute used to decide what object is cloned to what point when multiple objects are connected to the MOPs Instancer. The prefix convention means a script can tell reserved MOPs attributes from your own without guessing.

Installation means cloning somewhere other than your Houdini folders

The installation procedure has been simplified from previous releases, and the README says to read it carefully. The simplified part is mostly that there is now a single JSON file to edit instead of a hand written environment file.

Step one is downloading MOPs from GitHub and saving it somewhere on a local drive or network share. The wording is permissive about the location and explicit about two exceptions. Do not install into $HOME/houdiniXX.X or $HOME/houdiniX.Y, because those are your preferences directories and only the JSON goes there. Do not install into your Houdini program directory either.

The tutorial uses C:\VFX\MOPS as the example installation directory, with C:\VFX as the parent to clone into.

If you are comfortable with Git, the command is run from that parent folder.

git clone https://github.com/toadstorm/MOPS.git

If Git is not familiar, the alternative is to download the desired release directly from the releases page and extract it to a hard drive or network share.

The repository also carries mops_version.json, which is how the toolkit reports its own version to Houdini, and the version history in the releases list shows the shape of the project so far: v1.12 on 2026-07-04, v1.11 on 2026-02-04 and v1.10.2e, labelled Experimental, on 2025-09-01.

Configuring the environment with MOPS.json and an hpath entry

Step two is pointing Houdini at the installation directory. The first task is to find the Houdini configuration directory, which the README calls $HSITE and which is where houdini.env typically lives.

The three platform paths are given directly. On Windows it is My Documents\houdiniXX.Y. On Mac OS it is ~/Library/Preferences/Houdini/XX.Y. On Linux it is ~/houdiniXX.Y.

Inside it, look for a directory called packages and create it if it does not exist. Then copy MOPs.json from the MOPs installation directory into that packages directory, for example My Documents\houdini20.5\packages\MOPS.json.

The file itself is short. Open it in a text editor, look at line 4, find the variable named MOPS followed by a quoted file path, and change the path to the MOPs installation directory.

{
   "env": [
      {
         "MOPS": "C:/VFX/MOPS"
      }
   ],
   "hpath": [
      "$MOPS"
   ]
}

Two details are easy to get wrong. On Windows the path must use forward slashes and not backslashes, and the path has to stay inside the quotes. The hpath array then adds $MOPS to the Houdini path, which is what makes the toolkit load.

Save the file, and the configuration step is done. Nothing else in Houdini needs to be edited for the standard installation.

Testing, and the three things that usually go wrong

Step three is to confirm the install works, and the test is simple. Create a Geometry container, dive inside it, and look for the MOPs entry in the Tab menu, and for a toolbar called MOPS in your shelf list. The MOPs Shelf contains tools with their own documentation.

Step four is troubleshooting, and the README lists three checks in order of likelihood.

The first is that you are in a Geometry container. All MOPs nodes are SOPs, so you will not see MOPs nodes unless you are inside a Geometry container. This catches people who open a new scene, press Tab in the network view at the object level and conclude the install failed.

The second is the install path in MOPs.json. Line 4 has to point at the MOPs installation directory, and the README gives a way to confirm you picked the right directory: it should contain the README.md file.

The third is Houdini.env. If a houdini.env file already exists in your Houdini configuration directory it could be misconfigured. The suggested test is to rename it and restart Houdini, and if MOPs then works, the environment file was the problem. Open houdini.env and look for any lines defining HOUDINI_PATH, and make sure every such line includes $HOUDINI_PATH as one of the paths in the variable, and that the last path defined is always the & character.

HOUDINI_PATH=$HOUDINI_PATH;$QLIB;/path/to/my_tools/;&

Paths are separated by a semicolon on Windows and by a colon on Mac OS and Linux. The & at the end is the marker for append, which is what stops the variable from clobbering the rest of the Houdini path.

Learning from the included .hip files and the video series

The README is explicit that the wiki is the place to start for written tutorials. The MOPs Wiki on GitHub has a quick reference list of every MOPs and MOPs Plus node, along with basic information on how to get started.

For the hands-on part, every single node has documentation in embedded help cards, and the installation ships with an /examples/ directory. The recommendation is to look through the included setups and see how they are put together, which the README calls one of the best ways to understand both MOPs and Houdini.

That advice is worth taking literally, because the examples directory is where the intended usage is visible. Among the scenes are Delay_falloffs_01.hip, Exploder_animated_01.hip, Simple_transform_wipe_01.hip, Subdivider_Animated_01.hip, animated_instances.hip, audio_falloff.hip, changing_indexes_01.hip, cluster_pivots.hip, coil_torus.hip, explode_and_curl.hip, index_from_attribute.hip, instancing_indexes_01.hip, kinefx_aim.hip, mops_redshift_proxy.hip, mops_sequence_trigger.hip, mops_soft_mod.hip, mops_vellum_constraints.hip, motion_instancer_example.hip, move_along_mesh.hip, move_along_spline_1.5.hip, neighbors_01.hip, neighbors_02.hip, packed_rbd_match_001.hip and pivot.hip. The file names alone indicate the range: sequencing with a trigger, audio driven falloff, instancing index control, vellum constraints, and packed rigid body matching.

For video learners, Houdini School has a three part series on YouTube, free to watch, covering MOPs Basics, Advanced Setups and MOPs Math. The project's own YouTube channel carries videos mostly about individual MOPs Plus tools, and the Discord server is described as the best place for quick help while learning or troubleshooting, with both novice and expert users taking part.

One thing the README does not provide is a compatibility matrix. Nothing states which Houdini versions a given MOPs release supports, so pairing a release with your Houdini version is something you have to confirm yourself.

MOPs Plus is a separate paid product, and the licence is LGPL-3.0

MOPs Plus is described in the README as a paid add-on to MOPs that adds new tools for typography, guided simulations, cameras and more. It is a separate product with its own documentation and its own video coverage, and the wiki quick reference list covers MOPs and MOPs Plus nodes together.

That distinction matters for anyone evaluating the toolkit. MOPs itself is open source and free, the licence is LGPL-3.0, and the LICENSE file at the repository root holds the terms. The paid tier is what funds the project and what adds the features the README lists for it.

The LGPL grant is worth a sentence of caution for a studio. It is a reciprocal licence, so if you modify the library itself and distribute it, the modified library has to stay available under the same terms. Using MOPs inside a Houdini scene or a render pipeline is a different situation from redistributing the toolkit, and the README does not discuss how studios handle that, so anyone shipping the toolkit to another facility should read the licence file and decide with their own legal input.

On maintenance, the repository is not archived and the last push was on 2026-10-12. The release line is regular enough to follow, with v1.12 in July 2026, v1.11 in February 2026 and the experimental v1.10.2e in September 2025. The presence of an experimental tag alongside the stable ones is a good sign that changes land in the tree before they are tagged.

The public channels are the wiki, the Discord, Bluesky, Instagram and YouTube, all linked from the README.

Editorial conclusion

MOPs fits Houdini artists and technical artists who need to drive large numbers of instanced objects with readable falloff and transform controls, and who are migrating from After Effects or Cinema 4D habits. It does not fit artists who need HTML based motion graphics, and it does not fit a pipeline that forbids LGPL-3.0 components. Verify first that MOPs.json points at the installation directory and not at your Houdini preferences folder, then open one of the included .hip files in examples/ before building your own setup, since the packaged scenes document the intended workflow better than the README does.

Frequently asked questions

Official sources

1. Issues
2. License: LGPL-3.0
3. README
4. Releases
5. toadstorm/MOPS on GitHub