Library / SDK
vrm-c/UniVRM avatar
vrm-c/UniVRM

UniVRM's version table has two labels pointing elsewhere

UniVRM is a glTF-based VRM format implementation for Unity.

3,423 stars491 forksC#MIT

At a glance

What is it?
UniVRM is the reference implementation of the VRM avatar format for Unity, shipping through two different installation routes. Its previous-version table marks old releases unsupported and in two rows names a release that the link beside it does not point to.
Who is it for?
UniVRM fits a Unity team that needs to read or write avatar files, including legacy ones, and wants the import path to work at runtime rather than only in the editor.
Can I use it commercially?
Yes. MIT 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 27 days ago.
What is it written in?
Mainly C#, according to GitHub's language statistics.

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

From daily snapshots

Star history

  • vrm-c/UniVRM3,423 ★ · +32
Star history
Repository2026-09-282026-11-15
vrm-c/UniVRM3.4k3.4k

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

Editorial analysis

Four file types, two sharing an extension

The library reads and writes four formats. Two are VRM 1.0 and VRM 0.x, and both carry the same file extension, which is the first thing to internalise: a file with that extension can hold either generation of the format, and only the importer knows which. The third is glTF 2.0, in three container forms, a binary file, a text file and a zip archive. The fourth is VRM-Animation, a separate extension for animation data rather than for an avatar. The reason glTF comes along at all is structural: VRM is defined as an extension of glTF 2.0, so anything that reads VRM is already positioned to read the format VRM is built on. That is why the project describes itself as the standard implementation of the avatar format rather than as a standalone avatar tool.

Two format generations and a migration between them

The project supports the current 1.0 specification and the older 0.x generation side by side, and it ships a migration path from one to the other. That combination is the practical reason to choose this library over a narrower one: a project holding a library of legacy avatars does not have to convert them all at once. The import side has three further features worth naming separately. Importing works at runtime as well as in the editor, which matters for anything that loads avatars on demand rather than baking them into a scene. Importing at runtime supports async and await, so a load does not have to block. And there is a scripted importer for the two current formats, VRM 1.0 and glTF 2.0, for pipelines that want import to be part of the asset pipeline rather than an editor action.

Material conversion is written against one pipeline

Two export and import statements concern materials, and both name the same render pipeline. On the way in, physically based materials from glTF are converted into the standard material of Unity's built-in render pipeline. On the way out, standard materials from that pipeline are converted into physically based materials for glTF. What the file does not do is mention any other pipeline. For a project on a scriptable or high definition pipeline, that means the conversion path described here is not the one that applies, and whether the project handles it is something you would have to establish from the code rather than from the README. The rest of the feature list is format work rather than rendering work, which is consistent with a library whose job ends at the asset boundary.

Two rows of the version table disagree with their own links

The installation section has a collapsed block of previous releases, and it opens by saying those releases are not supported. The table maps Unity versions to releases and marks whether that release understands VRM 1.0: Unity 2021.3 pairs with a release labelled v0.112.0, Unity 2020.3 with v0.100.0, Unity 2019.3 with v0.99.1, and Unity 2018.4 with v0.79.0. In the first two rows the link target is not the release named in the label, pointing at v0.127.0 and v0.111.0 respectively, while the last two rows match. Whichever is intended, a reader pinning a version for an old Unity install cannot trust the label alone. Above that table, the current line is stated plainly: the latest version supports Unity 2022.3 LTS or later, and has since v0.128.0.

One package file serves two purposes

The first installation route is a Unity package file downloaded from a release. There are two naming families. Packages prefixed for the older generation are named with the project name, and packages for the current generation and for glTF are named for the format instead. That second family covers two separate entries in the install instructions, one for VRM 1.0 import and export and one for glTF 2.0 import and export, and both name the same file pattern. So a user who wants both avatar and plain model support downloads one archive rather than two, and a user who assumes the two entries mean two files downloads twice. Two further files are offered alongside them, one sample project per naming family.

The package route splits into two or three installs

The second route uses Unity's package manager with git URLs, added by hand through the add package from git URL dialog rather than from a registry. Here the splits are explicit and they are not the same splits as the package-file route. For the current avatar format you install two packages: a glTF one and a VRM one. For the older avatar format you install the same glTF package plus a different project package. For plain glTF support you install only the glTF package. The naming is the clue to the design: the glTF package is common to all three, and the second package is what selects which avatar generation you work with. Anyone upgrading between the two avatar generations is therefore changing a package, not just a file.

A Unity project sits at the repository root

The repository is not a bare library. Its top level contains the folders a Unity project needs, an assets folder, a packages folder and a project settings folder, alongside tests, documentation and two submodule checkouts, one for the glTF repository and one for the specification repository, which is why a submodule file is present. A Python script for converting a test format between two NUnit generations is committed at the root, an editor configuration directory is there, and a small image file sits beside the README. Platform support is stated narrowly and honestly: standalone builds on the three desktop systems, iOS, Android and WebGL, with both the .NET and IL2CPP scripting backends, and every other platform may work but is not tested.

Editorial conclusion

UniVRM fits a Unity team that needs to read or write avatar files, including legacy ones, and wants the import path to work at runtime rather than only in the editor. Check four things before you start: which Unity version you are on, since the current line requires 2022.3 LTS or later and everything older is explicitly unsupported, whether you need VRM 0.x at all, since a migration path exists and the two lines install as different package sets, which render pipeline you are on, since material conversion is only described against the built-in one, and which of the two installation routes fits your build system, because the package route needs git URLs added by hand. Reading the version table carefully is worth the minute it takes.

Frequently asked questions

How to install UniVRM?

Two routes. Download a .unitypackage from the latest release and import it, or add the UPM packages by git URL through Package Manager's add package from git URL dialog. The current line requires Unity 2022.3 LTS or later, a requirement in place since v0.128.0.

What file formats can UniVRM read and write?

VRM 1.0 and VRM 0.x, which share the .vrm extension, plus glTF 2.0 in its binary, text and zip forms, and VRM-Animation in the .vrma form. VRM is an extension of glTF 2.0, so plain glTF files pass through the same library.

Can UniVRM import and export at runtime?

Yes, both directions at runtime as well as in the editor, with async and await support for importing at runtime, a migration path from VRM 0.x files to VRM 1.0, and a scripted importer for VRM 1.0 and glTF 2.0.

Which Unity versions does UniVRM support?

The latest version supports Unity 2022.3 LTS or later, and has since v0.128.0. Older Unity versions have matching older releases listed in the README, which are marked as not supported, going back to Unity 2018.4.

Which platforms can UniVRM build for?

Standalone builds on Windows, Mac and Linux, iOS, Android and WebGL, with both the .NET and IL2CPP scripting backends. The README says other platforms may work but are not tested.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. vrm-c/UniVRM on GitHub
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/vrm-c-univrm.svg)](https://hysenlabs.com/projects/vrm-c-univrm)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/vrm-c-univrm.svg)](https://hysenlabs.com/projects/vrm-c-univrm)

Was this useful?