Closing Thoughts


So, what else can this be used for other than deformers? Think about things like Maya MPxCommands; GUI widgets (via hooking the QEventLoop instead of the deform/compute functions), or even scene callbacks! The possibilities are endless...for abuse, that is. While the overhead of constantly checking of an updated DLL is not significantly performance-draining, repeated checks across several DLLs could have an effect.

In my opinion, within the context of Maya, it's best to utilize this technique as a development aid, rather than something you leave enabled in shipping code, controlled via a simple preprocessor definition or similar mechanism.

Current Limitations

State transfer

Right now, this little demonstration doesn't do anything to save any static state across reloads of the DLL, nor does it handle adding new business logic functions and making those hot-loadable as well; you must maintain a defined set of entry points beforehand. There are several possible solutions to this; cr.h handles this quite elegantly, and I might decide to take a similar approach as well in the future.

Single-shot functions

Certain functions in Maya, such as initialize and creator are called only once when the node is created; as such, if we wanted to do things like add attributes to a node dynamically, we cannot utilize this existing approach of keeping the update in the deform function; we'd need to find a different way of not just making sure that the DLL is reloaded for that initialize function, but also to make sure that all nodes in the scene are updated to point to that new initialize function as well, along with making any modifications to memory that might entail. This is not a trivial problem to solve.

Crash/Error handling

Right now, we don't do any sort of crash handling in the DLL at all; this means that if we accidentally compile code that executes UB, we could end up crashing Maya very easily. One thing to look into is to possibly catch such crash signals, and if so, load a previous known good working version of the DLL and attempt to continue execution. Again, cr.h has some implementation of this work as well; I might take a stab at porting it over to a Maya implementation in the future.


Even with all the downsides and possible crashes, to me, being able to continuously work on your code and watch it update live 5 out of 10 times is better than having to unload/reload 10 out of 10 times; I've been utilizing this approach recently when writing a deformer on my own project, and I'm definitely far more productive than when I work conventionally, even with all my build shortcuts and tests.

In summary, I hope you've learned a little more about memory and how it works over the course of this tutorial, whether or not you choose to implement this development technique in production! Feel free to contact me or file questions on the repository page; I know I'm not the greatest when it comes to explaining stuff.