With support for many languages out of the box, getting started with Snapcraft can be as simple as installing and running snapcraft.
To develop snaps you have Linux support via Snaps, macOS support via homebrew and Windows support via WSL. With whichever OS you’re comfortable with, you can develop and publish snaps.
If you already have an Electron app for Windows and macOS, you only need to make minimal changes to your package.json to build a snap that’s ready to release. Get started with an Electron app.
In just a few steps, you’ll have an example C/C++ app in the Snap Store.
Python
Pre-built apps
C/C++
Go
Java
Node.js
Electron
Flutter
Ruby
Rust
MOOS
ROS
ROS 2
name: dosbox
version: "0.74-svn"
summary: DOS emulator
description: |
DOSBox is a x86 emulator with Tandy/Hercules/ […]
base: core18
confinement: devmode
parts:
dosbox:
plugin: autotools
source-type: tar
source: http://source.dosbox.com/dosboxsvn.tgz
build-packages:
- g++
- make
- libsdl1.2-dev
[…]
- libasound2-dev
stage-packages:
- freeglut3
- libsdl-sound1.2
- libsdl-net1.2
[…]
- zlib1g
apps:
dosbox:
command: dosbox
environment:
"LD_LIBRARY_PATH": "$SNAP/usr/lib/$SNAPCRAFT_ARCH_TRIPLET/pulseaudio"
"DISABLE_WAYLAND": "1"
In just a few steps, you’ll have an example Electron app in the Snap Store.
{
"name": "electron-quick-start",
"version": "1.0.0",
"description": "A minimal Electron application",
"main": "main.js",
"scripts": {
"start": "electron .",
"dist": "build --linux snap"
},
"repository": "https://github.com/electron/electron-quick-start",
"keywords": [
"Electron",
"quick",
"start",
"tutorial",
"demo"
],
"author": "GitHub",
"license": "CC0-1.0",
"devDependencies": {
"electron": "^11.2.1",
"electron-builder": "^22.9.1"
}
}
In just a few steps, you’ll have an example Flutter app in the Snap Store.
name: my-flutter-app
version: '1.0'
summary: An example Flutter snap
description: |
An example showing how Flutter programs can be packaged as snaps.
base: core22
confinement: strict
grade: stable
apps:
my-flutter-app:
command: my_flutter_app
extensions: [gnome]
parts:
my-flutter-app:
source: .
plugin: flutter
flutter-target: lib/main.dart
Programming in Go makes it easy to create a zip of your app that runs across Linux, without dependencies. However, end user discovery and update management remain a challenge. Snaps fill this gap, letting you distribute a Go app in an app store experience for end users.
In just a few steps, you’ll have an example Go app in the Snap Store.
name: woke
summary: Detect non-inclusive language in your source code
description: |
Creating an inclusive work environment is imperative […]
version: git
grade: stable
base: core20
confinement: devmode
apps:
woke:
command: bin/woke
plugs:
- home
parts:
woke:
plugin: go
source-type: git
source: https://github.com/get-woke/woke
Distributing a Java application for Linux and reaching the widest possible audience is complicated. Typically, the user has to make sure the JRE/SDK version and their environment are configured correctly. When a Linux distribution changes the delivered JRE, this can be problematic for applications. Snapcraft ensures the correct JRE is shipped alongside the application at all times.
In just a few steps, you’ll have an example Java app in the Snap Store.
name: freeplane
title: Freeplane
version: '1.8.1'
summary: A free tool to structure and organise your information […]
description: |
Freeplane is a free and open source software […]
base: core18
confinement: strict
apps:
freeplane:
extensions:
- gnome-3-28
command: freeplane-$SNAPCRAFT_PROJECT_VERSION/freeplane.sh
environment:
JAVA_HOME: $SNAP/usr/lib/jvm/java-11-openjdk-amd64
PATH: $JAVA_HOME/jre/bin:$PATH
plugs:
- home
- network
- cups-control
parts:
freeplane:
plugin: gradle
source: https://github.com/freeplane/freeplane.git
source-tag: release-$SNAPCRAFT_PROJECT_VERSION
gradle-version: '5.1.1'
gradle-output-dir: BIN
gradle-options: [binZip, -xtest, -xcreateGitTag]
override-build: |
snapcraftctl build
unzip -o DIST/freeplane_bin-*.zip -d $SNAPCRAFT_PART_INSTALL/
build-packages:
- unzip
In just a few steps, you’ll have an example MOOS app in the Snap Store.
name: test-moos
version: '0.1'
summary: MOOS Example
description: |
This example includes MOOSDB, the main […]
base: core18
confinement: devmode
parts:
test-moos:
source: https://github.com/themoos/core-moos/archive/v10.4.0.tar.gz
plugin: cmake
build-packages: [g++]
apps:
test-moos:
command: bin/MOOSDB
With npm you can distribute apps to other developers, but it’s not tailored to end users. Snaps let you distribute your Node app in an app store experience.
In just a few steps, you’ll have an example Node.js app in the Snap Store.
name: wethr
version: git
summary: Command line weather tool.
description: |
Get current weather:-
$ wethr
Get current weather in metric units
$ wethr --metric
Get current weather in imperial units
$ wethr --imperial
confinement: strict
base: core20
apps:
wethr:
command: wethr
parts:
wethr:
plugin: npm
npm-node-version: 14.16.1
source: .
Distributing the Linux build of your app as a zip lets you provide one download and set of instructions for all of Linux. However, end user discovery and update management remain a challenge. Snaps fill this gap, letting you wrap your existing Linux build in an app store experience for end users.
In just a few steps, you’ll have an example pre-built app in the Snap Store.
name: test-geekbench4
version: 4.2.0
summary: Cross-Platform Benchmark
description: |
Geekbench 4 measures your system's power […]
confinement: devmode
base: core18
parts:
test-geekbench4:
plugin: dump
source: http://cdn.geekbench.com/Geekbench-$SNAPCRAFT_PROJECT_VERSION-Linux.tar.gz
apps:
test-geekbench4:
command: geekbench4
With PyPI you can distribute apps to other developers, but it’s not tailored to end users. Virtualenv lets you install an app’s dependencies in isolation, but it’s not automatically used for installs from PyPI. Snaps let you distribute a dependency-isolated Python app in an app store experience for end users.
In just a few steps, you’ll have an example Python app in the Snap Store.
name: liquidctl
summary: a status and control utility to for power, cooling and LED components
description: |
liquidctl is a command-line tool to monitor and control […]
version: test
base: core22
confinement: strict
parts:
liquidctl:
plugin: python
source: .
stage-packages:
- python3-usb
apps:
liquidctl:
command: bin/liquidctl
plugs:
- raw-usb
- hardware-observe
In just a few steps, you’ll have an example ROS app in the Snap Store.
name: ros-talker-listener
version: '0.1'
summary: ROS Talker/Listener Example
description: |
This example launches a ROS talker and listener.
confinement: devmode
base: core20
parts:
ros-tutorials:
plugin: catkin
source: https://github.com/ros/ros_tutorials.git
source-branch: noetic-devel
catkin-packages: [roscpp_tutorials]
stage-packages:
- ros-noetic-roslaunch
apps:
ros-talker-listener:
command: opt/ros/noetic/bin/roslaunch roscpp_tutorials talker_listener.launch
extensions: [ros1-noetic]
In just a few steps, you’ll have an example ROS2 app in the Snap Store.
name: ros2-talker-listener
version: '0.1'
summary: ROS2 Talker/Listener Example
description: |
This example launches a ROS2 talker and listener.
confinement: devmode
base: core22
parts:
ros-demos:
plugin: colcon
source: https://github.com/ros2/demos.git
source-branch: humble
source-subdir: demo_nodes_cpp
stage-packages: [ros-humble-ros2launch]
apps:
ros2-talker-listener:
command: opt/ros/humble/bin/ros2 launch demo_nodes_cpp talker_listener.launch.py
extensions: [ros2-humble]
Linux install instructions for Ruby applications often get complicated. To prevent modules from different Ruby applications clashing with each other, developer tools like rvm or rbenv must be used. With snapcraft, it’s one command to produce a bundle that works anywhere.
In just a few steps, you’ll have an example Ruby app in the Snap Store.
name: test-mdl
version: "0.5.0"
summary: Markdown lint tool
description: |
Style checker/lint tool for markdown files
confinement: devmode
base: core18
parts:
test-mdl:
source: .
plugin: ruby
gems:
- rake
- bundler
override-build: |
snapcraftctl build
rake install
build-packages:
- git
apps:
test-mdl:
command: bin/mdl
You can distribute your apps across Linux using a musl-enabled version of Rust, with all the dependencies satisfied. However, end user discovery and update management remain a challenge. Snaps fill this gap, letting you distribute a Rust app in an app store experience for end users.
In just a few steps, you’ll have an example Rust app in the Snap Store.
name: test-xsv
version: git
summary: A fast CSV command line toolkit written in Rust
description: |
xsv is a command line program for indexing […]
base: core18
confinement: devmode
parts:
test-xsv:
plugin: rust
source: .
apps:
test-xsv:
command: bin/xsv
Building your snap locally limits you to your development architecture. Let us do the heavy lifting and build it for multiple architectures including AMD64, i386, ARM and ARM64.
Behind the scenes, snaps are built by Launchpad the tool used to build all Ubuntu images. When your builds are ready, you can release them together, as a set, ensuring everyone on all architectures receive the same version at the same time.
Find out moreIf you’re already comfortable with a third party CI workflow Snaps are supported there too. You don’t need to change or modify anything if you don’t want to.
Already have a build farm, for all the architectures you need? The Publisher Gateway APIs let you automate everything from uploading and releasing a Snap, to adding screenshots to display in the Storefront.
