Packaging Executable Builds
Bash# 1. Identify target platform and build type # 2. Build the executable with all dependencies bundled # 3. Place it correctly inside project structure # 4. Test it runs standalone from terminal # 5. Verify metadata (name, icon, version) is correct # Example: Linux -> Windows EXE pyinstaller --onefile --windowed --icon=app.ico --name="AppName" main.py ./dist/AppName # or test via Wine if cross-compiling
Progress:
- Step 1: Determine target output type (EXE, APK, MSI, or Web)
- Step 2: Verify all dependencies/requirements are present in the dev environment (Linux)
- Step 3: Build the executable using the appropriate toolchain
- Step 4: Set metadata correctly — app name, package identifier, icon, version
- Step 5: Place the build artifact in the correct project folder structure
- Step 6: Bundle companion files as needed (MSI installer alongside EXE, APK alongside signing files)
- Step 7: For web projects, wire up the download button to point to the correct packaged artifact path
- Step 8: Run the executable via terminal to confirm it launches, is interactive, and functions correctly
- Step 9: Fix any missing dependency, broken icon, wrong name, or crash before handoff
- Step 10: Final confirmation — mark build as verified working
Platform-specific placement rules
EXE (Windows):
- Output goes in
dist/orbuild/folder within project - If an MSI installer is also required, place MSI alongside the EXE
- Confirm icon (
.ico) and app name are embedded correctly, not default/placeholder
APK (Android):
- Place the
.apkfile in the project's release/output folder (e.g.,android/app/build/outputs/apk/release/) - Keep APK alongside its signing config / keystore reference if present
- Verify app name, package ID (applicationId), and launcher icon are correctly set in manifest/build config
Web:
- Package project so the download button serves the correct built artifact
- Confirm the download path matches where the final file (EXE/APK/zip) is actually stored
- Let the requester choose the final download destination path — don't hardcode it
Example 1:
Input: Python desktop app needs to become a Windows EXE, built from Linux.
Output: Cross-compiled EXE via PyInstaller/Wine, named correctly, custom icon applied, placed in dist/AppName.exe, tested by running wine dist/AppName.exe from terminal — confirms window opens, buttons respond, no missing DLL errors.
Example 2:
Input: React Native project needs an APK for testing.
Output: ./gradlew assembleRelease run inside the dev environment, APK found in app/build/outputs/apk/release/app-release.apk, renamed/labeled per app name, installed on an emulator or device via adb install, confirmed app icon and name show correctly on home screen, app opens and functions.
Example 3:
Input: Web project needs a "Download App" button wired to the latest build.
Output: Build artifact placed in public/downloads/AppName-v1.2.apk (or .exe), download button href updated to that path, confirmed clicking button in browser downloads a working file, final storage path left open for the requester to choose.
- Always do a real terminal run of the output file — never assume a successful build command means a working executable.
- Check app name, icon, and identifiers explicitly; these are the most commonly forgotten details.
- Keep installer companions (MSI) and signing artifacts (keystore for APK) bundled with the main executable, not scattered.
- Match project folder structure conventions already in place — don't invent a new structure.
- When something is missing (a library, an asset, a config value), add it directly rather than flagging it as a blocker — the goal is a fully working final output.
- For web delivery, don't assume the final storage location — leave the destination path decision to the requester.
- Shipping an executable that was only "build-tested" (compiled without errors) but never actually launched and clicked through.
- Leaving default/placeholder icons or generic app names in the final build.
- Forgetting to include the MSI installer when the target is a full Windows install experience, not just a standalone EXE.
- Misplacing the APK/EXE outside the expected project folder structure, breaking the download button or deployment script.
- Cross-compiling from Linux without verifying Windows/Android-specific dependencies are actually resolvable in that environment.
- Hardcoding a download destination path instead of letting the requester pick it.