This article explains why native CLI tools written in Go and Rust increasingly use npm for distribution, detailing three packaging patterns, a deep dive into Feishu CLI's implementation, and a step-by-step guide to publishing a Go binary via npm with practical pitfalls.
The author details building a Python desktop tool for automated bid data collection, covering technology selection (PySide6 over Playwright), three development pitfalls (config handling, redirect loops, invisible GUI crashes), PyInstaller packaging decisions (onedir mode, path resolution), and three key lessons for distributable GUI applications.
When a Spring Boot project is packaged as a jar it runs with the embedded Tomcat using the application's own configuration, while a war package relies on an external Tomcat container, adopts the container's settings such as the default 8080 port, and requires additional Maven configuration and a ServletInitializer class.
This guide walks through installing rpmbuild dependencies, using the open‑source go‑bin‑rpm tool to create a minimal rpm.json configuration, adding optional systemd service definitions, and automating the build and packaging process with a Makefile to produce a ready‑to‑install RPM for a Go binary.
The article examines why QR codes printed on beverage bottle caps often become unreadable, analyzes the material and logistical vulnerabilities that cause damage, and presents two technical upgrade paths—laser marking and reinforced anti‑counterfeit stickers—plus a multi‑layer coding strategy to protect consumer experience and boost marketing effectiveness.
Node.js now supports Single Executable Applications (SEA) with ESM entry points, allowing developers to bundle code and the runtime into a single binary, and benchmarks by Evan You demonstrate that the resulting executable launches faster than Bun's compiled mode.
This guide explains how to use Maven's assembly plugin to create executable JARs, ZIP/TAR archives, and custom distribution packages by configuring the plugin in pom.xml, writing assembly descriptors, and running a single Maven command, with multiple real‑world examples and a sample project structure.
The author reviews common Java desktop packaging methods—GraalVM, JLink, Exe4J, batch scripts, and plain JAR—detailing their advantages and drawbacks, then demonstrates a custom WinForm‑based packaging utility that bundles a Swing application and a trimmed JRE into a single executable for double‑click launch.
This guide compares common Java desktop packaging methods, evaluates their pros and cons, and demonstrates a custom Winform tool that bundles a Swing program and a minimal JRE into a single executable for easy distribution.
After struggling with manual gnuplot installations across Linux, macOS, and Windows, the author created a Python wheel that bundles the binary, enabling pip install without system dependencies, simplifying usage for developers, researchers, and DevOps scripts, and integrating it into the gitstats tool.
The article explains why the traditional setup.py build script is outdated, outlines the problems it causes, and shows how adopting a declarative pyproject.toml file modernizes Python packaging, improves maintainability, and unifies tool configuration.
Upgrading a Python project from 3.11 to 3.12 can cause macOS App Store rejections because the new standard library embeds an "itms-services" URL string that Apple’s automated review flags, prompting CPython core developers to propose patches, distribution‑tool options, and a new compliance flag to resolve the issue.
This guide explains how to use electron-builder to package Electron apps into native installers for Windows, macOS, and Linux, covering setup, configuration, Python integration, code signing, auto‑updates, and practical tips for seamless cross‑platform distribution.
This article explains why turning a Python script into a standalone .exe can simplify distribution, improve usability, protect source code, and enhance portability, and it provides step‑by‑step guides for three popular tools—PyInstaller, auto‑py‑to‑exe (py2exe), and cx_Freeze—along with a concise feature comparison.
This article provides a comprehensive guide to using Kotlin, Jetpack Compose, and Multiplatform for desktop applications, covering project setup, shared code structure, platform-specific implementations, UI layout, resource handling, dependency configuration, and detailed packaging options for Windows, macOS, and Linux.
This article explains how Chiplet technology boosts integration and performance in modern SoCs, compares MCM, CoWoS, and EMIB packaging methods, discusses architectural design strategies and the UCIe standard, and highlights real‑world examples from Intel, AMD, Huawei, and Apple.
This guide explains what auto-py-to-exe is, how to install it, introduces its key options, and walks through a step‑by‑step example of packaging a simple calculator Python program into a standalone executable.
This guide compares five Java Swing packaging approaches, evaluates their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing app with a minimal JRE into a standalone executable, complete with example Maven configuration and source code.
This article explains how to reduce Unreal Engine Android package size and native library memory usage by applying a series of build‑time and resource‑trimming strategies—including native lib compression, code size reduction, relocation table compression, and selective asset packaging—while preserving runtime performance.
This guide walks through building a Chrome extension from scratch, covering manifest configuration, UI pages, content and background scripts, required permissions, development tools, debugging techniques, packaging, publishing to the Chrome Web Store, and common feature implementations such as page interaction, messaging, and request interception.
This article compares five Java packaging methods—GraalVM, JLink, Exe4J, batch scripts, and plain JAR—detailing their pros and cons, then introduces a custom WinForm tool that bundles Swing applications into self‑contained executable files, complete with code examples and deployment steps.
This article provides a structured overview of Python version management, virtual environment handling, package management, building, and publishing tools, comparing utilities like pyenv, conda, pipenv, Poetry, pdm, Hatch, and Rye, and includes practical command examples and a feature‑comparison table.
This tutorial explains what auto-py-to-exe is, how to install it, details its key configuration options, and demonstrates the complete packaging process with a simple calculator project, enabling Python scripts to be turned into standalone executables.
This tutorial explains why Python projects need packaging, introduces essential tools like setuptools, wheel, and twine, shows the recommended project layout, walks through creating a setup.py file, building distribution files, testing locally, uploading to PyPI, and handling version updates and common questions.
This guide walks you through the fundamentals of creating a Python package, from setting up the directory and __init__.py file to adding modules, configuring setup.py, and using the package locally or via installation, complete with code examples.
This article explains how to gather GIF assets, write a PyQt5 desktop‑pet application in Python—including directory layout, window initialization, tray integration, random positioning, mouse interaction, and context menus—and finally package the program into an executable using PyInstaller.
This tutorial explains how to prepare a PHP project, install and use Composer to manage dependencies, create a ZipArchive with PHP code to package the entire application, and finally deploy the packaged project on a web server such as Apache or Nginx.
This guide tackles the problem of oversized Spring Boot JARs by showing how to separate library JARs and configuration files from the main artifact, presenting three Maven‑based solutions—spring‑boot‑maven‑plugin, maven‑jar‑plugin, and maven‑assembly‑plugin—complete with configuration snippets, build commands, and deployment tips.
This article explains how to use Maven plugins to build a Spring Boot project into an executable JAR, separate its dependencies into a lib folder, and create a Docker image that copies those libraries, enabling clean deployment of Java backend services.
This article explains how to streamline Spring Boot production releases by extracting libraries and configuration files from the main JAR, using various Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, maven-assembly-plugin, and maven-jar-plugin to create lightweight, fast‑deployable packages.
This article reviews several methods for distributing Java Swing applications as standalone executables—including GraalVM native images, JLink, Exe4J, batch scripts, and plain JAR distribution—compares their advantages and drawbacks, and demonstrates a custom WinForm packaging tool with example Maven and source code.
This guide walks through preparing the Kivy development environment on macOS and CentOS, creating a simple hello‑world Python app, installing and using Buildozer to package the app for Android (and iOS), and troubleshooting common build issues with code examples and virtual‑machine recommendations.
This article explores Java Swing packaging challenges, compares five distribution methods—including GraalVM, JLink, and Exe4J—highlights their pros and cons, and demonstrates a custom WinForm tool that bundles a Swing program with a minimal JRE into a double‑clickable executable.
This tutorial explains how to set up the Kivy development environment on macOS, Linux, and CentOS, create a simple hello‑world Python app, test it, install Buildozer, and use it to package the app into an Android APK (or iOS build), including common pitfalls and fixes.
This article walks through creating the Mofish Python library, using Click to build a command‑line tool that shows days remaining to holidays, packaging it with setuptools, and publishing the package to PyPI for easy installation and use.
This guide explains how to use Maven plugins such as spring-boot-maven-plugin, maven-dependency-plugin, and maven-jar-plugin to package a Spring Boot application into an executable JAR with external lib dependencies, and shows how to deploy the resulting artifacts in a Docker container using a custom Dockerfile.
PyPA, the Python Packaging Authority, oversees key tools such as pip, setuptools, packaging, wheel, virtualenv, twine, and build, each serving distinct roles in package installation, creation, distribution, and environment isolation, with pyproject.toml coordinating their interactions to streamline Python development workflows.
This article explains how to build a desktop pet application using Python and PyQt5, covering required GIF assets, multiple methods for creating or sourcing those GIFs, the project directory layout, detailed source code walkthrough, and steps to package the app with PyInstaller.
This tutorial walks through creating a cross‑platform Electron desktop app using Vue 3 and Vite, covering project setup, Electron installation, configuration of .npmrc and plugins, writing the main process, Vite plugin integration, package.json adjustments, building, Windows and Linux packaging, NSIS installer options, and adding Vue router for navigation.
This guide explains how to structure a Python project, list required libraries in requirements.txt, write a main script that installs dependencies at runtime, and use PyInstaller to bundle the application and its assets into a single executable that automatically installs needed packages.
This comprehensive guide explains how to integrate Flutter into an existing Android app using source and AAR approaches, manage multiple Flutter engines with FlutterEngineGroup, choose hybrid stack solutions such as flutter_boost and flutter_thrio, apply MVVM architecture with Riverpod, and handle debugging and APK packaging.
Upgrading Python from 3.11 to 3.12 introduced an "itms‑services" string in the standard library, causing macOS App Store rejections, which led developers and CPython core contributors to discuss the issue, propose patches, and plan a compliance option for future Python releases.
This step‑by‑step guide shows how to structure a Python project, write a setup.py and README, add code and tests, build a source distribution, create a zip package, upload it to PyPI with Twine, and finally install the library using pip.
The article explains how the __init__.py file marks a directory as a Python package, enables package initialization, controls namespace exposure, defines package‑level variables and metadata, supports dynamic loading, performance optimizations, and can serve as an entry point, while noting changes introduced in Python 3.3 and PEP 420.
This article explains why Maven runs unit tests during the package phase, describes the Maven lifecycle, and provides several practical methods—including command‑line flags, pom.xml configuration, and IDE settings—to skip tests when building a Java project.
This article provides a detailed guide to Python version management, package management, virtual environment handling, package building, and publishing tools, comparing utilities like pyenv, venv, virtualenv, pip, pipenv, conda, Poetry, pdm, Hatch, and Rye, and explaining their motivations, commands, and feature support.
This article details the background, research, demos, discovered issues, and the comprehensive refactor of the pipdeptree tool to replace deprecated pkg_resources APIs with importlib.metadata, improving Python package dependency analysis for AI workloads in TencentOS.
This guide explains what PHAR archives are, how to configure PHP to allow writing PHAR files, how to structure a PHP project, create a PHAR package with a build script, run it via a simple wrapper, and outlines the internal mechanics and limitations of PHAR.
This article explains what auto-py-to-exe is, how to install it, describes its key configuration options, and walks through a complete example of packaging a simple Python calculator into a single executable, while also offering tips for handling additional files and icons.
This article explains how to package a Spring Boot application so that its dependencies are stored externally and loaded at runtime using Maven plugins and the PropertiesLauncher, enabling easy replacement of individual libraries without rebuilding the entire fat jar.
This article explains how to create a Spring Boot fat‑jar that externalizes its dependencies by configuring the spring‑boot‑maven‑plugin and maven‑assembly‑plugin to produce a ZIP layout, then uses the PropertiesLauncher with loader.path to load libraries from a separate libs directory at runtime.
This guide explains the step-by-step process of preparing, managing dependencies with Composer, creating directory structures, and using PHP code to package a project into a zip archive for deployment, including installation commands and deployment tips for web servers.
This article walks through a common PyInstaller issue where the input dialog disappears in the generated exe, explains why the executable size balloons, and provides a clear code solution and practical tips to resolve the problem.
This article explains why a Spring Boot application runs with the configured port when packaged as a JAR using the embedded Tomcat, but switches to Tomcat's default port and context path when deployed as a WAR, and provides step‑by‑step instructions to package and deploy both formats along with historical context and technical differences.
This article provides a step‑by‑step guide to using CMake for cross‑platform builds, covering fundamental concepts, basic project setup, adding versioning and configuration headers, creating libraries, optional components, installation, testing, packaging with CPack, dashboard integration, and practical usage within JetBrains CLion for C/C++ development.
This article explains how to use Setuptools to manage dependencies, package source code, and provide command-line tools, and demonstrates a step‑by‑step example of integrating Sphinx to automatically generate documentation and include it in a Python package build.
This article explains several methods for converting Python scripts into standalone executables—including pyinstaller, cx_Freeze, py2exe, py2app, Nuitka, and a combination of Nuitka with pyinstaller—detailing their commands, platform support, advantages, and common pitfalls such as missing imports and GIL-related issues.
This article examines the directory structures, package.json entries, and build scripts of popular React component libraries—Ant Design, Arco Design, and Semi Design—explaining how they generate CommonJS, ES Module, and UMD bundles using tools like tsc, Babel, Webpack, and Gulp, and shows how to apply the same approach when creating your own library.
Docker version 24.0.6 introduces numerous bug fixes and feature enhancements—including fixes to containerd storage backend commands, overlayfs snapshotter issues, network isolation rules, and Windows service registration—alongside packaging updates such as upgrading Go to 1.20.7, containerd to v1.7.3, and Compose to v2.21.0.
This article compares PyInstaller and Nuitka for converting Python projects into standalone executables, shares practical experiences—including size and speed differences—and provides a detailed installation and command‑line guide for Nuitka with code examples and post‑build dependency handling.
This article explains the differences between JAR and WAR files, why Spring Boot runs with an embedded Tomcat when packaged as a JAR, how deployment changes when using an external Tomcat, and provides step‑by‑step instructions with Maven configurations to build Spring Boot applications as either JAR or WAR packages.
This article explains the differences between JAR and WAR packaging for Spring Boot applications, shows why embedded Tomcat behaves differently from external Tomcat, and provides step‑by‑step instructions with Maven commands and pom.xml modifications to build both JAR and WAR artifacts.
Red Hat announced that it will stop maintaining the LibreOffice RPMS packages for future RHEL releases, labeling them as orphaned and encouraging users to adopt the Flatpak version while refocusing engineering effort on Wayland, HDR and related display improvements.
This guide walks you through converting a Spring Boot JAR into a Windows executable using exe4j and then packaging it with its bundled JRE into an installer via Inno Setup, enabling users to run the application on machines without any Java runtime installed.
This article explains why a Spring Boot project runs differently when packaged as a JAR versus a WAR, outlines the historical evolution of Java web containers, compares the characteristics of JAR and WAR files, and provides step‑by‑step Maven commands and pom.xml configurations for building both package types.
This article explains why Maven runs unit tests during the package phase, describes the problems caused by missing production database access, and provides five practical methods—including command‑line flags, pom.xml configuration, IDE settings, and Maven runner options—to skip tests when building a Java project.
The article details multiple ways to skip unit tests when packaging a Maven Java project, including command‑line flags, pom.xml configuration, IDE settings, and Maven runner VM options, enabling developers to build JAR files without test execution when production configurations are needed.
This article explains why a Spring Boot application behaves differently when run as a JAR versus deployed as a WAR, outlines the historical context of servlet containers, compares JAR and WAR formats, and provides step‑by‑step Maven commands and pom.xml modifications for packaging both types.
This article shares practical techniques for adapting Android apps to overseas markets, covering modular code design, compliance checks, AAB bundle creation, Google Play signing, manifest adjustments, and automated multi‑language workflows to streamline global publishing.
This article explains how to create a Spring Boot package that keeps dependencies external by configuring the spring-boot-maven-plugin and maven-assembly-plugin, using a ZIP layout and PropertiesLauncher, so the application can be started with a custom loader.path that points to a libs directory.
This guide walks you through installing the required build tools, configuring go-bin-rpm with a concise rpm.json file, generating RPM packages, and automating the process with a Makefile for seamless Go binary deployment on RPM‑based systems.
This guide walks through preparing a Spring Boot jar, converting it to a Windows executable with exe4j, bundling the executable and a local JRE using Inno Setup, and creating an installer that runs on machines without a pre‑installed JDK.
This article explains common Maven commands, describes why a JAR built for execution cannot be imported by a third‑party project, and provides step‑by‑step solutions using the maven‑compiler‑plugin and maven‑assembly‑plugin to create dependency‑inclusive JARs.
auto-py-to-exe is a GUI front‑end for PyInstaller that simplifies packaging Python scripts into standalone executables; this guide explains installation, key configuration options such as script location, one‑file mode, console window, icon, additional files, and demonstrates a complete example by packaging a simple calculator program.
By formulating the Aurora Blue box design as an integer programming problem and applying both exact linear methods and a tailored genetic algorithm, the study identified an eight‑to‑fifteen‑type solution that raises packing efficiency by 5.49%, cuts paper use 7.6% and trims shipping cost by 0.06 CNY.
Linear Programminggenetic algorithminteger programming
This article reviews the fragmented state of Python project layout and build processes, compares four popular scaffolding and build tools—Cookiecutter, PyScaffold, PyBuilder, and Poetry—showing their installation commands, generated directory structures, and typical make/ tox workflows for packaging, testing, and documentation.
PowerShell Core 7.2.4, a cross‑platform automation and configuration framework, introduces several build and packaging enhancements for Ubuntu 22.04, Docker image updates, security supply‑chain analysis, and fixes to web cmdlets and RPM packaging.
This guide walks through preparing a PyQt5 project, installing PyInstaller, generating and configuring the .spec file, and using PyInstaller commands to build a standalone Windows executable, including tips for handling console windows and embedding resources.
This guide explains how to configure Maven profiles and the assembly plugin to create a zip package for a Spring Boot application, then use a reusable shell script to unzip, start, stop, and restart the service on Linux, streamlining deployment across multiple environments.
This guide walks through converting a functional Spring Boot JAR into a Windows executable with exe4j, then bundling the EXE, JRE, and dependencies into a single installer using Inno Setup, providing step‑by‑step screenshots, configuration tips, and the final script for seamless deployment on machines without a JDK.
The article explains how chiplet technology, as a modular semiconductor IP solution, reduces design cost and time, expands market opportunities, and faces challenges such as standardization, packaging testing, and software integration, while outlining its market outlook and impact on business models.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, configuring the bundled JRE, and then creating a full installer with Inno Setup, enabling non‑technical users to install and run the application without a separate JDK.
This article compares PyInstaller and Nuitka for turning Python projects into standalone executables, highlighting Nuitka's dramatically smaller file size, faster build times, and better performance while explaining installation steps, command‑line options, and how to handle third‑party dependencies.
This article compares PyInstaller and Nuitka for converting Python scripts into standalone Windows executables, discusses their advantages and drawbacks, provides step‑by‑step installation of Nuitka, explains key command‑line options, and demonstrates a practical example that yields a tiny, fast‑building executable versus a large, slow‑building PyInstaller output.
Sealer is an open-source Alibaba tool for packaging, delivering, and running distributed applications as cluster images, simplifying Kubernetes cluster deployment and management on Linux systems.
This article explains the evolution of Python packaging, compares legacy tools like distutils and setuptools with modern solutions such as Poetry, details how to create and configure pyproject.toml, setup.py, and requirements files, and provides practical guidance on building wheels, eggs, and publishing packages to PyPI.
This tutorial introduces common Python GUI frameworks, provides an in‑depth overview of PyQt5 and its modules, walks through installation, Qt Designer configuration, code examples for creating windows and handling events, demonstrates a weather‑query application, and explains how to package the program into a standalone executable.
This article explains how to package a Spring Boot application using Maven profiles and the maven‑assembly‑plugin, generate a zip deployment package, and manage the deployment with a custom shell script that supports unzip, start, stop, and restart operations across different environments.
This article explains why Android developers need Gradle, describes the structure of a default Android project, details Gradle concepts such as projects, tasks, and the wrapper, and walks through dependency configurations, conflict resolution, and the complete build and packaging pipeline for APK generation.
This guide explains how to build a Python desktop GUI application with Tkinter, PyQt5, or wxPython, package it using tools like PyInstaller, and implement a robust update mechanism that detects new versions on a remote server, downloads the update, and seamlessly replaces the old files.
This tutorial walks through converting a functional Spring Boot JAR into a Windows executable using exe4j, configuring a bundled JRE, and creating a single‑click installer with Inno Setup, providing step‑by‑step screenshots and command‑line details to avoid common pitfalls.
This guide walks through preparing a runnable Spring Boot JAR, converting it to an EXE with exe4j (including VM options and bundled JRE), and then creating a self‑contained installer using Inno Setup so the application can run on computers without a pre‑installed JDK.
This tutorial walks through preparing a Spring Boot JAR, converting it to an executable with exe4j, embedding a local JRE, and finally creating a user‑friendly installer using Inno Setup, enabling distribution to computers without a pre‑installed JDK.
This tutorial walks you through every essential step—from adding a license and organizing your project structure to writing tests, configuring CI, creating documentation, and finally releasing the package on PyPI or Conda—so you can share your Python library with the world.
This tutorial walks through the complete process of turning a local Python project into an open‑source package, covering licensing, project structure, setup.py creation, testing, coverage, documentation, continuous integration, and finally publishing to PyPI or Conda, with practical code examples and configuration files.
The article explains how Google and Facebook’s monolithic repositories and unified build systems let them avoid Docker images by using direct module transfer, tarballs, XAR files, and overlay filesystems, while highlighting the technical trade‑offs and challenges of layered caching in large‑scale clusters.
This guide explains how individuals or organizations can configure a setup.py file, build distribution packages, publish them to PyPI, generate documentation with pydoc, choose appropriate version numbers, and select a suitable open‑source license for a Python project hosted on GitHub.
This article explains a practical solution for developing, configuring, and packaging multiple mini‑programs from a single codebase using Taro, covering the challenges of cross‑team collaboration, environment‑specific configuration, adaptation layers, and integration methods such as plugins and sub‑packages.
This article details the end‑to‑end process of designing, publishing, packaging, optimizing, and continuously delivering a reusable React component library at Ctrip, covering npm workflow, build tooling choices, CSS extraction, on‑demand loading, package splitting, collaborative documentation, CI/CD, and automated testing.
This guide walks through configuring iOS certificates, installing Fastlane, handling common installation issues, and using Fastlane or a build script to package and install an iOS app on a real device, complete with command‑line examples and troubleshooting tips.