AppImage Crafters

appimage-builder v0.7.5 files based recipes

Sun, 01 Nov 2020 20:00:00 +0000

appimage-builder v0.7.5 brings an really interesting feature: full file based recipes. Unlike traditional recipes that uses apt-get and a list of Debian packages to fulfill the dependencies of a given application the new approach uses a list of files. Yes, you read it well, all the files that should be included in the final bundle will be listed in your AppImageBuilder.yml file.

The file list is built using the outputs of strace and the linker in debug mode. Therefore all the files that were accessed by the application at runtime are add into the list.

Are you nuts? The recipe files will be huge!

Indeed they will, that’s why we will keep recommending the package based recipes. But let’s dig a bit on this idea.

This kind of recipes are focussed on those GNU/Linux distributions that doesn’t have apt-get or other package manager supported by appimage-builder. To use it just run appimage-builder --generate on a system without apt-get. It will prompt the same questions and run the application. Once it exits instead of finding which packages provide the files and libraries accessed at runtime it will proceed to list them in the AppDir > files > include section.

Once the recipe is generated you can run appimage-builder again to create the bundle. Notice that not only libraries are included but also other data files. You may want to take a look at them before considering your job done. Some of them may be icons from the system icon theme or fonts. Those can be safely excluded.

While this approach has its drawbacks it’s an important step on bringing appimage-builder to every GNU/Linux distribution. If you want to see a full recipe generated using this check out the following link

Thanks for readings, see you in the comments section.

Path mapping in AppImages

Wed, 19 Aug 2020 20:00:00 +0000

Fixed file paths in binaries have been a nightmare for AppImage creators since the format was created. The most effective solution to this issue is to modify the source code and add a way of setting those paths at runtime. But, this is not always possible.

The developer may not have access, permissions, knowledge or time to modify the source code. This is a big stop if you plan to pack an applications as an AppImage. Obscure binary patches are used to workaround this leading to complex packaging recipes.

System calls hooking to the rescue

With the help of ld-linux.so and its preload feature we can hook every system call that takes a file path as an argument and edit it to point to the bundled files. This allows running binaries containing fixed file paths without modifying them.

For its use in AppImage bundle we added this feature into the AppRun project. This is will be deployed as default entry point for AppImages created with appimage-builder 0.6.

Limitations

Preloading libraries is only possible for dynamic linked binaries, we will need something different for static linked ones. Luckily the major part of the modern software is dynamically linked.

Introducing appimage-manager

Fri, 07 Aug 2020 05:00:00 +0000

appimage-manager is a tool for managing your AppImage collection. It works quite similar to a traditional package manager but without the fuss of managing dependencies.

Installation

To install appimage-manager go to the releases page at Github, download the AppImage file into /usr/local/bin and give it execution permissions. This is basically what the command below does:

sudo wget https://github.com/AppImageCrafters/appimage-manager/releases/download/v0.1.2/app-0.1.0-x86_64.AppImage -O /usr/local/bin/app; 
sudo chmod +x /usr/local/bin/app

Usage

Looking for AppImages

AppImage binaries are usually published in the author releases page. So if you know what application do you need then go to the releases author releases page and download the binary right from there.

If the author uses Github releases you can use:

app install https://github.com/lbryio/lbry-desktop

Discovering AppImage

AppImage Index is an index of projects that publish AppImages. You can also use https://www.srevinsaju.me/get-appimage/ for a better user interface.

AppImageHub is a software store were you can find many original and third party packaged applications. It’s recommended to always download binaries from the original author to avoid malware.

AppImageHub is also integrated into the app, so in order to look for an application you can use: app search <appname>

AppImage files will be downloaded to $HOME/Applications and will be also added to your system menu on installation.

Updating AppImages

appimage-manager support delta updates using the zsync algorithm. This algorithm requires .zsync file to be published by the author. In the cases were this file is not provided a regular download will be performed. Updates work also for manually downloaded applications.

Preview

See it working in this video:

Presenting AppImage Planet

Wed, 05 Aug 2020 05:00:00 +0000

The AppImage world is bast and mysterious, therefore a map is required to ease navigation. That map is the RSS aggregator AppImage Planet.

There you will be able to find all the people and projects that gravitates around the AppImage core project. Let’s take a look to the more significant project.

NXOS

NXOS is a GNU/Linux distribution focused on AppImages. They use Ubuntu for the system foundations and AppImages for user applications. This makes a great mix because developers can focus on making their awesome desktop environment and not having to worry on providing builds for every single app.

Read more about NXOS here: https://nxos.org/

The Assassin blog

Don’t be scared, no one will assassinate you for visiting this web. It belongs to the author of linux-deploy a great tool for creating AppImages. He is also an active collaborator of the AppImage project, so you can find many more AppImage related stuff there.

For more details visit: https://assassinate-you.net/

Probono Blog

Probono is the original author of the AppImage project. He writes about AppImage, of course, and about many tech related stuff including linux usability, digital privacy, typography, and computer history.

Check his blog here: https://medium.com/@probonopd/ He is also quite active on twitter

AppImage Crafters

That’s us!

We are responsible for the development of some awesome AppImage related projects such as:

appimage-builder
appimage-manager
AppRun

Also, we are active contributors of the AppImage core.

Conclusion

That was all, finally we recommend you to visit AppImage Planet and subscribe.

Stay tuned for more :)

Welcome to AppImage Crafters!

Wed, 29 Jul 2020 20:04:50 +0000

Every large GNU/Linux distribution has its way of packaging applications. With every release some packages change their names, some are added, and some others are deleted. For an application developer, this is a nightmare as they must target not one but several moving targets.

Let’s add that once a package goes into the “Official Repositories” it’s frozen until the next releases. There is keep all the working and not-working parts of the application. This translates into many issues reports on old bugs and frustrated users for not being able to get the new and shiny version.

The user also suffers from this approach, they have to wait for their GNU/Linux distribution maintainer to update the packages. This can take days, months, years, or not happen at all.

Users may also need to have some software installed to make use of their apps. There is no problem if this software comes pre-installed but if it doesn’t it may become a very hairy task to install it.

The AppImage Crafters Initiative

We believe that developers should be able to:

create a single bundle that runs on almost every GNU/Linux distribution
control the application runtime dependencies
control the application distribution

We believe that users should be able to:

use an application packaged for GNU/Linux no matter which distro they use
get the application the day it’s released
install it without the need for installing a package manager
keep the application version they love forever*

We aim to:

Educate developers on creating packages for GNU/Linux using the AppImage format
Develop tools to ease the creation process and user experience