Tagged articles
executable
33 articles · Page 1 of 1
The article explains how an executable file is located, parsed (e.g., ELF), loaded into memory, divided into code, data, heap and stack regions, how dynamic libraries are placed, and how the OS uses the entry‑point address to start the CPU executing the program.
ELFMemory Layoutentry point
0 likes · 5 min read

This article explains how a C/C++ program is compiled into an ELF executable, details the ELF file structure, describes the kernel's validation and segment mapping, covers dynamic linking, and shows how the process starts execution from the _start entry point, providing practical commands and debugging tips.
ELFLinuxcompilation
0 likes · 34 min read

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.
BackendESMNode.js
0 likes · 9 min read

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.
GraalVMJLinkJava
0 likes · 8 min read

This article explains the ELF file format, its various types, internal structure, compilation and linking steps, and how the Linux kernel loads ELF binaries, creates processes with fork and exec, handles dynamic linking, relocation, and builds the process address space, providing developers and system engineers with deep insight into Linux execution.
Binary FormatELFLinux
0 likes · 40 min read

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.
PyInstallerauto-py-to-exeexecutable
0 likes · 7 min read

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.
GraalVMJLinkJava
0 likes · 6 min read

PHPacker lets you bundle any PHP script or PHAR into a single, cross‑platform executable; this guide shows how to install it via Composer, create a sample script, run the build command for various platforms, and customize output with options such as destination, PHP version, and ini files.
CLIComposerPHP
0 likes · 3 min read

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.
GraalVMJLinkSwing
0 likes · 8 min read

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.
PyInstallerauto-py-to-exeexecutable
0 likes · 6 min read

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.
GraalVMJLinkJava
0 likes · 8 min read

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.
GraalVMJLinkJava
0 likes · 8 min read

This tutorial explains how to set up a Python environment, install the itchat and pyinstaller libraries, write a script that logs into WeChat and sends repeated messages to a specified contact, and then package the script into a standalone executable file.
PyInstallerWeChatautomation
0 likes · 3 min read

This article explains how an executable file is identified, loaded into memory, and organized into code, data, heap, and stack segments, describing the OS’s role, ELF format details, dynamic library placement, and how the CPU finds the program’s entry point to start execution.
ELFMemory Layoutexecutable
0 likes · 6 min read

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.
PyInstallerPythondependencies
0 likes · 5 min read

This guide explains how to extract .pyc files from a Python‑generated executable, restore missing bytecode headers, and use tools such as pyinstxtractor, pyi‑archive_viewer, and uncompyle6 to decompile the bytecode back into readable Python scripts while highlighting common pitfalls and protection mechanisms.
BytecodePyInstallerPython
0 likes · 12 min read

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.
PyInstallerauto-py-to-exeexecutable
0 likes · 6 min read

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.
PyInstallercodeexecutable
0 likes · 4 min read

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.
NuitkaPyInstallerPython
0 likes · 7 min read

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.
NuitkaPyInstallerPython
0 likes · 6 min read

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.
Exe4JInno SetupJava
0 likes · 6 min read

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.
GUIPyInstallerPython
0 likes · 7 min read

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.
PyInstallerPyQt5Python
0 likes · 4 min read

This tutorial walks through converting a functional Spring Boot JAR into a Windows executable with exe4j, bundling a local JRE, and then creating a user‑friendly installer using Inno Setup, providing step‑by‑step screenshots and configuration details to avoid common pitfalls.
BackendExe4JInno Setup
0 likes · 5 min read

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.
CLINuitkaPyInstaller
0 likes · 6 min read

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.
CLINuitkaPyInstaller
0 likes · 6 min read


21CTONov 25, 2021 · Backend Development
This article compares PyInstaller and Nuitka for converting Python projects into standalone executables, highlighting Nuitka's dramatically smaller file size, faster build times, and better performance while also providing step‑by‑step installation and usage instructions.
NuitkaPerformancePyInstaller
0 likes · 6 min read

This guide walks through converting a Spring Boot JAR into a Windows executable using exe4j, configuring the EXE for 32/64‑bit compatibility, adding VM parameters, and then packaging the EXE together with a local JRE into an installer with Inno Setup, providing step‑by‑step screenshots and script details.
Exe4JInno SetupJava Packaging
0 likes · 5 min read

This article explains how Go executables receive and process command‑line arguments and environment variables, compares C and Go implementations, dives into the Linux stack layout, and details the flag package's parsing mechanics with code examples and runtime internals.
C integrationCommand Line ArgumentsGo
0 likes · 21 min read

This guide shows how to create a series of playful Python prank programs, package them into standalone EXE files using PyInstaller, troubleshoot a common encoding bug, and includes ready-to-use code snippets and visual examples for each trick.
Prank ScriptsPythonexecutable
0 likes · 6 min read

This tutorial explains how to use the pkg tool to bundle a Node.js script into a standalone executable for Windows, macOS, and Linux, covering installation, sample code, configuration, and command‑line options to distribute applications without requiring a separate Node.js runtime.
CLINode.jsexecutable
0 likes · 6 min read

This article explains why the same program can execute on Linux yet not run on Windows by breaking down the compilation, assembly, linking stages, the ELF executable format, and how loaders and symbol tables make cross‑platform execution possible.
ELFLinuxcompilation
0 likes · 10 min read

This article explains how a simple Hello World program is transformed from source code into machine code, detailing the roles of object files, sections, linking (static and dynamic), and loading, while showing practical examples with GCC, objdump, and readelf on Linux.
C#executablelinking
0 likes · 16 min read
