Library / SDK
AyagamiDev/ayagami avatar
AyagamiDev/ayagami

Ayagami rebuilds a puppet renderer without touching the original code

2D puppet model renderer compatible with Live2D

402 stars20 forksRustApache-2.0

At a glance

What is it?
Ayagami is a Rust library that loads and renders 2D puppet models compatible with the dominant proprietary format, developed by declared black-box reverse engineering under a dual permissive licence. The rendering work is detailed, and animation playback is not implemented yet.
Who is it for?
Ayagami suits a Rust product that must let users load their own puppet models, where the commercial kit's terms are the obstacle and posing from live parameters is all you need. It is the wrong choice today if your product plays authored animations, since motion, expression and pose file support are all listed as not yet implemented, or if you need documentation and a stable interface, both of which the README says are absent.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 69 days ago.
What is it written in?
Mainly Rust, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 21, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • AyagamiDev/ayagami402 ★ · +70
Star history
Repository2026-09-192026-11-21
AyagamiDev/ayagami332402

70 Stars in the last 63 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

A clean-room renderer for a format nobody else implements freely

Ayagami is a Rust library for loading and rendering 2D puppet models, built to be compatible with the dominant proprietary format in that space while remaining extensible to others.

The reason it exists is licensing rather than capability. Animated 2D characters of this kind are used in streaming, games and virtual presenters, and the established path runs through a commercial software development kit with terms attached. Ayagami's README leads with the alternative position: free software under a dual permissive licence, usable for any purpose without royalties or permission, explicitly including games that ship models and applications that load models supplied by users.

That second case is the one that matters most. An application letting end users bring their own models is precisely the scenario proprietary terms tend to restrict, and naming it directly tells you the author understood which restriction people are trying to escape.

The audience is anyone building a product around these models who would rather not take on a commercial licence, plus Rust developers wanting this capability without a foreign binary in the build.

The provenance claim is the most important thing in the README

Directly under the licensing statement is a paragraph that carries more weight than the feature list.

The project states it was developed strictly through black-box reverse engineering: a complete, from-scratch, independent implementation, with no licence terms violated in its development. It states that the project has never disassembled or decompiled any proprietary software and never will, and that a strict contributor policy exists to guarantee it.

That is the difference between a library a company can adopt and one its lawyers will remove. A compatible reimplementation whose provenance is unclear transfers risk to every user, because the question of how the format was understood becomes their question too. Declaring the method, committing to it in writing, and binding contributors to it is the arrangement that makes the permissive licence mean something in practice.

It is worth being precise about what this does and does not establish. It is the author's statement rather than an audited finding, and format compatibility can raise questions beyond how the format was learned. What it does is put the project on the right side of the line that matters most, and make the commitment checkable by anyone reading the contributor policy.

What is implemented, and the gap that will decide most adoptions

The supported list is substantial. Model file loading covers features up to a recent version of the reference kit, including parts, meshes, rotation and warp deformers, glue and blendshape parameters. A driver computes final mesh state from a model and its parameters, with interpolation, extrapolation and deformer chaining described as equivalent to the reference implementation.

The renderer is built on a cross-platform graphics abstraction, so it reaches the major native backends and the browser. Its optimisations are specific: only changed portions and masks are recomputed when parameters change, invisible items are skipped, masks are pixel-exact, both linear and gamma-space blending are selectable, and texture decoding is multithreaded with colour conversion pushed to the GPU for faster loading. Premultiplied alpha is handled correctly, which the README notes by comparison with the edge artefacts of a widely used application.

Now the gap. Motion file support, meaning animation, is listed as not yet done, alongside expression files and pose files. For a puppet renderer that is the feature people assume is present. What exists today loads a model and computes its state from parameters you supply, so driving it from tracking input or your own code works, while playing an authored animation does not.

A physics engine, a screenshot tool, engine integration for one game framework and a newer feature set are marked complete, so the trajectory is active. Anyone whose use depends on playing authored motions should treat this as a project to watch rather than adopt.

Running the demonstration, in the browser or natively

There is no published package yet, so evaluation starts with the demonstration application in the repository.

A hosted web build exists and the README notes it runs entirely in the browser with model data never leaving the machine, which for a tool where people load their own commissioned artwork is the right property to state.

Building the native version is a single command inside the demonstration crate's directory.

bash
cargo run -r

The release flag matters more than usual here, since an unoptimised build of a renderer doing per-frame mesh deformation will mislead you about performance.

The web version builds through a dedicated bundler for Rust web applications.

bash
trunk serve --release

The demonstration itself is more capable than a token example: it loads model metadata files, and the model and textures from a compressed archive, giving you a working poser to test your own models against before writing any code.

The workspace splits three ways, into the core library, the renderer and the demonstration, so a consumer wanting only the model loading and parameter driving can depend on the core without the graphics stack.

The status section is unusually candid

The README's own status section says four things worth taking at face value. The interface is unstable and subject to change. There is no documentation yet. A package registry release is coming but has not happened. And, in the author's words, the code is messy, released early to gather feedback on the interface and to start enabling users.

That is a fair trade offered honestly, and it sets the terms of adoption. With no published package and no documentation, your reference is the demonstration crate, and your dependency is a git revision you pin yourself. An unstable interface means an upgrade is a code change rather than a version bump.

The absence of tagged releases confirms the same picture, with the last push on 2026-09-14.

Against that, the remaining roadmap reads like a plan rather than a wish list, naming format documentation, model verification that rejects inconsistent files at load time, a C-compatible interface, an embeddable web component, GPU-accelerated mesh deformation and clipping mask optimisation. A verification item is the one to watch if you intend to load models from users, since rejecting malformed input at load time is what stops a bad file becoming a rendering problem later.

The commercial kit is the alternative, and licence terms are the difference

The alternative is the official proprietary development kit for this format, which is what most existing products use.

The difference is not primarily technical. The commercial kit is complete, documented, supported, and implements the animation, expression and pose handling this project has not reached. Choosing it means those features work today and someone answers when they do not.

What you accept in exchange is the licence, and the terms are the reason this project was written. Royalty and permission obligations vary with how you ship, and the case Ayagami calls out, an application loading models the user supplies, is where those obligations bite hardest.

So the decision separates cleanly. If your product ships a fixed set of models and animations and you can live with the commercial terms, the official kit is the lower-risk path by a wide margin at this stage. If the terms are the obstacle, or your application must let users bring their own models, Ayagami is the only route that removes the licence question, and it asks you to accept an unstable interface, absent documentation and no animation playback in return. For anything in Rust that needs only posing from live parameters, that trade is already reasonable today.

Dual licensing and what to verify

The project is dual licensed under permissive terms, with both licence files present alongside a copyright file, so a user picks whichever suits their situation. Offering the choice is the conventional arrangement in this ecosystem and removes a compatibility question for downstream projects.

The repository carries a contributing guide holding the provenance policy, instruction files for coding agents, and a funding file, with the workspace split into the three crates described earlier.

Before building anything on this, three checks are worth making. Load your actual models in the hosted demonstration, since format coverage is the claim that matters and your models either work or do not. Confirm whether you need animation playback, because that is the largest missing piece and no workaround is described. Then read the contributor policy rather than only the README paragraph about it, since that document is where the provenance commitment is actually specified, and it is the part a reviewer at your organisation will want to see. This is not legal advice.

Editorial conclusion

Ayagami suits a Rust product that must let users load their own puppet models, where the commercial kit's terms are the obstacle and posing from live parameters is all you need. It is the wrong choice today if your product plays authored animations, since motion, expression and pose file support are all listed as not yet implemented, or if you need documentation and a stable interface, both of which the README says are absent. Test your own models in the hosted browser demonstration first, since format coverage is what decides feasibility, and read the contributor policy rather than the README summary of it, because that document is where the clean-room commitment is actually specified.

Frequently asked questions

Can I use Ayagami in a commercial product?

The README states it is free software under a dual permissive licence, usable for any purpose without royalties or permission, explicitly including games with built-in models and applications that load user-provided models. Model files themselves carry their own terms. This is not legal advice.

How was Ayagami developed?

The README states it was built strictly through black-box reverse engineering as a complete, independent implementation, that no proprietary software was ever disassembled or decompiled, and that a strict contributor policy exists to guarantee this.

Does Ayagami play animations?

Not yet. Motion file support is listed as outstanding, along with expression file and pose file support. What works today is loading a model and computing its final meshes from parameters you supply, so posing from live input functions while authored animation playback does not.

Is Ayagami available as a published package?

Not at present. The README states a package registry release is coming, that the interface is unstable and undocumented, and points at the demonstration crate as the usage example. There are no tagged releases, so depend on a pinned revision.

Official sources

  1. AyagamiDev/ayagami on GitHub
  2. Issues
  3. License: Apache-2.0
  4. README
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ayagamidev-ayagami.svg)](https://hysenlabs.com/projects/ayagamidev-ayagami)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ayagamidev-ayagami.svg)](https://hysenlabs.com/projects/ayagamidev-ayagami)

Was this useful?