# FreeMote reads the PSB container that visual novel engines ship their assets in

> FreeMote is a set of C# libraries and command line tools for the M2 Packaged Struct Binary format, covering decryption, parsing, compilation and conversion of PSB assets, with separate projects for images, compression and audio. It suits a developer working with visual novel assets, and its outputs are restricted to non-commercial use.

**UlyssesWu/FreeMote** — Managed Emote/PSB tool libs.

- Repository: https://github.com/UlyssesWu/FreeMote
- Stars: 524 · Forks: 30
- Language: C#
- License: NOASSERTION
- Published: 2026-10-22 · Updated: 2026-10-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/ulysseswu-freemote

## The format is identified by its header, not its extension

The first thing the project insists on is that you check the file header before assuming anything, and the reason is that several unrelated formats share the same extensions. FreeMote is a set of tools and libraries for the `M2 Packaged Struct Binary` file format, whose header usually starts with `PSB`, `PSZ` or `mdf`, and whose file extensions usually are `.psb`, `.psz`, `.mdf`, `.pimg`, `.scn`, `.mmo`, `.emtbytes`, `.mtn`, `.dpak` and `.psb.m`. But there are some other file formats using the same extensions, and they are explicitly not supported. `.psb` means PlayStation Binary for PS3 or PhotoShop Big for Photoshop, `.mdf` means Mirror Disc File for Alcohol 120% or Primary Data File for MSSQL, and `.mtn` means Motion File for Live2D. The practical instruction is short and absolute: before submitting an issue or asking a question, check your PSB file header with a hex editor. For anyone automating over a directory of files, that check is not optional, because the extension tells you nothing.

## The core library decrypts, and the plugins handle the payload formats

The components divide along the lines of what you are trying to do. The base FreeMote component holds the basic functions, decrypting or encrypting EMT PSB files. The FreeMote SDK is a separate project with special API libraries for the EMT engine which take pure, meaning unencrypted, PSB files as input. FreeMote.Psb parses and generates PSB. FreeMote.PsBuild compiles and decompiles PSB files, converts PSB among different platforms, and recovers EMT projects. The plugins component holds external and experimental features, and within it the formats are handled by separate libraries: images get TLG encoding and decoding through FreeMote.Tlg for x64, shells get compression and decompression such as FreeMote.FastLz for x64, and audio has experimental support for the audio used in PSB. A component called FreeMote.Purify is listed as unreleased, and its purpose is to infer and calculate the key used by an EMT PSB file just from the PSB file itself, rather than obtaining the key from the engine. The repository layout mirrors this, with a directory per component including FreeMote.Plugins, FreeMote.Plugins.x64, FreeMote.PsBuild, FreeMote.Psb, FreeMote.Purify, FreeMote.Tools.EmtConvert, FreeMote.Tools.EmtMake, FreeMote.Tools.PsBuild, FreeMote.Tools.PsbDecompile and FreeMote.Tools.Viewer.

## Five command line tools cover the round trip

The tools are thin wrappers around the libraries, and the set of them maps onto the conversion directions. EmtConvert converts EMT PSB files. PsbDecompile decompiles PSB files to json files and resources, which is the direction that makes a file readable. PsBuild compiles PSB json files and resources back to PSB, the reverse. EmtMake is marked as a preview and converts an EMT PSB to an MMO project. The FreeMote Viewer opens and renders a pure PSB, and it is powered by a separate project, FreeMote.NET. The detailed usage for each is in the wiki, on the command line usage page. The json intermediate is the notable design choice here, because it means the round trip does not have to be binary all the way, and a decompiled project can be inspected, edited and recompiled. The documentation does not describe the tools as having a stable command line contract, so anyone scripting against them should expect to read the wiki page rather than assume flags.

## Building needs VS 2022, .NET 4.8 and a second NuGet feed

The build requirements are stated precisely, and they date the project. It requires VS 2022 and .NET 4.8 to build. There is an extra wrinkle for the plugin projects, since FreeMote.Plugins and FreeMote.Plugins.x64 require a MyGet feed to get external libs made by the project, and the documentation notes that if you do not need FreeMote Plugins you can unload the Plugins projects and remove them from the other projects' references. To install the project's own NuGet packages you add the feed to your IDE, and the feed URL is given as `https://www.myget.org/F/monarchsolutions/api/v3/index.json`, while the plugin packages themselves come from `https://www.myget.org/feed/monarchsolutions/package/nuget/FreeMote.Tlg`. The repository carries a `NuGet.Config` file and a `FreeMote.sln` solution with a shared `FreeMote.sln.DotSettings`, plus a `FreeMote.Tests/` directory. For test data the documentation points at a separate samples repository, FreeMote.Samples, and thanks the people who provided the samples.

## The licence rules out commercial output

This is the constraint to read before anything else, because it decides whether you can use the library at all. The project is licensed under a Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License, CC BY-NC-SA 4.0, and the EmtMake tool entry states in bold that the output file is always licensed under CC BY-NC-SA 4.0 with no commercial usage allowed. The general statement is broader: some outputs of FreeMote, such as mmo and psd, are transformed from FreeMote code and are treated as derived work, so they are always licensed under CC BY-NC-SA 4.0. The attribution condition is separate and practical. The documentation says it is required to attach the text of `FreeMote.LICENSE.txt` with your release if you are using FreeMote codes or binaries, and the licence page is in the wiki. Share-alike then propagates through the outputs, so a derived asset carries the same terms forward.

## Third party code is acknowledged piece by piece, with its own licences

The acknowledgements section is unusually detailed, and it is the best available guide to what is in the binaries. It credits @9chu for help, @number201724 for PSB format references with an MIT licence, @WcLyic for PSB samples and editor help, and @nalsas for editor help. Individual code contributions are listed with their origins and licences, including DxtUtil from MonoGame under Ms-PL, Adler32 from Singyuen Yip, DxtCodec from @gdkchan, TexturePacker from @mfascia, ImageTLG, ArcPSB, PspDecompression and Bc7Decoder from @morkt under MIT, GetPixelCoordinatesPSP and PostProcessing from @xdaniel and @FireyFly under MIT, BitmapHelper from @Nyerguds, ColorConsole from @RickStrahl, and an AstcDecoder from @mafaca under MIT. There is also credit to @GMMan for information about mzs, PSBv1 and trie form, to vgmstream and @SilicaAndPina for VAG related code, and a general note about all NuGet references used in the project. This matters in practice because the pieces are not all under one licence, and a build of the tool is a combination of MIT, Ms-PL and the project's own CC BY-NC-SA terms.

## Where FreeMote is the wrong tool

Two limits are worth naming. The first is the format scope. The library works with the M2 Packaged Struct Binary container and the EMT engine's use of it, so a general game asset pipeline, a modern engine with its own asset format, or a container that is not PSB is out of scope by definition, and the extension collision makes that a real risk when you point a batch script at a folder. The second is the toolchain. VS 2022 and .NET 4.8 is a specific and dated combination, the plugins need a separate feed to resolve, and the tools have no documented stable command line contract, so automating them means reading the wiki and pinning to a specific version. The alternative to weigh against is a general purpose asset tool, for example an image or archive tool that handles the payload formats without understanding the container, which is enough if all you need is to get textures out of a directory. The difference in approach is that FreeMote understands the container and the engine's conventions, which is what makes decompiling, recompiling and key recovery possible at all, and what makes every output inherit a non-commercial licence. For a researcher, a hobbyist, or anyone whose work is already non-commercial, that is a good trade. For a commercial product, the licence is disqualifying before any technical consideration matters.

## Conclusion

FreeMote is worth using if you work with PSB or EMT assets and need to read, write or convert them, because the component split matches the job, with separate libraries for parsing and generating, for compiling and decompiling, and for the image, compression and audio plugins, and because the command line tools cover the round trip from PSB to json and back. It is a poor fit for commercial work, since the project is licensed under CC BY-NC-SA 4.0 and the documentation states that outputs are always licensed under CC BY-NC-SA 4.0 with no commercial usage allowed. It is also a poor fit if you want a modern cross-platform toolchain, since building requires VS 2022 and .NET 4.8, and the plugin projects need an extra NuGet feed. Before adopting it, read `FreeMote.LICENSE.txt` and attach its text to your release if you use FreeMote code or binaries, and note that the last push to the repository was on 2026-10-18 with release v4.9.0 published the same day.

## FAQ

### What file format does FreeMote work with?

It is a set of tools and libraries for the M2 Packaged Struct Binary format, whose header usually starts with PSB, PSZ or mdf, with extensions usually .psb, .psz, .mdf, .pimg, .scn, .mmo, .emtbytes, .mtn, .dpak and .psb.m. Several unrelated formats share those extensions and are not supported, so the documentation asks you to check the file header with a hex editor before filing an issue.

### What are the main components in the FreeMote project?

The base FreeMote library decrypts or encrypts EMT PSB files, FreeMote.Psb parses and generates PSB, FreeMote.PsBuild compiles, decompiles and converts PSB files and recovers EMT projects, and FreeMote.Plugins holds external and experimental features such as TLG image handling through FreeMote.Tlg, shell compression through FreeMote.FastLz, and experimental audio support. A separate FreeMote SDK provides special API libraries for the EMT engine that take pure unencrypted PSB files as input.

### Can I use FreeMote for commercial work?

No. The project is licensed under CC BY-NC-SA 4.0, and the documentation states that the output of the EmtMake tool is always licensed under CC BY-NC-SA 4.0 with no commercial usage allowed, and that outputs transformed from FreeMote code are considered Adapted Material and carry the same terms. If you use FreeMote code or binaries you must attach the text of FreeMote.LICENSE.txt to your release.

### What do I need to build FreeMote?

The project requires VS 2022 and .NET 4.8. The FreeMote.Plugins and FreeMote.Plugins.x64 projects need a MyGet feed to resolve the external libraries made by the project, and if you do not need the plugins you can unload those projects and remove them from the other projects' references. Test and research samples are available in the separate FreeMote.Samples repository.

## Sources

- [Issues](https://github.com/UlyssesWu/FreeMote/issues)
- [README](https://github.com/UlyssesWu/FreeMote/blob/master/README.md)
- [Releases](https://github.com/UlyssesWu/FreeMote/releases)
- [UlyssesWu/FreeMote on GitHub](https://github.com/UlyssesWu/FreeMote)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ulysseswu-freemote