Sign inDemoInstall


Package Overview
File Explorer

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies



Create a Flatpak package for your Electron app.

Version published
Weekly downloads
increased by68.06%
Install size
4.50 MB
Weekly downloads



@malept/electron-installer-flatpak npm (scoped) Build Status codecov

Create a flatpak for your Electron app. This is based off the electron-installer-debian tool. Add flatpak support to an electron app using electron-packager with minimal configuration.


This tool requires flatpak and flatpak-builder >= 0.8.2 to be installed on your system. See . For Electron apps using Electron 6 and above, elfutils is required.

Building a flatpak for an Electron app requires installing a "base" flatpak application with electron library dependencies. That base will be autoinstalled during an app build.

Actually running the apps will require the freedesktop runtime to be installed. If you already are running flatpak apps you may have the freedesktop runtime installed. The following example will install the freedesktop runtime for both i386 and x86_64.

flatpak --user remote-add --if-not-exists flathub
flatpak --user install gnome org.freedesktop.Platform/x86_64/1.6 org.freedesktop.Platform/i386/1.6

Apps using Electron 6 or above require a runtime version of 19.08 instead of 1.6. Please note that as of 19.08, they have removed support for the i386 arch.


For use from command-line:

$ npm install -g @malept/electron-installer-flatpak

For use in npm scripts or programmatically:

$ npm install --save-dev @malept/electron-installer-flatpak


Say your Electron app lives in path/to/app, and has a structure like this:

├── node_modules
│   ├── electron-packager
│   └── electron
├── package.json
├── resources
│   ├── Icon.png
│   ├── IconTemplate.png
│   └── IconTemplate@2x.png
└── src
    ├── index.js
    ├── main
    │   └── index.js
    └── renderer
        ├── index.html
        └── index.js

You now run electron-packager to build the app for flatpak:

$ electron-packager . app --platform linux --arch x64 --out dist/

And you end up with something like this in your dist folder:

└── dist
    └── app-linux-x64
        ├── LICENSE
        ├── LICENSES.chromium.html
        ├── content_shell.pak
        ├── app
        ├── icudtl.dat
        ├── locales
        ├── natives_blob.bin
        ├── resources
        ├── snapshot_blob.bin
        └── version

How do you turn that into a flatpak package that your users can install?


If you want to run electron-installer-flatpak through npm, install the package locally:

$ npm install --save-dev @malept/electron-installer-flatpak

Edit the scripts section of your package.json:

  "name": "app",
  "description": "An awesome app!",
  "version": "0.0.1",
  "scripts": {
    "start": "electron .",
    "build:linux:x64": "electron-packager . --platform linux --arch x64 --out dist/",
    "build:flatpak:x64": "electron-installer-flatpak --src dist/app-linux-x64/ --dest dist/installers/ --arch x64"
  "devDependencies": {
    "@malept/electron-installer-flatpak": "^0.10.1",
    "electron-packager": "^14.0.0",
    "electron": "^7.1.1"

And run the script:

$ npm run build:flatpak:x64

You'll end up with the package at dist/installer/io.atom.electron.app_master_x64.flatpak.


Install the package locally:

$ npm install --save-dev @malept/electron-installer-flatpak

An example of a script utilizing this module:

const installer = require('@malept/electron-installer-flatpak')

const options = {
  src: 'dist/app-linux-x64/',
  dest: 'dist/installers/',
  arch: 'x64'

async function main (options) {
  console.log('Creating package (this may take a while)')
  try {
    await installer(options)
    console.log(`Successfully created package at ${options.dest}`)
  } catch (err) {
    console.error(err, err.stack)

You'll end up with the package at dist/installers/io.atom.electron.app_master_x64.flatpak.


If you want to run @malept/electron-installer-flatpak straight from the command-line, install the package globally:

$ npm install -g @malept/electron-installer-flatpak

And point it to your built app:

$ electron-installer-flatpak --src dist/app-linux-x64/ --dest dist/installers/ --arch x64

You'll end up with the package at dist/installers/io.atom.electron.app_master_x64.flatpak.


Even though you can pass most of these options through the command-line interface, it may be easier to create a configuration file:

  "dest": "dist/installers/",
  "icon": "resources/Icon.png",
  "categories": [

And pass that instead with the config option:

$ electron-installer-flatpak --src dist/app-linux-x64/ --arch x64 --config config.json

Type: String Default: undefined

Path to the folder that contains your built Electron application.


Type: String Default: undefined

Path to the folder that will contain your flatpak installer.


Type: Function Default: function (dest, src) { return path.join(dest, src); }

Function that renames all files generated by the task before putting them in your dest folder.

Type: String Default: the inverted hostname of package.homepage plus the santized, or io.atom.electron

App ID of the flatpak, used in the id field of a flatpak-builder manifest and the flatpak filename.


Type: String Default: package.productName ||

Name of the application (e.g. Atom), used in the Name field of the desktop specification.


Type: String Default: package.genericName || package.productName ||

Generic name of the application (e.g. Text Editor), used in the GenericName field of the desktop specification.


Type: String Default: package.description

Short description of the application, used in the Comment field of the desktop specification.


Type: String Default: master

Release branch of the flatpak, used in the branch field of a flatpak-builder manifest and the flatpak filename, after the sanitized app ID.


Type: String Default: io.atom.electron.BaseApp for Electron < 2, org.electronjs.Electron2.BaseApp for Electron >= 2

Base app to use when building the flatpak, used in the base field of a flatpak-builder manifest.


Type: String Default: master

Base app version, used in the base-version field of a flatpak-builder manifest.


Type: String Default: undefined

Url of a flatpakref to use to auto install the base application.


Type: String Default: org.freedesktop.Platform

Runtime id, used in the runtime field of a flatpak-builder manifest.


Type: String Default: 1.6 for Electron < 5, 19.08 for Electron >= 5

Runtime version, used in the runtime-version field of a flatpak-builder manifest.


Type: String Default: org.freedesktop.Sdk

Sdk ID, used in the sdk field of a flatpak-builder manifest.


Type: String Default: undefined

Machine architecture the package is targeted to. Suggested to use node style arches here ('ia32', 'x64'), which will be converted to flatpak style arches ('i386', 'x86_64') when calling into the actual flatpak commands. Directly using flatpak style arches is also supported.


Type: Array[String] Default:

  // X Rendering
  '--socket=x11', '--share=ipc',
  // Open GL
  // Audio output
  // Read/write home directory access
  // Chromium uses a socket in tmp for its singleton check
  // Allow communication with network
  // System notifications with libnotify

Arguments to use when call flatpak build-finish, use in the finish-args field of a flatpak-builder manifest.

Changing this can be used to customize permissions of the sandbox the flatpak will run in.


Type: Array[Array[source, dest]] Default:


Files to copy directly into the app. Should be a list of [source, dest] tuples. Source should be a relative/absolute path to a file/directory to copy into the flatpak, and dest should be the path inside the app install prefix (e.g. /share/applications/)

Application assets and code will be fully handled by electron-packager, but this is a useful way to install things such as appstream metadata for an app, or dbus configuration files.

Type: Array[Array[target, location]] Default:


Symlinks to create in the app files. Should be a list of [target, location] symlink tuples. Target can be either a relative or absolute path inside the app install prefix, and location should be a absolute path inside the prefix to create the symlink at.


Type: Array[Object] Default: []

This option can be used to build extra software modules into the flatpak application sandbox. Most electron applications will not need this, but if you are using native node modules that require certain libraries on the system, this may be necessary. For example, to build libgit2 to use with nodegit, add the following to your modules list.

modules: [
    name: 'libgit2',
    cmake: true,
    sources: [{
      type: 'git',
      url: '',
      branch: 'maint/v0.24'

See the modules field of a flatpak-builder manifest for more details.

For apps using Electron 6 or above, the zypak module is included by default so sandbox support works correctly. Since it needs to compile the module, it only works when the host arch and target arch are the same.


Type: String Default:

Relative path to the executable that will act as binary for the application, used in the Exec field of the desktop specification.

The generated package will contain a symlink /usr/bin/<%= %> pointing to the path provided here.

For example, providing this configuration:

  src: '...',
  dest: '...',
  name: 'foo',
  bin: 'resources/cli/'

Will create a package with the following symlink:

usr/bin/foo@ -> ../lib/foo/resources/cli/

And a desktop specification with the following Exec key:

Exec=foo %U

Type: String or Object[String:String] Default: undefined

Path to a single image that will act as icon for the application:

  icon: 'resources/Icon.png'

Or multiple images with their corresponding resolutions:

  icon: {
    '48x48': 'resources/Icon48.png',
    '64x64': 'resources/Icon64.png',
    '128x128': 'resources/Icon128.png',
    '256x256': 'resources/Icon256.png',
    'scalable': 'resources/Icon.svg'

Note that the image files must be one of the types: PNG or SVG. The support for SVG works only on scalable resolution.


Type: Array[String] Default: []

Categories in which the application should be shown in a menu, used in the Categories field of the desktop specification.

For possible values check out the Desktop Menu Specification.


Type: Array[String] Default: []

MIME types the application is able to open, used in the MimeType field of the desktop specification.




Copyright (c) 2016 Daniel Perez Alvarez ( This is free software, and may be redistributed under the terms specified in the LICENSE file.



Last updated on 14 Jul 2021

Did you know?

Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.


Related posts

SocketSocket SOC 2 Logo


  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc