Purrgress: A zero-allocation state-machine and animation queue library driven by procedural macros

I'd like to share my library. This library almost completely abandons dynamic dispatching or heap allocations. You set all the necessary states at program startup, using macros whose writing is controlled by the compiler, or manually using the tools typically used by the macros themselves. Later, you call just one update function within the loop. The animator, with its "animator" feature, is designed on a similar principle, allowing you to conveniently synchronize your animations with the main queue. My library collects queues rather than storing a single stage, allowing you to conveniently append, delete, completely rebuild, or insert any stage into the desired part of the queue. The library supports nesting, meaning you can create multiple state managers within a single one. The library implements a single nested structure, but you can easily understand how a multi-nested structure works by observing the animator. But the library really shines when used with a large number of different animators with a small number of stages, allowing you to create tens, if not hundreds, of thousands of such animators. Examples can be found in the README on GitHub or crates.io.

GitHub: GitHub - Honami333/purrgress: An immediate-mode stage manager and queue sequencer for Rust with compile-time dependency validation and lightweight dynamic dispatch. · GitHub
Crates.io: crates.io: Rust Package Registry

What kind of applications would make use of this library, to do what? You mention “animations” but that’s not very specific.

Yes, I agree the concept is a bit vague, and I apologize for that. It is specifically frame-by-frame animation—specifically, the ability to create convenient presets and animation queues, for instance, to synchronize them with game logic. You can retrieve data on the current animation and frame to easily load the image into objects. 3D isn't really the focus here, though if you really wanted to, you could synchronize it via a standard state manager. I’m currently using this library for my game—specifically for its AI. It’s hard to find a scenario where this library couldn't be used, though in some cases it might be overkill. If you specifically need queuing capabilities and a convenient way to handle queues and presets, feel free to use this library; if you just need a flat state manager that tracks the current state without looking ahead to future states, choose a different library. Sorry for my poor English; I’m not a native speaker!