Snapcraft Guide (Linux)

    Together with the broader Linux community, Canonical aims to fix many of the common software installation problems with the snapcraft project. Snaps are containerized software packages that include required dependencies, auto-update, and work on all major Linux distributions without system modification.

    There are three ways to create a .snap file:

    1) Using or electron-builder, both tools that come with snap support out of the box. This is the easiest option. 2) Using electron-installer-snap, which takes electron-packager‘s output. 3) Using an already created .deb package.

    In some cases, you will need to have the snapcraft tool installed. Instructions to install snapcraft for your particular distribution are available .

    Package the application using electron-packager (or a similar tool). Make sure to remove node_modules that you don’t need in your final application, since any module you don’t actually need will increase your application’s size.

    The output should look roughly like this:

    1. .
    2. └── dist
    3.     └── app-linux-x64
    4.         ├── LICENSE
    5.         ├── LICENSES.chromium.html
    6.         ├── content_shell.pak
    7.         ├── app
    8.         ├── icudtl.dat
    9.         ├── libgcrypt.so.11
    10.         ├── libnode.so
    11.         ├── locales
    12.         ├── resources
    13.         ├── v8_context_snapshot.bin
    14.         └── version

    Step 2: Running electron-installer-snap

    From a terminal that has snapcraft in its PATH, run electron-installer-snap with the only required parameter --src, which is the location of your packaged Electron application created in the first step.

    1. npx electron-installer-snap --src=out/myappname-linux-x64

    If you have an existing build pipeline, you can use electron-installer-snap programmatically. For more information, see the Snapcraft API docs.

    1. name: electron-packager-hello-world
    2. version: '0.1'
    3. summary: Hello World Electron app
    4. description: |
    5.   Simple Hello World Electron app as an example
    6. base: core18
    7. confinement: strict
    8. grade: stable
    11.   electron-packager-hello-world:
    12.     extensions: [gnome-3-34]
    13.     plugs:
    14.     - browser-support
    15.     - network
    16.     - network-bind
    17.     environment:
    18.       # Correct the TMPDIR path for Chromium Framework/Electron to ensure
    19.       # libappindicator has readable resources.
    20.       TMPDIR: $XDG_RUNTIME_DIR
    22. parts:
    23.   electron-quick-start:
    24.     plugin: nil
    25.     source: https://github.com/electron/electron-quick-start.git
    26.     override-build: |
    27.         npm install electron electron-packager
    28.         npx electron-packager . --overwrite --platform=linux --output=release-build --prune=true
    29.         cp -rv ./electron-quick-start-linux-* $SNAPCRAFT_PART_INSTALL/electron-quick-start
    30.     build-snaps:
    31.     - node/14/stable
    32.     build-packages:
    33.     - unzip
    34.     stage-packages:
    35.     - libnss3
    36.     - libnspr4

    If you want to apply this example to an existing project:

    • Replace source: https://github.com/electron/electron-quick-start.git with source: ..
    • Replace all instances of electron-quick-start with your project’s name.

    Step 2: Build the snap

    1. $ snapcraft
    3. <output snipped>
    4. Snapped electron-packager-hello-world_0.1_amd64.snap

    Step 4: Run the snap

    1. electron-packager-hello-world

    Snapcraft is capable of taking an existing .deb file and turning it into a .snap file. The creation of a snap is configured using a snapcraft.yaml file that describes the sources, dependencies, description, and other core building blocks.

    If you do not already have a .deb package, using electron-installer-snap might be an easier path to create snap packages. However, multiple solutions for creating Debian packages exist, including , electron-builder or .

    Step 2: Create a snapcraft.yaml

    For more information on the available configuration options, see the . Let’s look at an example:

    1. name: myApp
    2. version: '2.0.0'
    3. summary: A little description for the app.
    4. description: |
    5.  You know what? This app is amazing! It does all the things
    7. grade: stable
    8. confinement: classic
    10. parts:
    11.   slack:
    12.     plugin: dump
    13.     source: my-deb.deb
    14.     source-type: deb
    15.     after:
    16.       - desktop-gtk3
    17.     stage-packages:
    18.       - libasound2
    19.       - libnotify4
    20.       - libnspr4
    21.       - libnss3
    22.       - libpcre3
    23.       - libpulse0
    24.       - libxss1
    25.       - libxtst6
    26.   electron-launch:
    27.     plugin: dump
    28.     source: files/
    29.     prepare: |
    30.       chmod +x bin/electron-launch
    32. apps:
    33.   myApp:
    34.     command: bin/electron-launch $SNAP/usr/lib/myApp/myApp
    35.     desktop: usr/share/applications/myApp.desktop
    36.     # Correct the TMPDIR path for Chromium Framework/Electron to ensure
    37.     # libappindicator has readable resources.
    38.     environment:
    39.       TMPDIR: $XDG_RUNTIME_DIR

    Alternatively, if you’re building your snap with strict confinement, you can use the desktop-launch command:

    1. apps:
    2.   myApp:
    3.     # Correct the TMPDIR path for Chromium Framework/Electron to ensure
    4.     # libappindicator has readable resources.
    5.     command: env TMPDIR=$XDG_RUNTIME_DIR PATH=/usr/local/bin:${PATH} ${SNAP}/bin/desktop-launch $SNAP/myApp/desktop