tarinstall

An alternative to AppImages, flatpacks and snaps to let the user install an application as a single executable file when static linking is not possible

tarinstall does not include any external files as such it does not include any man pages, example configuration files, etc. All of those have to be installed separately.

Graph

An application packaged as a tarinstall is made as such

----- Decompressor -----
|                      |
|                      |
|------- Loader -------|
|                      |
|                      |
|----- App Tarball ----|
|                      |
| bin/                 |
| lib/                 |
| man/                 |
| ext/                 |
| env                  |
| checksum             |
| id                   |
|                      |
------------------------

Decompressor: It decompresses the archive and then runs the loader

Loader: It reads the env file in the tarball and enumerates the lib/ directory to loads all the necessary libraries and sets the correct environment before executing the correct binary in the bin/ directory.

This may include changing the RPATH section of the binaries inside bin/

Files and folders

lib/: contains the required shared libraries
bin/: will substitute PATH and contains all the binaries that the application requires, such as POSIX utilities, a python interpreter, etc. As well as the application's binaries
man/: contains the manual pages for the biaries in app
ext/: contains all other files, such as example configurations, etc.
env: lists the cutom environment variables to start the application
checksum: contains the checksum of the application
id: contains the application id

Utilities

User

tarman: get manual pages from a tarinstall application
tarext: extract the files in ext/
tarup: tries to find a newer version of the application using it's id and checksum and updates it using a differential algorithm

Devs

tarpack: package a tarinstall application

TODO

Find a way to include external files
Include a package manager
- App binary diffs for incremental upgrades
Automated tarinstall packaging for developers
- Package manager for shared objects (libraries)
- Standardized way to define dependencies

Advantages

Allows for application compression
Simpler and configyred in plaintext
Does not include any external dependencies other than optional ones
It can be used alongside other package managers and package formats

Compression is optional, it can be used to produce smaller packages but also increments latency wich may be unwanted.

Configuration

When the application is started the decompressor extracts the directory structure into a temporary directory in the filesystem in order to start it. This directory can be configured trough the XDG_CACHE_HOME enviroment variable and if not set it will default to /tmp/ti-<appname>, to ensure optimal performance the XDG_CACHE_HOME directory should be mounted on RAM, that said if mounted on permanent storage altough the start times will be worse, the files will only be overritten if the checksum changes so to not require the extraction everytime.

How it works

On executing the tarinstall the decompressor is executed which:
1. If the checksum matches the one in the destination directory it skips the extraction
2. Else it extracts the content of the tar application in the destination directory
The decompressor then executes the loader inside the destination directory which:
1. It sets environment according to the env file
2. It overrides the loader libraries with the contents of lib/
3. it enters the bin/ directory and executes the binary named argv[0] with all the passed arguments

Upon packaging the tarinstall all the executables in the bin/ directory are modified so that their RPATH points to lib/.

Examples

Simple example, one binary in `bin/`

/home/anon/.local/bin/
	foo.ti

/bin/
	foo -> /home/anon/.local/bin/foo.ti

executing foo -h starts bin/foo -h inside foo.ti
trying to execute foo.ti directly results in the execution of the only binary in bin/

More complex example, multiple biaries inside `bin/`

/home/anon/.local/bin/
	foo.ti

/bin/
	foo -> /home/anon/.local/bin/foo.ti
	bar -> /home/anon/.local/bin/foo.ti
	baz -> /home/anon/.local/bin/foo.ti

executing foo -v starts bin/foo -v inside foo.ti
executing bar -h starts bin/bar -h inside foo.ti
executing baz -o file starts bin/baz -o file inside foo.ti
executing foo.ti directly results in the execution of the binary named foo inside bin/, if it doesn't exist

Language

POSIX shell (tools)
C (loader and decompressor)

4.7 KiB Raw Blame History