#LunaPack

• SHA-256 checksums for every entry (verified on unpack).
• MD5 fingerprints for every entry: the files are scanned before they go into the package, the fingerprints are listed, and after unpacking every extracted file is read back and checked against the fingerprint it had. The fingerprint of the produced file is reported as well.
• gzip and LZ4 compression per entry. LZ4 is implemented in this package and trades a larger result for a much shorter packing time.
• encryption of the entries, either to the owner of a public key or with a passphrase. The mechanism is the one of the reference implementation this package follows.
• Cross-platform: runs on Windows, Linux and macOS; packages carry their install scripts with the platform they target.
• Native and Wasm: usable as a standalone binary or through moonx.

#Releases

#Usage

#Via moonx (published on Mooncakes)

moonx riantr/LunaPack/cmd/main@latest \
  --input-exe=[input-exe-path] \
  --output-exe=[output-exe-path] \
  --Files=[Pack-Folder]

The bundle is self-extracting when the launcher is a native LunaPack binary. The one that runs on this machine is used by default, so a native LunaPack always produces a self-extracting file. A bundle produced through moonx runs on WebAssembly and has no native binary of its own, so it needs one named with --launcher - see below.

myapp.exe  =  [ LunaPack launcher ]  +  [ archive: myapp.exe, res/app.cfg, ... ]

$ ./myapp.exe
LunaPack: starting D:/apps/.lunapack/9c445884d23653fb/myapp.exe

#The launcher

# A bundle for Windows, made with the launcher of the release.
lunapack bundle -i ./myapp.exe -o ./myapp.exe \
  --Files=./build --launcher ./lunapack-windows-x86_64.exe

#As a single file that behaves like the program

• The arguments of the bundle are the arguments of the bundled program.
• The exit code of the bundle is the exit code of the bundled program.
• The subsystem of the bundle is the subsystem of the bundled program, so a windowed program does not flash a console window when it is started.
• The standard input, output and error are the ones of the bundle, so a program that asks a question gets an answer.

$ ./myapp.exe --version
myapp 2.6.0
$ echo $?
0

#The icon

$ lunapack --input-exe=./BRLabeler.exe --output-exe=./BRLabeler.exe --Files=./build
  md5  cb77181515d4680a960433f65ba05bef  BRLabeler.exe
  ...
scanned 392 files
bundled 392 files -> ./BRLabeler.exe (icon copied)
output md5  f5f06ca638d59a31e773c0a28358804d  BRLabeler.exe

lunapack verify  myapp.exe
lunapack info    myapp.exe
lunapack unpack  -i myapp.exe -o ./out

#As a native binary

moon build --release
# -> _build/native/release/build/cmd/main/main.exe   (every platform)

lunapack pack   -i <input_dir> -o <output.appkg> [options]
lunapack bundle -i <exe> -o <output.exe> [--Files <dir>]... [options]
lunapack unpack -i <package>   -o <dest_dir>    [--skip-scripts]
lunapack verify <package>      [--extracted <dir>]
lunapack info   <package>

#Options

#Compression

#Encryption

# Make a pair of keys. The public key goes to the machine that seals the
# packages, the secret key to the machine that opens them.
lunapack keygen --public-key recipient.pub --secret-key recipient.key

# Seal a package to the owner of the public key.
lunapack pack -i ./app -o app.appkg \
  --encryption-method x25519 --public-key recipient.pub

# Open it again with the secret key.
lunapack unpack -i app.appkg -o ./out --secret-key recipient.key

# Or with a passphrase.
lunapack pack -i ./app -o app.appkg \
  --encryption-method passphrase --passphrase-file passphrase.txt
lunapack unpack -i app.appkg -o ./out --passphrase-file passphrase.txt

lunapack keygen --public-key recipient.pub --secret-key recipient.key \
  --passphrase-file passphrase.txt

#Example

# Bundle an application and its resources into one self-extracting file.
lunapack --input-exe=./build/myapp \
         --output-exe=./dist/myapp \
         --Files=./build

# Or produce a plain archive instead.
lunapack pack -i ./myapp -o myapp.appkg \
  --name myapp --version 1.4.0 \
  --pre-install setup.sh --post-install setup.sh

lunapack verify  myapp.appkg
lunapack unpack  -i myapp.appkg -o /opt/myapp

  md5  6f5902ac237024bdd0c176cb93063dc4  a.txt
  md5  3db2050fcf84bb631dcae417d3db518c  sub/b.txt
scanned 2 files
packed 2 files -> myapp.appkg
output md5  63da650c906fe3ab1446b121a4edd4ca  myapp.appkg

unpacked 2 files -> /opt/myapp
  md5  6f5902ac237024bdd0c176cb93063dc4  a.txt
  md5  3db2050fcf84bb631dcae417d3db518c  sub/b.txt
verified 2 files, 0 mismatches

lunapack verify BRLabeler.exe --extracted .lunapack\60844df795cb7f31

verify: OK (392 files)
verify: OK (392 files in .lunapack/60844df795cb7f31)
VERIFY OK

verify: OK (392 files)
verify: md5 mismatch for appsettings.json: expected 86ff00ef... got 3ddcb685...
verify: FAILED (392 files checked)
VERIFY FAILED

lunapack ^
  --input-exe="D:/src/App/bin/Release/net10.0-windows/App.exe" ^
  --output-exe="D:/dist/App.exe" ^
  --Files="D:/src/App/bin/Release/net10.0-windows"

D://src//WorkBuddy//Moonbit//LunaPack//_build//native//release//build//cmd//main//main.exe ^
  --input-exe="D://zkhongtuo//src//MOlabeler_V2.6//bin//x64//Release//net10.0-windows10.0.22000.0//BRLabeler.exe" ^
  --output-exe="D://zkhongtuo//src//MOLabeler_V2.6//bin//BRLabeler.exe" ^
  --Files="D://zkhongtuo//src//MOlabeler_V2.6//bin//x64//Release//net10.0-windows10.0.22000.0"

#Publishing to Mooncakes

moon login                 # once
moon publish --dry-run     # validate
moon publish               # publish riantr/LunaPack
moonx riantr/LunaPack/cmd/main@latest --input-exe=... --output-exe=... --Files=...

#Install scripts

• LUNAPACK_DEST - absolute path of the destination directory
• LUNAPACK_PHASE - pre_install or post_install

#Package format

+--------------------+  offset 0
| magic "APPKGD02"   |  8 bytes
+--------------------+  offset 8
| entry payloads     |  stored back to back, raw, gzip, lz4 or sealed
+--------------------+
| manifest (UTF-8    |
| JSON)              |
+--------------------+
| magic "APPKGD02"   |  8 bytes
| manifest offset    |  8 bytes, little-endian int64
| manifest length    |  8 bytes, little-endian int64
+--------------------+  end of file

{
  "format_version": 4,
  "name": "myapp",
  "version": "1.4.0",
  "os": "linux",
  "arch": "x86_64",
  "checksum_algo": "sha256",
  "compression": "auto",
  "created_at": "2026-11-04T04:10:20Z",
  "main_program": "myapp.exe",
  "pre_install": { "platform": "posix", "body": "#!/bin/sh\n..." },
  "post_install": null,
  "entries": [
    {
      "path": "res/app.cfg",
      "mode": 420,
      "size": 22500,
      "stored_size": 913,
      "codec": "gzip",
      "checksum": "0a77c24c45d0c61f906862c4706f5dd739166985e8fc5c6344dadd9220507b28",
      "md5": "1520e796ba25554696b3cef6e913cc90",
      "offset": 8
    }
  ]
}

• size is the original file size, stored_size the space it occupies in the package.
• checksum is the SHA-256 of the original content, so it validates the data the user actually gets, not the compressed form.
• md5 is the MD5 fingerprint of the same content. It is a convenience for comparing against what the platform tooling shows, not the integrity guarantee.
• mode holds UNIX permission bits (0o644 / 0o755); they are ignored on Windows.
• main_program names the entry that is the application executable.

#Testing

moon test                      # unit + integration tests
bash scripts/test_linux.sh     # end-to-end suite (Linux / WSL)

#Notes and limitations

• main must return Unit in this MoonBit version, so the process exit code is always 0. Status is reported on stdout (VERIFY OK / VERIFY FAILED / error: ...); scripts that need an exit code should grep for those markers.
• UNIX permission bits cannot be set on Windows, so they are only applied on POSIX hosts.
• The checksum is computed over the original content; verify therefore has to decompress every entry.
• The fingerprint of the produced file is computed while it is written, so the file is never read back for that. The launcher stub is the one exception: it is hashed after the icon was written into it, because writing the icon changes its bytes.
• The big integers of the core are not constant time, so the X25519 of this package is not either. The control flow of the ladder does not depend on the secret, but the time of the arithmetic does. For the use here - a key exchange on the machine that holds the secret key - that is not the threat, but it is a reason to look elsewhere when it is.
• The encryption protects the content of the entries. The names of the entries and their sizes are in the manifest, which is not encrypted.
• The launcher stub is the LunaPack executable of the machine that built the bundle, so a bundle runs on the platform it was created on. Under moonx (Wasm) no native stub exists, so the bundle falls back to carrying the payload inside the application executable - such a bundle holds the data but does not extract itself.
• The extraction cache lives next to the bundle (.lunapack/<hash>/). When that folder cannot be written, a temporary directory is used instead.
• Copying the icon is Windows only, because an icon is a Windows resource.
• Bundling writes the archive to a temporary file next to the output, so there must be enough free disk space for it.
• The package is built on moonbitlang/core/async, which the toolchain ships as an experimental package. The MoonBit developers have confirmed that the stable releases will use it, so the package follows the toolchain rather than pinning an older release of the runtime.