# JEngine: shipping Unity game updates without shipping a build > A HybridCLR based hot update framework for Unity with asset encryption, code obfuscation, one-click builds and a three package layout. **JasonXuDeveloper/JEngine** — The solution that allows unity games to update in runtime. 使Unity开发的游戏支持热更新的解决方案。 - Repository: https://github.com/JasonXuDeveloper/JEngine - Website: https://jengine.xgamedev.net/ - Stars: 2,236 · Forks: 348 - Language: C# - License: MIT - Published: 2026-10-07 · Updated: 2026-10-07 · Language: en - Canonical page: https://hysenlabs.com/projects/jasonxudeveloper-jengine ## Why HybridCLR beats writing hot update code in Lua Traditional Unity hot update means learning a second language. The comparison table in the README is blunt about this: with the conventional approach you write update code in Lua or TypeScript, and with JEngine you write standard C# in the same IDE with the same debugging. That is the whole pitch in one line. The mechanism is HybridCLR, which runs standard C# natively instead of interpreting it. The README claims a 10x or better speed advantage over ILRuntime and Lua, and while that is a project claim rather than an independent measurement, the direction matches what is known about interpreter overhead in a hot loop. The second saving is architectural. ILRuntime-style approaches need cross-domain adapters registered so the interpreted domain can call into the compiled one. With HybridCLR there are no adapters to write, described as zero adapters in the before and after table. For a team shipping a live game, that is the difference between a framework you integrate in a week and one you schedule for a quarter. ## Three packages, only one of them required The layout is deliberately small. JEngine.Core is required and handles hot update bootstrap, encryption and resource management. JEngine.Util is optional and carries JAction for zero-GC async tasks and JObjectPool for lock-free object pooling. JEngine.UI is optional, with an async MessageBox and editor UI built on UI Toolkit with theming support. An ultralight core is the claim that matters most here, and it is a claim about how few files you have to drop into a project before hot updates work. The README says no boilerplate is required, and the quick start is short enough to be honest about: Unity 2022.3 or newer, install the packages, follow the getting started guide. Installation runs through OpenUPM, which is the modern Unity package route and avoids the older copy-a-folder approach. The README does not inline the commands, so if you want them without leaving your editor, the release notes carry the three `openupm add` lines for the core, util and ui packages. ## Asset encryption and code obfuscation as first-class build steps Anything you can hot update, an attacker can also download and read. JEngine treats that as a build pipeline concern rather than a post-processing chore. Assets and DLLs can be encrypted with XOR, AES or ChaCha20, and hot update code is obfuscated with Obfuz. The README claims no other hot update framework ships this combination, which is a marketing claim, but the encryption choice list is concrete and the pipeline integration is what separates it from calling an encryption tool by hand. Version 1.1.6 added automatic detection of manifest decryption in PreprocessBuildCatalog, which is a small fix that matters more than it sounds. Manual decryption flags are exactly the kind of thing that works until a build script changes, and then the whole update path breaks at runtime. The build is a single button in the JEngine Panel. That button compiles the code, generates AOT metadata, obfuscates, encrypts and packages resources in sequence. Whether one click is faster than five menu items depends on your build setup, but bundling the order is the actual value, because the order is where mistakes happen. ## Platform coverage including Chinese mini-game channels The platform list is iOS, Android, Windows, macOS and WebGL, plus WeChat, Douyin, Alipay and TapTap mini-game platforms. That last group is the unusual one and the reason a Western reader should still pay attention: hot update support on mini-game platforms is a real engineering problem because those runtimes impose their own packaging rules and update constraints. Asset delivery comes from YooAsset, which the README credits with powering games past a million daily active users. UniTask provides GC-free async, and Nino handles zero-allocation serialization. Nino is by the same author as JEngine, and version 1.1.6 bumped it to fix dictionary serialization under HybridCLR, which tells you the serialization boundary between interpreted and compiled code is a real edge rather than a solved problem. The usage figures are the maintainer's claims: more than 1,000 games shipped and more than 100 companies in production. Those are adoption numbers for the framework and its ecosystem, not a guarantee about any individual integration. ## AI tooling, related projects and where the docs live The repository ships a `.claude-plugin/` directory and a `.claude/` one, and the README describes JEngine as the first hot update framework with a Claude Code plugin, on the grounds that an assistant that understands the framework's patterns writes more idiomatic code for it than one that does not. That is a plausible claim about a small opinionated API surface, and the plugin is the kind of thing that helps most with the repetitive parts of a build integration. The surrounding project files show a serious maintenance posture rather than a hobby: `.scorecard.yml` for OpenSSF scorecards, `.codacy.yml`, `codecov.yml`, `SECURITY.md`, `CODE_OF_CONDUCT.md`, `CHANGE.md` as a full changelog, a `CLAUDE.md`, and both English and Chinese READMEs. Documentation lives on a separate site at jengine.xgamedev.net with a Chinese mirror at a `/zh/` path, which is where the real getting started guide is, since the README delegates to it rather than inlining setup steps. The ecosystem is documented too. MetaJUI is a customized UI framework for JEngine and MetaExcelDataTool is an Excel table guide tool, and the same author maintains Nino. License is MIT and the repository is C# with 2236 stars. ## Conclusion JEngine's real argument is not the hot update itself, it is what you stop writing. HybridCLR means hot update code is ordinary C#, so nobody on the team has to learn Lua, and the conventional cross-domain adapter layer disappears. That is a large saving on a project with more than a few programmers. The frame is HybridCLR, not JEngine, so the hard limits of the approach are HybridCLR's: the code that must be in the binary at build time still is, and AOT metadata generation remains a real step in the pipeline. JEngine's contribution is wrapping that in a panel so compilation, metadata, obfuscation, encryption and packaging happen together, which is the part that is tedious to build yourself. The repository is MIT licensed, sits at 2236 stars, and its last push was 2026-04-23, with the newest release being 1.1.6 on 2026-02-08. ## FAQ ### What does JEngine do? It is a Unity hot update framework. You can ship changed code, assets and logic to a live game without rebuilding and resubmitting it, which matters on app stores where release review takes days or weeks. ### What Unity version does JEngine require? Unity 2022.3 or newer. Packages install through OpenUPM, and the getting started guide lives on the project's documentation site at jengine.xgamedev.net rather than in the README. ### How does JEngine protect hot update content? Assets and DLLs can be encrypted with XOR, AES or ChaCha20, and hot update code is obfuscated with Obfuz. Encryption and obfuscation are steps in the one-click build rather than separate tools you have to wire up. ### Which platforms are supported? iOS, Android, Windows, macOS and WebGL, plus WeChat, Douyin, Alipay and TapTap mini-game platforms. Asset delivery is handled by YooAsset and async by UniTask. ## Sources - [JasonXuDeveloper/JEngine on GitHub](https://github.com/JasonXuDeveloper/JEngine) - [License: MIT](https://github.com/JasonXuDeveloper/JEngine/blob/master/LICENSE) - [Project website](https://jengine.xgamedev.net/) - [README](https://github.com/JasonXuDeveloper/JEngine/blob/master/README.md) - [Releases](https://github.com/JasonXuDeveloper/JEngine/releases) --- Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jasonxudeveloper-jengine