Sharing your Python programs with others can be a real headache. Usually, you have to bundle the entire Python interpreter and all your dependencies, which makes the final file huge and tricky to set up. Plus, ensuring everything works smoothly on another person’s computer can take a lot of tinkering.

But new tools are changing this. Some are built with Rust, a fast and safe programming language, which helps make the process easier. While they might not reduce the size of the package much, they do let you bundle your app quickly and easily, almost like clicking a button to run it.

One of these tools is called PyCrucible. It’s simple, lightweight, and easy to get started with. Let’s see how you can use it to package your Python app.

Getting Started with PyCrucible

To use PyCrucible, your project needs to be set up properly. First, it has to be a package that can be installed with pip, and it should include a pyproject.toml file. This file is like a blueprint that tells Python how your project is built. Your project must also have a clear entry point — the main file or function that runs when you start the program.

Installing PyCrucible is straightforward. You just run pip install pycrucible in your project’s virtual environment. That’s it. Once installed, you’re ready to configure your project.

Configuring Your Project for Packaging

Next, you need to tell PyCrucible where your program starts. Open your pyproject.toml file and add this section:

[tool.pycrucible]
entry = "main.py"

Replace “main.py” with the path to your actual entry point, relative to your project root. For example, if your main file is located at src/mytool/main.py, you’d write:

entry = "src/mytool/main.py"

This step is crucial because it guides PyCrucible on how to launch your program.

Creating the Package

Once your project is set up, packaging it is simple. In your terminal, go to your project directory with the virtual environment activated. Then run:

pycrucible -e . -o <your_app_name>.exe

Here, replace <your_app_name> with what you want your packaged app to be called. The -e flag tells PyCrucible to embed your project files from the current directory, and -o specifies the output filename. For Windows, add “.exe” at the end.

PyCrucible then automatically creates a single executable file. You don’t need to worry about other files or dependencies — just share that one file, and your users can run it without installing Python.

Running Your Packaged App

When someone runs your packaged app, it extracts the necessary files into a temporary folder called pycrucible_payload and then starts your program from there. On the next run, if that folder already exists, it skips the extraction and just runs the program directly.

Because it writes files to that folder, the user’s account needs permission to create files in their directory. Usually, that’s not a problem, but it’s something to keep in mind.

Advanced Packaging Options

PyCrucible also offers some extra features for more control. You can add options to your pyproject.toml under [tool.pycrucible.options]. For example, you can set extract_to_temp to true, so files are always extracted to a temporary directory, or delete_after_run to true, so the files are cleaned up after the program finishes. This is useful if you want a really clean setup or if your app runs only once.

Using these tools, distributing Python apps becomes much easier. Instead of complex setups or huge bundles, you get a simple, single-file executable that others can run with just a click. It’s a big step toward making Python applications more accessible for everyone.

Inspired by

• https://www.infoworld.com/article/4063326/pycrucible-an-easy-way-to-redistribute-your-python-apps.html

Sources

• gmpg.org
• github.com
• python.org
• siia.net
• podigee.com