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
You can execute an appImage as follows:
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).
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
README.md of the AppImageKit-project offers a lot additional informations like Use cases, the problem space and objectives.
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.
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.
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
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.