Electron API

Electron API Electron APIs are assigned based on the process type, meaning that some modules can be used from either the Main or Renderer process, and some from both. Electron's API documentation indicates which process each module can be used from. For example, to access the Electron API in both processes, require its included module. For the most part, we can assure you that Electron is 99.9% trustable and is safe to use. Can Electron execute any scripts? We are certain that Electron is capable of executing majority of scripts you wish to use. An Electron for.NET apps So what is Blazor Desktop, really? Microsoft sometimes compares it to Electron, the desktop wrapper for JavaScript applications that powers software like Slack.

Developer API only. See Configuration for user documentation.

  • electron-builder
    • .Arch : enum
    • .build(rawOptions)Promise<Array<String>>
    • .createTargets(platforms, type, arch)Map<Platform Map<Arch Array<String>>>

electron-builder.Arch : enum

Kind: enum of electron-builder
Properties* ia32 * x64 * armv7l * arm64

electron-builder.build(rawOptions)Promise<Array<String>>

Kind: method of electron-builder

ParamType
rawOptionsCliOptions

electron-builder.createTargets(platforms, type, arch)Map<Platform Map<Arch Array<String>>>

Kind: method of electron-builder

ParamType
platformsArray<Platform>
typeStringnull
archStringnull
Api

Package your Electron app into OS-specific bundles (.app, .exe, etc.) via JavaScript or the command line.

Supported Platforms Installation Usage API Contributing Support Related Apps/Libraries FAQ Release Notes

About

Electron Packager is a command line tool and Node.js library that bundles Electron-based application source code with a renamed Electron executable and supporting files into folders ready for distribution.

For creating distributables like installers and Linux packages, consider using either Electron Forge (which uses Electron Packager internally), or one of the related Electron tools, which utilizes Electron Packager-created folders as a basis.

Note that packaged Electron applications can be relatively large. A zipped, minimal Electron application is approximately the same size as the zipped prebuilt binary for a given target platform, target arch, and Electron version(files named electron-v${version}-${platform}-${arch}.zip).

Supported Platforms

Electron Packager is known to run on the following host platforms:

  • Windows (32/64 bit)
  • macOS (formerly known as OS X)
  • Linux (x86/x86_64)

It generates executables/bundles for the following target platforms:

  • Windows (also known as win32, for x86, x86_64, and arm64 architectures)
  • macOS (also known as darwin) / Mac App Store (also known as mas)* (for x86_64 and arm64 architectures)
  • Linux (for x86, x86_64, armv7l, arm64, and mips64el architectures)

*Note for macOS / Mac App Store target bundles: the .app bundle can only be signed when building on a host macOS platform.

Installation

This module requires Node.js 10.0 or higher to run.

Building Windows apps from non-Windows platforms

Building an Electron app for the Windows target platform requires editing the Electron.exe file. Currently, Electron Packager uses node-rcedit to accomplish this. A Windows executable is bundled in that Node package and needs to be run in order for this functionality to work, so on non-Windows host platforms, Wine 1.6 or later needs to be installed. On macOS, it is installable via Homebrew.

Electron Api

Usage

JavaScript API usage can be found in the API documentation.

From the Command Line

Running electron-packager from the command line has this basic form:

This will:

  • Find or download the correct release of Electron
  • Use that version of Electron to create a app in <out>/<appname>-<platform>-<arch>(this can be customized via an optional flag)

--platform and --arch can be omitted, in two cases:

  • If you specify --all instead, bundles for all valid combinations of target platforms/architectures will be created.
  • Otherwise, a single bundle for the host platform/architecture will be created.

For an overview of the other optional flags, run electron-packager --help or see usage.txt. For detailed descriptions, see the API documentation.

If appname is omitted, this will use the name specified by 'productName' or 'name' in the nearest package.json.

Desktopshelves. Characters in the Electron app name which are not allowed in all target platforms' filenames (e.g., /), will be replaced by hyphens (-).

You should be able to launch the app on the platform you built for. If not, check your settings and try again.

Be careful not to include node_modules you don't want into your final app. If you put them in the devDependencies section of package.json, by default none of the modules related to those dependencies will be copied in the app bundles. (This behavior can be turned off with the prune: false API option or --no-prune CLI flag.) In addition, folders like .git and node_modules/.bin will be ignored by default. You can use --ignore to ignore files and folders via a regular expression (not a glob pattern). Examples include --ignore=.gitignore or --ignore='.git(ignore modules)'.

Example

Let's assume that you have made an app based on the electron-quick-start repository on a macOS host platform with the following file structure:

…and that the following is true:

  • electron-packager is installed globally
  • productName in package.json has been set to Foo Bar
  • The electron module is in the devDependencies section of package.json, and set to the exact version of 1.4.15.
  • npm install for the Foo Bar app has been run at least once

When one runs the following command for the first time in the foobar directory:

electron-packager will do the following:

  • Use the current directory for the sourcedir
  • Infer the appname from the productName in package.json
  • Infer the appVersion from the version in package.json
  • Infer the platform and arch from the host, in this example, darwin platform and x64 arch.
  • Download the darwin x64 build of Electron 1.4.15 (and cache the downloads in ~/.electron)
  • Build the macOS Foo Bar.app
  • Place Foo Bar.app in foobar/Foo Bar-darwin-x64/ (since an out directory was not specified, it used the current working directory)

Electron Api Calls

The file structure now looks like:

The Foo Bar.app folder generated can be executed by a system running macOS, which will start the packaged Electron app. This is also true of the Windows x64 build on a system running a new enough version of Windows for a 64-bit system (via Foo Bar-win32-x64/Foo Bar.exe), and so on.

Related

  • Electron Forge - creates, builds, and distributes modern Electron applications
  • electron-packager-interactive - an interactive CLI for electron-packager
  • grunt-electron - grunt plugin for electron-packager

Distributable Creators

  • electron-installer-zip - creates symlink-compatible ZIP files

Electron Api Example

Windows:

  • electron-winstaller - Squirrel.Windows-based installer from the Electron maintainers group
  • electron-windows-store - creates an AppX package for the Windows Store
  • electron-wix-msi - creates traditional MSI installers
  • electron-installer-windows - alternative Squirrel.Windows-based installer

macOS:

  • electron-installer-dmg - creates a DMG

Linux:

  • electron-installer-debian - creates a DEB file
  • electron-installer-redhat - creates an RPM
  • electron-installer-flatpak - creates a Flatpak file
  • electron-installer-snap - creates a Snap file

Plugins

These Node modules utilize Electron Packager API hooks:

Electron Api Demo

  • electron-packager-languages - set the locales available to Electron when packaged, which is used by the Mac App Store, among other places
  • electron-packager-plugin-non-proprietary-codecs-ffmpeg - replaces the normal version of FFmpeg in Electron with a version without proprietary codecs
  • electron-rebuild - rebuild native Node.js modules against the packaged Electron version