Unity as data, not a platform — the idea behind NextLiber VRM

Akito Hayasaka — Wed, 28 Jan 2026 01:24:47 +0000

Why I’m exploring a virtual runtime for Unity assets (beyond the engine itself)
Unity has been the dominant engine for years, shaping how we build games and interactive content.
But there’s a structural assumption baked into the ecosystem that we rarely question:

Unity assets can only run inside the Unity runtime.

This assumption defines how we prototype, deploy, reuse, and even imagine what a “runtime” is supposed to be.
It’s convenient, but also limiting—especially when you want lightweight experimentation or cross‑platform flexibility.

This is where my project, NextLiber VRM (NLV), comes in.

Unity as data, not a platform
At its core, Unity scenes are stored as YAML.
That means:

Transforms

Prefabs

Materials

Mesh references

Component structures

…are all data, not magic.

And if it’s data, then it can be interpreted anywhere.

This simple idea led me to explore a radical direction:

What if Unity scenes could run outside Unity?

Not by re‑implementing Unity.
Not by competing with Unity.
But by treating Unity assets as a portable format that can be reconstructed in an external runtime.

Introducing NextLiber VRM
NLV is a Java‑based virtual runtime that:

reads Unity YAML

reconstructs the object hierarchy

interprets scene data

renders it externally (starting with 2D)

It’s early, experimental, and evolving.
But the goal is clear:

liberate Unity assets from runtime dependency.

Why start with 2D
2D is the perfect foundation for exploring this idea:

simpler physics

predictable rendering

manageable MVP scope

easier debugging of scene reconstruction

If NLV can run a 2D Unity scene externally,
the path to 3D becomes a matter of iteration, not speculation.

What this unlocks
Running Unity assets outside Unity could enable:

lightweight mobile prototypes

instant scene previews

cross‑runtime asset reuse

new workflows for experimentation

Unity as a format, not just a platform

This isn’t about replacing Unity.
It’s about expanding what Unity assets can do.

Challenges ahead
There are real obstacles:

physics emulation

shader abstraction

animation systems

cross‑platform runtime design

deciding what to emulate vs. reinvent

But these challenges are part of the fun.
They define the frontier.

If this idea resonates with you
NLV is open, experimental, and very much in motion.
If the thought of “Unity outside Unity” sparks something in you,
I’d love to hear your thoughts.

GitHub:

https://github.com/Akito5928/NextLiber-VRM

NextLiber VRM — Running Unity projects outside the Unity runtime

Akito Hayasaka — Tue, 27 Jan 2026 05:55:02 +0000

Unity’s editor and asset ecosystem are incredibly powerful, but its runtime is heavy, closed, and increasingly restrictive.

I’ve been exploring a radical idea:

Running Unity projects outside the Unity runtime.

This concept is called NextLiber VRM (NLV) — a Java-based Virtual Runtime Machine that interprets Unity scenes, assets, and logic without relying on Unity’s native runtime.

Why this idea matters

Unity runtime dependency is a long-standing bottleneck
Licensing and platform restrictions limit long-term sustainability
Research, education, and enterprise use cases often need more openness
Unity assets are valuable, but the runtime is not always the best execution layer

What NLV aims to explore

A Java-based external runtime
Interpreting Unity scenes and assets
Redefining the execution layer of Unity projects
A new architecture for long-term asset liberation

Still conceptual, but the vision is clear.

GitHub

https://github.com/Akito5928/NextLiber-VRM/

Discussions

https://github.com/Akito5928/NextLiber-VRM/discussions