Packaging made simple

Distributing and installing modern web applications is a pain.
We automatically package them so you don't have to.

  • Push
    Push new code to GitHub
  • Package
    Packages get built automatically
  • Deploy
    Deploy packages on your servers using APT, YUM, ZYPPER

Build and operate your apps the Heroku way, on your own servers

Get Debian, Ubuntu, CentOS/RHEL, and SuSE Linux Enterprise Server packages built on demand, including a powerful CLI to scale, run, inspect, and configure your applications, on your own servers.

Scale your processes up and down:

my-app scale web=1 worker=2

Run arbitrary processes in the context of your application:

my-app run ruby -v
my-app run rake db:migrate
my-app run console

Inspect your application's logs:

my-app logs

Set configuration variables for your application:

my-app config:set DATABASE_URL=...

Start/Stop/Restart the application, in a distribution-independent way:

my-app start|stop|restart [web|worker]

Advantages of a package-based installation

  Install and update in one command

It's a fact: modern web applications are a pain to install. With packages, no more complicated install intructions, and no need for heavy-duty configuration management tools to install an app. Packages get built and hosted in your own package repository, so that you (or your clients/users) can just apt-get install (or yum install) the application and be done with it.

  Based on Heroku buildpacks

Heroku buildpacks are a standard for web application deployment. That means you're not entering some dark world, but you just use our (slightly) customized version of the Heroku buildpacks you've known and loved for a long time!


Everything is precompiled, which makes for a really fast installation procedure. On any number of servers.


Packages only embed what's absolutely required to make your app work. This includes the language runtime of your app (Ruby, NodeJS) and its dependencies (gems, modules, etc.). For the rest, packages rely on the system libraries of the distribution as much as possible.

  Support for multiple delivery channels

Get packages built for some or all of your branches, so that you can keep maintaining multiple delivery channels of your software in parallel (e.g. staging, production, release/7.1).

  Secure package repository

All your packages are published to a package repository dedicated to your application, complete with authentication tokens if you want to restrict access. Plus your repository metadata is signed using GPG, and only available through HTTPS.


What if you could know how many times your packages have been downloaded? And from where? And how many servers are still polling for updates? We surface all those informations on a map so that you can see at a glance your installation base.

Easy installation, for all major Linux distributions

  1. Fetch the public GPG key and the repository details (e.g. for RHEL/CentOS):
    $ sudo wget -O /etc/yum.repos.d/openproject.repo \
  2. Install
    $ sudo yum install openproject

OpenSource projects

  • OpenProject (ruby, nodejs) - Web based project management built using Ruby on Rails.
  • Zammad (ruby) - Web based open source helpdesk/customer support system.
  • Ekylibre (ruby) - Connecting farms to the world.
  • Gogs (go) - Go Git Service
  • Discourse (ruby) - A platform for community discussion.
  • GitLab (ruby) - GitLab is version control for your server.
  • Joola (nodejs) - Data middleware for building custom analytics applications
  • docker-gc (go) - Docker garbage collection of containers and images

A few notes from happy users

Prior to using we experimented with many options. The obvious starting point was a combination of Chef or Puppet with Capistrano. Chef/Puppet get it to the point where Capistrano can deploy the application, but that still leaves a lot to be desired. It's also not in any way "simple". As a former professional systems administrator, I'm very sympathetic to the needs of the Ops Team. Anything we as developers can do to lighten their load just means better uptime for us.
Ben Klang, Principal/Technology Strategist, Mojo Lingo makes it extremely simple to distribute our software packages to clients on a variety of platforms. It's easy to use, and their support is excellent.
Michael Sive, Software Engineer, Bliss
We've used to publish Joola as packages for Debian, Ubuntu and CentOS and we wanted to share our reasoning behind offering Joola as a packaged downloadable and our experience with Spoiler alert: it took us less than 10 minutes, worked on the first time and was overall awesome!

I never even dreamed that it can be fun to build debian packages :)

Philipp Tessenow, early maintainer of the OpenProject package.

We'd love to take you on board

Start packaging with our free account

14-days free trial. Free for OpenSource projects.

How it works

Sign in with your GitHub account, enable a repository for packaging, then push new code:

$ git commit -am "new feature" ; git push

Watch your package being built, including the exact dependencies and language runtime you specified.

Here is how you install your packaged app

  1. Fetch the public GPG key used to sign your repository release files:
    $ apt-key adv --keyserver \
        --recv-keys 79A43FE48E564FD7A215A736E998402EB366273F
  2. Fetch repository details:
    $ wget -O /etc/apt/sources.list.d/my-org-my-app.list \
  3. Install and run !
    $ apt-get update && apt-get install my-app
    $ my-app scale web=1 worker=2
    service my-app start/running
  • That's it, you can now query the web process (port is configurable):

    $ curl localhost:6000
    Hello world!


Today, when the time comes to deploy a web application, the choice is either to use a PaaS (over which you have no control), or spend time configuring various tools such as Puppet, Capistrano, Chef, Fabric, Docker (the list goes on) to simplify the process of releasing new code to your own servers.

Some of these tools are excellent for configuring your infrastructure, but are they really needed to handle the nitty gritty details of what essentially amounts to: install those dependencies, copy those files here, start a daemon and ensure it runs smoothly over time?

Wouldn't it be great if you could have a native (DEB or RPM) package that automatically does this for you? Most of the applications present on your servers are installable that way, and I'd bet that you quite liked the feeling of an apt-get install stuff the first time you tried it.


Look at what you no longer have to do!

  • Create a new (unprivileged) deploy user
  • install the right version of Ruby (from source, rbenv, rvm, or third-party packages, since your OS most likely does not provide the version you want)
  • err, I mean, apt-get install a slew of dependencies, then install the right version of Ruby
  • upload the latest code to the server (bonus points for not leaving sensitive github credentials around)
  • install dependencies with bundler
  • precomp... err, install a javascript runtime, then precompile Rails assets
  • more instructions usually follow, involving setting up init scripts, log rotation, running migrations, setting up cron files, etc.
  • ... truncated for brevity, I hope you get the point.

It's time to (re)discover the power of software packages

Packager makes it a breeze to package your Rails, NodeJS, or Go applications for all the major Linux distributions, anytime you push to your Github repository.

Step 1: Build packages as part of your development workflow integrates with Github so that packages get built anytime you push new code.

All it takes to start building packages for your app is to sign in using your Github account, enable an application on, and push a .pkgr.yml file at the root of your project repository.

This file will declare for which target distributions you want to build packages, the buildpack to use, and any additional configuration such as cron files, pre|postinstall files, etc.

# .pkgr.yml
      - postgresql
      - postgresql-server
  - packaging/crons/backup-database
  - packaging/crons/clean-stuff
postinstall: packaging/hooks/postinstall

Step 2: Serve packages from your own APT / YUM / ZYPPER repository

Icing on the cake: every package built for your app will automatically be added to your own APT / YUM / ZYPPER package repository.

This is the final step that allows a seamless delivery to your users, using the tools they use everyday to manage their Linux distribution. A package repository hosts DEB or RPM packages, with a few additional security features such as:

  • GPG signing of the metatada files
  • private repository support using access tokens
  • encrypted file delivery using HTTPS end-to-end

Step 3: Install and relax while your package sets everything for you

Now that your package is built and available from a package repository, you or your clients can just use the distribution's package manager (APT, YUM, ZYPPER) to install it, using the usual commands apt-get install, yum install, or zypper install.

  • System dependencies get automatically installed.
  • For interpreted languages, your package ships with your own version of Ruby/NodeJS (the one you specified in your Gemfile or package.json file), so that it does not conflict with any other version you installed system-wide.
  • Your package ships with the exact application dependencies you specified in your Gemfile, package.json, or xx file.
  • Log files available in /var/log/my-app, with log rotation enabled, so that you never fill up your disk with logs again.
  • Cron files are automatically installed in the right place.
  • Init scripts (sysvinit, upstart, systemd) are automatically generated for the distribution, so that you can easily start/stop/restart your application, and get it launched when your system boots.
  • A powerful CLI tool ships with all packages, allowing you to set configuration variables, scale processes, run arbitrary commands in the context of your application, view logs, etc.
    • my-app config:set DATABASE_URL=postgres://user:pass@host:port/dbname
    • my-app scale web=1 worker=2 other_daemon=1