• Version 4.0.0-rc.6
  • Published
  • 145 kB
  • 16 dependencies
  • MIT license


npm i nexe
yarn add nexe
pnpm add nexe


Create a single executable out of your Node.js application



variable argv

const argv: parseArgv.ParsedArgs;

    variable help

    let help: string;

      variable version

      const version: string;


        function compile

        compile: (
        compilerOptions?: Partial<NexeOptions>,
        callback?: (err: Error | null) => void
        ) => Promise<void>;


          class NexeCompiler

          class NexeCompiler {}


            constructor(options: NexeOptions);

              property bundle

              bundle: Bundle;
              • Virtual FileSystem

              property configureScript

              configureScript: string;
              • Path to the configure script

              property entrypoint

              entrypoint: string;
              • The main entrypoint filename for your application - eg. node mainFile.js

              property env

              env: { [x: string]: string; TZ?: string | undefined };
              • Copy of process.env

              property files

              files: NexeFile[];
              • In memory files that are being manipulated by the compiler

              property log

              log: Logger;

                property nodeSrcBinPath

                nodeSrcBinPath: string;
                • The file path of node binary

                property options

                options: NexeOptions;

                  property output

                  output: string;
                  • Output filename (-o myapp.exe)

                  property remoteAsset

                  remoteAsset: string;
                  • Remote asset path if available

                  property shims

                  shims: string[];
                  • Standalone pieces of code run before the application entrypoint

                  property src

                  src: string;
                  • Root directory for the source of the current build

                  property startup

                  startup: string;
                  • The last shim (defaults to "require('module').runMain()")

                  property stdinUsed

                  stdinUsed: boolean;
                  • Flag to indicate whether or notstdin was used for input

                  property target

                  target: NexeTarget;
                  • Current target of the compiler

                  property targets

                  targets: NexeTarget[];
                  • Not used

                  method addResource

                  addResource: (
                  absoluteFileName: string,
                  content?: Buffer | string | File
                  ) => Promise<number>;

                    method assertBuild

                    assertBuild: () => void;

                      method build

                      build: () => Promise<ReadStream>;

                        method code

                        code: () => string;

                          method compileAsync

                          compileAsync: (target: NexeTarget) => Promise<any>;

                            method getNodeExecutableLocation

                            getNodeExecutableLocation: (target?: NexeTarget) => string;

                              method quit

                              quit: (error?: any) => Promise<unknown>;

                                method readFileAsync

                                readFileAsync: (file: string) => Promise<NexeFile>;

                                  method replaceInFileAsync

                                  replaceInFileAsync: (
                                  file: string,
                                  replace: string | RegExp,
                                  value: string | StringReplacer
                                  ) => Promise<void>;

                                    method setFileContentsAsync

                                    setFileContentsAsync: (file: string, contents: string | Buffer) => Promise<void>;

                                      method writeFileAsync

                                      writeFileAsync: (file: string, contents: string | Buffer) => Promise<void>;


                                        interface NexeOptions

                                        interface NexeOptions {}

                                          property asset

                                          asset: string;

                                            property build

                                            build: boolean;

                                              property bundle

                                              bundle: boolean | string;

                                                property clean

                                                clean?: boolean;

                                                  property configure

                                                  configure: string[];

                                                    property cwd

                                                    cwd: string;

                                                      property debugBundle

                                                      debugBundle?: boolean;

                                                        property downloadOptions

                                                        downloadOptions: any;
                                                        • Api Only

                                                        property enableNodeCli

                                                        enableNodeCli: boolean;

                                                          property enableStdIn

                                                          enableStdIn?: boolean;

                                                            property fakeArgv

                                                            fakeArgv?: boolean;

                                                              property flags

                                                              flags: string[];

                                                                property fs

                                                                fs: boolean | string[];

                                                                  property ghToken

                                                                  ghToken: string;

                                                                    property ico

                                                                    ico?: string;

                                                                      property info

                                                                      info?: boolean;

                                                                        property input

                                                                        input: string;

                                                                          property loglevel

                                                                          loglevel: 'info' | 'silent' | 'verbose';

                                                                            property make

                                                                            make: string[];

                                                                              property mangle

                                                                              mangle: boolean;

                                                                                property name

                                                                                name: string;

                                                                                  property native

                                                                                  native: any;

                                                                                    property output

                                                                                    output: string;

                                                                                      property patches

                                                                                      patches: (string | NexePatch)[];

                                                                                        property plugins

                                                                                        plugins: (string | NexePatch)[];

                                                                                          property python

                                                                                          python?: string;

                                                                                            property rc

                                                                                            rc: {
                                                                                            [key: string]: string;

                                                                                              property remote

                                                                                              remote: string;

                                                                                                property resources

                                                                                                resources: string[];

                                                                                                  property silent

                                                                                                  silent?: boolean;

                                                                                                    property snapshot

                                                                                                    snapshot?: string;

                                                                                                      property sourceUrl

                                                                                                      sourceUrl?: string;

                                                                                                        property targets

                                                                                                        targets: (string | NexeTarget)[];

                                                                                                          property temp

                                                                                                          temp: string;

                                                                                                            property vcBuild

                                                                                                            vcBuild: string[];

                                                                                                              property verbose

                                                                                                              verbose?: boolean;

                                                                                                                property warmup

                                                                                                                warmup?: string;

                                                                                                                  Package Files (3)

                                                                                                                  Dependencies (16)

                                                                                                                  Dev Dependencies (19)

                                                                                                                  Peer Dependencies (0)

                                                                                                                  No peer dependencies.


                                                                                                                  To add a badge like this badgeto your package's README, use the codes available below.

                                                                                                                  You may also use to create a custom badge linking to

                                                                                                                  • Markdown
                                                                                                                  • HTML
                                                                                                                    <a href=""><img src="" alt=""></a>