awesome-repositories.com
Blog
MCP
awesome-repositories.com

Discover the best open-source repositories with AI-powered search.

ExploreCurated searchesOpen-source alternativesSelf-hosted softwareBlogSitemap
ProjectMCP serverAboutHow we rankPress
LegalPrivacyTerms
© 2026 Bringes Technology SRL·VAT RO45896025·hello@awesome-repositories.com
nexe avatar

nexe/nexe

0
View on GitHub↗

Nexe

Nexe is a cross-platform binary bundler and compiler that packages Node.js applications and their dependencies into single standalone executables. It functions as a runtime compiler that can build the Node.js runtime from source with custom flags and application snapshots to enable software distribution without requiring a pre-installed runtime.

The system allows for cross-compilation across different operating systems and architectures from a single build environment. It includes a static asset bundler to embed external files and directories directly into the compiled binary for access at runtime.

The build process is managed through a pipeline that supports custom middleware and plugins to modify source code, integrate build patches, and resolve dependencies.

AI search

Explore more awesome repositories

Describe what you need in plain English — the AI ranks thousands of curated open-source projects by relevance.

Start searching with AI

Features

  • Binary Compilers - Converts interpreted JavaScript source code into standalone native binaries for distribution.
  • Cross-Platform Binary Generation - Generates platform-specific executable binaries for diverse CPU architectures and operating systems from a single build environment.
  • Cross-Compilation Toolchains - Provides a build environment capable of generating executable binaries for diverse operating systems and hardware architectures from a single host.
  • Build-Time Bundles - Bundles required libraries and external modules directly into application binaries during the build process.
  • Single-Binary Distributions - Packages an application and all its dependencies into a single executable file for simplified distribution.
  • Static Binary Compilers - Bakes external file contents and directory structures directly into the compiled executable binary.
  • Static Asset Embedding - Includes specific files or directories into the binary using glob patterns for access at runtime.
  • Static Dependency Bundlers - Resolves and embeds all required modules and libraries at build time to create a standalone executable.
  • Custom Runtime Builds - Compiles a version of the Node.js runtime from source with specific flags and configurations embedded into a binary.
  • Standalone Application Packaging - Packages Node.js apps into single standalone binaries to distribute software without requiring a pre-installed runtime.
  • Standalone Executable Compilers - Bundles Node.js applications and their dependencies into a single standalone binary for distribution without a pre-installed runtime.
  • Standalone Archive Deployment - Provides the ability to package applications as standalone executable archives for simplified installation and cross-platform execution.
  • Runtime Compilers - Compiles the Node.js runtime from source with custom build flags and application snapshots.
  • Runtime Builds - Compiles the Node.js runtime from source using custom flags and configurations for specific environment compatibility.
  • Standalone Server Executables - Generates self-contained server binaries that bundle the application and runtime for independent execution.
  • Bundling Pipeline Extensions - Provides hooks and interfaces for inserting custom transformation logic into the bundling pipeline.
  • Build Patching Utilities - Ships utilities for modifying application files during the build process to customize the final executable.
  • Build Pipeline Plugins - Implements a build pipeline with modular extensions that intercept and transform assets during the compilation lifecycle.
  • Embedded Asset Bundlers - Packages static assets and non-code files directly into an executable binary using an embedded virtual filesystem.
  • Binary Asset Embedding - Bakes JavaScript source and static assets directly into the compiled executable binary for internal runtime access.
  • Runtime Snapshots - Captures the initial state of the runtime environment to significantly accelerate the startup of bundled executables.
13,571 stars·556 forks·TypeScript·MIT·28 views

Star history

Star history chart for nexe/nexeStar history chart for nexe/nexe

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

Projects sharing features with Nexe

These projects share indexed features with Nexe. Shared tags can include platform or build tooling; verify the primary use case before treating a result as a replacement.
  • zeit/pkgzeit avatar

    zeit/pkg

    24,366View on GitHub↗

    pkg is a Node.js executable packager and cross-platform binary compiler. It bundles a project and its dependencies into a single standalone executable file that runs without a pre-installed runtime on the target machine. The tool uses a virtual filesystem bundler to embed project assets and native modules into a binary snapshot. It includes a bytecode obfuscator that compiles source code into bytecode to prevent the extraction of raw logic. The project supports cross-platform distribution, allowing the generation of binaries for different operating systems and architectures from a single hos

    JavaScript
    View on GitHub↗24,366
  • btbn/ffmpeg-buildsBtbN avatar

    BtbN/FFmpeg-Builds

    10,382View on GitHub↗

    FFmpeg-Builds is a cross-platform compilation toolchain and custom build system designed to generate static executables of the FFmpeg multimedia framework. It provides a distribution of pre-compiled binaries for multiple operating systems and hardware architectures. The project utilizes a Docker-based build environment to isolate toolchains and dependencies. This containerized approach enables multi-architecture cross-compilation and allows for parameter-driven feature selection to include specific codecs, libraries, and license options in the final binaries. The system manages the entire wo

    Shell
    View on GitHub↗10,382
  • vercel/pkgvercel avatar

    vercel/pkg

    24,364View on GitHub↗

    pkg is a Node.js executable packager and cross-platform binary compiler. It bundles a project and its dependencies into a single standalone binary, allowing applications to run on machines without a pre-installed runtime. The project distinguishes itself by precompiling JavaScript source code into bytecode to remove human-readable text and obfuscate the logic. It utilizes a virtual filesystem bundler to embed static assets and non-javascript files directly into the executable, employing compression algorithms to reduce the final binary size. The tool covers cross-platform compilation for var

    JavaScriptbinariesclicompiler
    View on GitHub↗24,364
  • indygreg/pyoxidizerindygreg avatar

    indygreg/PyOxidizer

    6,105View on GitHub↗

    PyOxidizer is a Python application packager and interpreter embedder designed to compile Python code and dependencies into a single standalone executable binary. It functions as a distribution tool that allows applications to run on target machines without a pre-installed interpreter. The project serves as a bridge between Rust and Python, providing a framework to integrate the two languages for creating linkable libraries or incrementally replacing logic. It facilitates the embedding of a Python runtime into larger applications to execute scripts or provide Python-based logic. The toolset c

    Rust
    View on GitHub↗6,105
Compare all 30 related projects→

Frequently asked questions

What does nexe/nexe do?

Nexe is a cross-platform binary bundler and compiler that packages Node.js applications and their dependencies into single standalone executables. It functions as a runtime compiler that can build the Node.js runtime from source with custom flags and application snapshots to enable software distribution without requiring a pre-installed runtime.

What are the main features of nexe/nexe?

The main features of nexe/nexe are: Binary Compilers, Cross-Platform Binary Generation, Cross-Compilation Toolchains, Build-Time Bundles, Single-Binary Distributions, Static Binary Compilers, Static Asset Embedding, Static Dependency Bundlers.

Which projects share features with nexe/nexe?

Projects with overlapping indexed features include: zeit/pkg — pkg is a Node.js executable packager and cross-platform binary compiler. It bundles a project and its dependencies… btbn/ffmpeg-builds — FFmpeg-Builds is a cross-platform compilation toolchain and custom build system designed to generate static… vercel/pkg — pkg is a Node.js executable packager and cross-platform binary compiler. It bundles a project and its dependencies… indygreg/pyoxidizer — PyOxidizer is a Python application packager and interpreter embedder designed to compile Python code and dependencies… mitchellh/gox — Gox is a cross-platform build automator and command line tool designed for Go cross-compilation. It serves as a… rakyll/statik — Statik is a build tool for the Go language that transforms directory structures and files into byte arrays within…