cargo-bundle

cargo-bundle is a command-line tool that packages GUI executables built with Cargo as application bundles or installers. It can create .app bundles for macOS and iOS, .deb packages and .AppImage bundles for Linux, and .msi installers for Windows. The project describes iOS and Windows support as experimental; Linux .rpm and Android .apk output are still pending. Install it with `cargo install cargo-bundle` to add it as a Cargo subcommand. Projects configure bundle details in a `[package.metadata.bundle]` section of Cargo.toml, with fields including the app name, identifier, icons, version, resources, copyright, category, and descriptions. The `--target` option selects a target, and macOS can combine architectures into a universal binary. The `--binary-path` option packages an existing executable without rebuilding or modifying it. AppImage creation does not automatically collect shared libraries, so dynamically linked GUI apps may need matching or staged libraries. Apple artifacts can be signed but are not notarized by the tool. The project is free and open source under either the MIT or Apache license. Its README calls it very early alpha and gives no stability guarantee for the metadata format.

cargo-bundle provides several packaging formats for Cargo-built GUI applications, with options for existing binaries and target selection. Its early-alpha label, experimental platforms, and packaging limitations should be considered before relying on it.

cargo-bundle suits Rust developers who build GUI executables with Cargo and want to package them for desktop platforms. Its experimental support and early-alpha status may matter when selecting it for a project.

cargo-bundle is a free, open-source Cargo subcommand for packaging GUI applications built with Rust. It best suits developers who want to produce several desktop formats from a Cargo project or package a binary built elsewhere. Its format coverage is practical, but experimental targets and very early-alpha stability make it a poor default for release-critical pipelines.

Overview

Install cargo-bundle with cargo install cargo-bundle, then configure app metadata in a [package.metadata.bundle] section of Cargo.toml. Fields include the app’s name, identifier, icons, version, resources, copyright, category and descriptions, keeping packaging details with the project rather than in a separate setup.

It can package a Cargo-built executable or take an existing one through --binary-path, without running cargo build again. The input file is copied, not modified, which is useful when a separate build or CI step already produces the artifact. Target selection via --target also supports cross-compilation, and macOS builds can combine architectures into a universal binary.

Key features

Output formats include macOS .app bundles, Linux .deb packages and .AppImage bundles, and Windows .msi installers. That range makes one Cargo-centered tool worth considering for teams shipping Rust GUI software to more than one desktop platform. Linux .rpm and Android .apk support remain pending, however, so it cannot cover those formats today.

Signing options include Apple bundle and DMG signing, Windows Authenticode signing, and configurable keyless Sigstore signing for Linux artifacts. Apple artifacts are not notarized by cargo-bundle, so signing alone does not complete an Apple release workflow. Windows signing is opt-in through the windows-signing feature, which links a GPL-3.0-or-later implementation; teams should account for that licensing detail before enabling it.

AppImage creation does not automatically collect shared libraries. Dynamically linked applications may therefore need matching system libraries or staged libraries, adding packaging work and a deployment dependency that teams must manage themselves.

Pricing

cargo-bundle is free and open source under either the MIT License or Apache Software License. There is no paid plan or trial to weigh against its packaging limitations; the practical cost is the engineering effort needed to accommodate its alpha stability and platform-specific gaps.

Platforms

Its stated platform scope is macOS, iOS, Linux and Windows, but iOS and Windows support are experimental. The current output formats are macOS .app, Linux .deb and .AppImage, and Windows .msi; Android .apk remains pending despite Android appearing in the broader platform scope. Treat the experimental targets as options to evaluate carefully, not dependable release foundations.

Who it's for

Rust developers who already build GUI applications with Cargo and want packaging integrated into that workflow are the clearest fit. Teams with an established build or CI process can use --binary-path to package prebuilt executables. It is less suitable for teams that need stable metadata contracts, notarized Apple deliverables from the packaging step, or automatic shared-library collection for AppImage.

Pros and cons

• Several desktop formats from a Cargo subcommand: .app, .deb, .AppImage and .msi output can simplify packaging across supported desktop targets.
• Works with prebuilt executables: --binary-path avoids a redundant build and leaves the supplied input file unchanged.
• Metadata stays with the project: Cargo.toml holds app identity and packaging settings, though the format may change without a stability guarantee.
• Alpha maturity and experimental targets: the project calls itself very early alpha, while iOS and Windows support are experimental, raising risk for production release pipelines.
• Important deployment steps remain manual: AppImage shared libraries are not collected automatically, and Apple artifacts are not notarized.
• Some targets and formats are missing: Android APK and Linux RPM support are pending.

Alternatives

Browse the Software Packaging Tools list for other packaging options. Tauri Bundler is another free, open-source Rust bundling option for teams that want a library wrapping Rust executables in OS-specific app bundles; its public API stability is not strictly SemVer. For Windows-only installer needs, Advanced Installer has a free Simple-project option, while licensed features require a paid license.

makeself is a free choice for self-extracting archives on Unix-compatible systems. Linux-focused teams specifically seeking a builder for Flatpak packages can consider Flatpak Builder. Electron Forge is a free alternative for Electron applications on Linux, macOS and Windows rather than Cargo-built Rust apps. Jamf Safe Internet is a paid, trial-offering option focused on network threat prevention, content filtering and education-focused management and security. CyberInstaller Suite offers Windows freeware packages with reduced functionality on its free plan. InstallAware has a free edition for commercial use that requires Visual Studio.

Verdict

Choose cargo-bundle if you build Rust GUI applications with Cargo and want a free way to package several desktop formats, especially when a prebuilt binary or target-specific workflow matters. Its biggest advantage is a Cargo-integrated route to multiple formats; its biggest reason to look elsewhere is the combination of very early-alpha status, experimental platform support and unfinished packaging needs.