Ubuntu – How to examine the files inside an Appimage

appimage

From what I've read, an Appimage file is a compressed application along with all of its resources, and when run it is auto-mounted and then executed.

I want to inspect the resources and files inside an Appimage file I've downloaded, without actually running the Appimage.

How can I do this?

Best Answer

Without changing their extension:

As such, an appimage can be mounted or extracted. That is:

To mount them:

my.AppImage --appimage-mount
The AppImage is unmounted when the application called in the example is interrupted (e.g., by pressing Ctrl+C, closing the terminal etc.).

Note: This is only available for type 2 AppImages. Type 1 AppImages do not provide any self-mounting mechanism. To mount type 1 AppImages, use
mount -o loop

To extract them:

An alternative to mounting the AppImages is to extract their contents. This allows for modifying the contents. The resulting directory is a valid AppDir, and users can create AppImages from them again using appimagetool.

Analog to mounting AppImages, there is a simple commandline switch to extract the contents of type 2 AppImages without external tools. Just call the AppImage with the parameter --appimage-extract. This will cause the runtime to create a new directory called squashfs-root, containing the contents of the AppImage’s AppDir specification.

Type 1 AppImages require the deprecated tool AppImageExtract to extract the contents of an AppImage. It’s very limited functionality wise, and requires a GUI to run. It creates a new directory in the user’s desktop directory.

There is an answer on superuser on how to extract files from an AppImage.

Looking at my appimages I see that only some of them can be mounted with gnome-disk-image-mounter. Also here.

Changing their extension:

Not all appimages have exactly the same structure, but all are archives. Wikipedia says: "An AppImage of version 1.0 is an ISO 9660 Rock Ridge file (which can be optionally zisofs compressed) containing a minimal AppDir and a tiny runtime. (Version 2 may use other file system image formats like SquashFS)".

So, it can be extracted. In this way you can examine the files.

Simply changing the extension from AppImage to an archive extension that my file-roller archive manager can read (I tested with zip, 7z, etc) and double-clicking the file reveals the contents in file-roller:

They can also be extracted, of course. The "extract" file manager context menu action works too in order to extract the archive. (As said in comment, the unzip command reports an error with a file renamed with a zip extension, so renaming to zip is not the proper choice in itself, but it works with archive managers like file-roller.)

Basic Information

Regarding installation

I am quoting the appImage project page here:

AppImages can be downloaded and run without installation or the need for root rights.

Making it executable

You can make the appImage executable as follows:

chmod a+x exampleName.AppImage

Executing it

You can execute an appImage as follows:

./exampleName.AppImage

Additional Information

About appImage

You can find some general informations about appImage here.

I am quoting the appImage project page here:

The key idea of the AppImage format is one app = one file. Every AppImage contains an app and all the files the app needs to run. In other words, each AppImage has no dependencies other than what is included in the targeted base operating system(s).

Wikipedia adds

AppImage (and the predecessors klik and portablelinuxapps) do not install software in the traditional sense (i.e., it do not put files all over the place in the system).

It use one file per application. Each one is self-contained: it includes all libraries the application depends on and that are not part of the base system. In this regard, it is similar to "application virtualization". One can use a AppImage file even if they are not a superuser, or they are using a live CD. AppImage files are often simpler than compiling and installing an application, as no installation actually took place. The AppImage file is a compressed image which is temporarily mounted to allow access to the program, but not having to extract the program or modify the underlying system.

The README.md of the AppImageKit-project offers a lot additional informations like Use cases, the problem space and objectives.

Use Cases

As a user, I want to go to an upstream download page, download an application from the original author, and run it on my Linux desktop system just like I would do with a Windows or Mac application.
As a tester, I want to be able to get the latest bleeding-edge version of an application from a continuous build server and test it on my system, without needing to compile and without having to worry that I might mess up my system.
As an application author or ISV, I want to provide packages for Linux desktop systems just as I do for Windows and OS X, without the need to get it 'into' a distribution and without having to build for gazillions of different distributions.

Objectives

Be Simple.

AppImage is intended to be a very simple format that is easy to understand, create, and manage.
Maintain binary compatibility.

AppImage is a format for binary software distribution. Software packaged as AppImage is intended to be as binary-compatible as possible with as many systems as possible. The need for (re-)compilation of software should be greatly reduced.
Be distribution-agnostic.

An AppImage should run on all base operating systems (distributions) that it was created for (and later versions). For example, you could target Ubuntu 9.10, openSUSE 11.2, and Fedora 13 (and later versions) at the same time, without having to create and maintain separate packages for each target system.
Remove the need for installation.

AppImages contain the app in a format that allows it to run directly from the archive, without having to be installed first. This is comparable to a Live CD. Before Live CDs, operating systems had to be installed first before they could be used.
Keep apps compressed all the time.

Since the application remains packaged all the time, it is never uncompressed on the hard disk. The computer uncompresses the application on-the-fly while accessing it. Since decompression is faster than reading from hard disk on most systems, this has a speed advantage in addition to saving space. Also, the time needed for installation is entirely removed.
Allow to put apps anywhere.

AppImages are "relocatable", thus allowing the user to store and execute them from any location (including CD-ROMs, DVDs, removable disks, USB sticks).
Make applications read-only.

Since AppImages are read-only by design, the user can be reasonably sure that an app does not modify itself during operation.
Do not require recompilation.

AppImages must be possible to create from already-existing binaries, without the need for recompilation. This greatly speeds up the AppImage creation process, since no compiler has to be involved. This also allows third parties to package closed-source applications as AppImages. (Nevertheless, it can be beneficial for upstream application developers to build from source specifically for the purpose of generating an AppImage.)
Keep base operating system untouched.

Since AppImages are intended to run on plain systems that have not been specially prepared by an administrator, AppImages may not require any unusual preparation of the base operating system. Hence, they cannot rely on special kernel patches, kernel modules, or any applications that do not come with the targeted distributions by default.
Do not require root.

Since AppImages are intended to be run by end users, they should not reqiure an administrative account (root) to be installed or used. They may, however, be installed by an administrator (e.g., in multi-user scenarios) if so desired.

AppImage – How to Associate a File Type with an AppImage

Got this working on Mint 18.1 Cinnamon.

The .appimage of Krita 3.1.2 didn't add any file associations, so I created a file named krita.desktop, and put the following inside:

[Desktop Entry]
Encoding=UTF-8
Name=Krita
Comment=Krita, An open source painting and drawing application.
Exec=[path to .appimage] %F
Type=Application
Icon=[path to icon]
Categories=Graphics; 
MimeType=image/krita;

I made that file executable, then copied it to /usr/share/applications.

Next I opened ~/.config/mimeapps.list, and appended:

image/krita=krita.desktop;

under the section [Added Associations]

Finally I right clicked a .kra file and chose Krita as the default app under Open With.

Hope that helps someone out.