diff --git a/Makefile b/Makefile
index d4d2ae3..80efb8a 100644
--- a/Makefile
+++ b/Makefile
@@ -7,7 +7,7 @@ all:
 	  @echo "Run 'make uninstall' for uninstallation."
 
 install:
-		install -Dm755 gpgit.py $(DESTDIR)$(PREFIX)/bin/gpgit
+		install -Dm755 gpgit.sh $(DESTDIR)$(PREFIX)/bin/gpgit
 		install -Dm644 Readme.md $(DESTDIR)$(PREFIX)/share/doc/gpgit/Readme.md
 
 uninstall:
diff --git a/Readme.md b/Readme.md
index 5e575f1..8a6a153 100644
--- a/Readme.md
+++ b/Readme.md
@@ -6,16 +6,16 @@
 As we all know, today more than ever before, it is crucial to be able to trust our computing environments. One of the main difficulties that package maintainers of GNU/Linux distributions face, is the difficulty to verify the authenticity and the integrity of the source code. With GPG signatures it is possible for packagers to verify source code releases quickly and easily.
 
 #### Overview of the required tasks:
-* Create and/or use a **[4096-bit RSA keypair][1]** for the file signing
+* Create and/or use a **[4096-bit RSA/Ed25519 ECC keypair][1]** for the file signing
 * Use a **[strong, unique, secret passphrase][2]** for the key
 * Upload the public key to a **[key server][3]** and **[publish the full fingerprint][4]**
 * **[Sign][5]** every new Git **[commit][6]** and **[tag][7]**
-* Create **[signed][8], [compressed][9]** (xz --best) release **archives**
-* Upload a **[strong message digest][10]** (sha512) of the archive
+* Create **[signed][8], [compressed release archives][9]**
+* Upload a **[strong message digest][10]** of the archive
 * Configure **[HTTPS][11]** for your download server
 
 ### GPGit
-[GPGit][12] is meant to bring GPG to the masses. It is not only a Python script that automates the process of [creating new signed Git releases with GPG][13], but also a [quick-start-guide][14] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][15] for uploading.
+[GPGit][12] is meant to bring GPG to the masses. It is not only a shell script that automates the process of [creating new signed Git releases with GPG][13], but also includes a [quick-start-guide][14] for learning how to use GPG. GPGit integrates perfectly with the [Github Release API][15] for uploading.
 
 The security status of GNU/Linux projects will be tracked in the [Linux Security Database][16]. If you have any further questions, do not hesitate to [contact me][17] personally. Thanks for your help in making GNU/Linux projects more secure by using GPG signatures.
 
@@ -37,7 +37,7 @@ The security status of GNU/Linux projects will be tracked in the [Linux Security
 [16]: https://github.com/NicoHood/LSD
 [17]: http://contact.nicohood.de
 
-## Index
+# Index
 * [Introduction](#introduction)
 * [GPGit Documentation](#gpgit-documentation)
 * [GPG Quick Start Guide](#gpg-quick-start-guide)
@@ -45,103 +45,80 @@ The security status of GNU/Linux projects will be tracked in the [Linux Security
 # GPGit Documentation
 
 ## Installation
-### ArchLinux
-You can install GPGit from [AUR](https://aur.archlinux.org/packages/gpgit/). Make sure to [build in a clean chroot](https://wiki.archlinux.org/index.php/DeveloperWiki:Building_in_a_Clean_Chroot). Please give the package a vote so I can move it to the official ArchLinux [community] repository for even simpler installation.
 
-### Ubuntu/Debian/Other
-GPGit dependencies can be easily installed via [pip](https://pypi.python.org/pypi/pip).
+### Distribution Packages
+* [Arch Linux (AUR)](https://aur.archlinux.org/packages/gpgit/)
 
+### Manual Installation
 ```bash
-# Install dependencies
-sudo apt-get install python3 python3-pip gnupg2 git
-VERSION=2.0.7
+# Install dependencies and optional dependencies
+sudo apt-get install bash gnupg2 git tar xz-utils coreutils gawk grep sed
+sudo apt-get install gzip bzip lzip file jq curl
 
 # Download and verify source
-wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz
-wget https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz.asc
+VERSION=1.3.0
+wget "https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz"
+wget "https://github.com/NicoHood/gpgit/releases/download/${VERSION}/gpgit-${VERSION}.tar.xz.asc"
 gpg2 --keyserver hkps://pgp.mit.edu --recv-keys 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161
-gpg2 --verify gpgit-${VERSION}.tar.xz.asc gpgit-${VERSION}.tar.xz
+gpg2 --verify "gpgit-${VERSION}.tar.xz.asc" "gpgit-${VERSION}.tar.xz"
 
-# Extract and install dependencies
-tar -xf gpgit-${VERSION}.tar.xz
-cd gpgit-${VERSION}
-pip3 install --user -r requirements.txt
-
-# Install  and run GPGit
-sudo cp gpgit.py /usr/local/bin/gpgit
+# Extract, install and run GPGit
+tar -xf "gpgit-${VERSION}.tar.xz"
+sudo make -C "gpgit-${VERSION}" PREFIX=/usr/local install
 gpgit --help
 ```
 
 ## Script Usage
-The script guides you through all 5 steps of the [GPG quick start guide](#gpg-quick-start-guide). **By default no extra arguments beside the tag are required.** Follow the instructions and you are good to go.
+The script guides you through all 5 steps of the [GPG quick start guide](#gpg-quick-start-guide). Run GPGit with the tag name as parameter. All other options will get auto detected. When running the script for the first time GPGit runs in interactive (`-i`) mode and guide you through all steps of secure source code signing.
 
+### Sample Usage
 ![screenshot](img/screenshot.png)
 
-### Parameters
-
-#### -h, --help
-Show help message and exit.
-
-#### -v, --version
-Show program's version and exit.
-
-#### tag
-Tagname of the release. E.g. `1.0.0` or `20170521` with `$(date +%Y%m%d)`.
-
-#### -m <msg>, --message <msg>
-Use the given <msg> as the commit message.
-
-#### -o <path>, --output <path>
-Output path of the archive, signature and message digest. You can also set this option via configuration.
-
-#### -g <path>, --git-dir <path>
-Path to the Git project.
-
-#### -n, --no-github
-Disable Github API functionality. Github releases need to be created manually and release assets need to be uploaded manually. GPGit will not prompt for a Github token anymore.
-
-#### -p, --prerelease
-Flag as Github prerelease.
-
-### Configuration
-Additional configuration can be made via [git config](https://git-scm.com/docs/git-config). Example usage:
-
-```bash
-git config --global gpgit.token <token>
-git config --global gpgit.output ~/gpgit
-git config --local gpgit.compression gzip
+### Parameters and Configuration
+```
+$ gpgit --help
+Usage: gpgit [options] <tag>
+
+GPGit 1.3.0 https://github.com/NicoHood/gpgit
+A shell script that automates the process of signing Git sources via GPG.
+
+Mandatory arguments:
+  <tag>                    The name of the tag to create.
+
+Optional arguments:
+  -h, --help               Show this help message and exit.
+  -m, --message <msg>      Use the given <msg> as the commit message.
+                           If multiple -m options are given, their values are
+                           concatenated as separate paragraphs.
+  -C, --directory <path>   Run as if GPGit was started in <path> instead of the
+                           current working directory.
+  -S, --signingkey <keyid> Use the given GPG key.
+  -o, --output <path>      Safe all release assets to the specified <path>.
+  -p, --pre-release        Flag as Github pre-release.
+  -n, --no-github          Disable Github API functionallity.
+  -i, --interactive        Run in interactive mode, step-by-step.
+      --<option>           Temporary set a 'gpgit.<option>' from config below.
+
+Examples:
+  gpgit 1.0.0
+  gpgit -p -m "First alpha release." 0.1.0 --hash "sha256 sha512"
+  gpgit -C git/myproject/ -o /tmp/gpgit -n -m "Internal test release." 0.0.1
+
+Configuration options:
+  gpgit.signingkey <keyid>, user.signingkey <keyid>
+  gpgit.output <path>
+  gpgit.token <token>
+  gpgit.compression <xz | gzip | bzip2 | lzip | zip>
+  gpgit.hash <sha512 | sha384 | sha256 | sha1 | md5>
+  gpgit.keyserver <keyserver>
+  gpgit.githubrepo <username/projectname>
+  gpgit.project <projectname>
+
+Examples:
+  git config --global gpgit.output ~/gpgit
+  git config --local user.signingkey 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161
+  git config --local compression "xz zip"
 ```
-
-#### user.signingkey
-Full GPG fingerprint to use for signing/verifying.
-
-#### gpgit.output
-Output path of the archive, signature and message digest. You can also set this option via parameter.
-
-#### gpgit.compression
-Archive compression option. Chose between "gzip,xz,bzip2,lzip". Default: "xz"
-
-#### gpgit.sha
-Message digest algorithm. chose between "sha256,sha384,sha512". Default: "sha512"
-
-#### gpgit.keyserver
-Keyserver to use for GPG key check. Automatically set to "skip" after the first check was successfull. Default: "hkps://pgp.mit.edu"
-
-#### gpgit.github
-Enable or disable Github functionality with "true|false". Default: "true" (enabled)
-
-#### gpgit.user
-Username used for github uploading.
-
-#### gpgit.project
-Project name used for github uploading and archive naming.
-
-#### gpgit.armor
-Use ascii armored output of GPG (.asc instead of .sig) with "true|false". Default: "true" (armored output).
-
-#### gpgit.token
-Specify the Github token for Github API release uploading.
-
 
 # GPG Quick Start Guide
 GPGit guides you through 5 simple steps to get your software project ready with GPG signatures. Further details can be found below.
@@ -177,36 +154,30 @@ Here are a few examples how to keep a passphrase strong but easy to remember:
 * [PasswordCard](https://www.passwordcard.org/en)
 
 ### 1.2 Key generation
-If you don't have a GPG key yet, create a new one first. You can use RSA (4096 bits) or ECC (Curve 25519) for a strong key. The latter one does currently not work with Github. You want to stay with RSA for now.
+If you don't have a GPG key yet, create a new one first. You can use RSA (4096 bits) or ECC (Curve 25519) for a strong key. GPG offers you the option to use the most future-proof key algorithm available. Use the most recent version gnupg2, not gnupg1!
 
-**Make sure that your secret key is stored somewhere safe and use a unique strong password.**
+Ed25519 ECC GPG keys are currently [not supported by Github](https://help.github.com/articles/generating-a-new-gpg-key/#supported-gpg-key-algorithms). To generate an ECC key use `future-default` instead of `rsa4096` as parameter.
 
-Crucial key generation settings:
-* (1) RSA and RSA
-* 4096 bit key size
-* 4096 bit subkey size
-* Valid for 1 year (1y)
-* Username and email
+**Make sure that your secret key is stored somewhere safe and use a unique strong password.**
 
 ##### Example key generation:
-```
-$ gpg --full-gen-key --expert
-[...]
-gpg: /tmp/trustdb.gpg: trustdb created
-gpg: key 61D68FF6279DF9A6 marked as ultimately trusted
-gpg: directory '/tmp/openpgp-revocs.d' created
-gpg: revocation certificate stored as
-'/tmp/openpgp-revocs.d/3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6.rev'
+```bash
+$ gpg2 --quick-generate-key "John Doe <john@doe.com>" future-default default 1y
+We need to generate a lot of random bytes. It is a good idea to perform
+some other action (type on the keyboard, move the mouse, utilize the
+disks) during the prime generation; this gives the random number
+generator a better chance to gain enough entropy.
+gpg: key 2F8E73B1D445CCD3 marked as ultimately trusted
+gpg: revocation certificate stored as '/home/john/.gnupg/openpgp-revocs.d/6718A9A63030E182A86FEE152F8E73B1D445CCD3.rev'
 public and secret key created and signed.
 
-pub   rsa4096 2017-01-04 [SC] [expires: 2018-01-04]
-      3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
-      3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6
+pub   ed25519 2017-09-24 [SC] [expires: 2018-09-24]
+      6718A9A63030E182A86FEE152F8E73B1D445CCD3
 uid                      John Doe <john@doe.com>
-sub   rsa4096 2017-01-04 [E] [expires: 2018-01-04]
+sub   cv25519 2017-09-24 [E]
 ```
 
-The generated key has the fingerprint `3D6B9B41CCDC16D0E4A66AC461D68FF6279DF9A6` in this example. Share it with others so they can verify your source. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Create_key_pair)
+The generated key has the fingerprint `6718A9A63030E182A86FEE152F8E73B1D445CCD3` in this example. Share it with others so they can verify your source. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Create_key_pair)
 
 If you ever move your installation make sure to backup `~/.gnupg/` as it contains the **private key** and the **revocation certificate**. Handle it with care. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Revoking_a_key)
 
@@ -217,11 +188,11 @@ To make the public key widely available, upload it to a key server. Now the user
 
 ```bash
 # Publish key
-gpg --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>
+gpg2 --keyserver hkps://pgp.mit.edu --send-keys <fingerprint>
 
 # Import key
 # Alternative keyserver: hkps://hkps.pool.sks-keyservers.net
-gpg --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
+gpg2 --keyserver hkps://pgp.mit.edu --recv-keys <fingerprint>
 ```
 
 ### 2.2 Publish full fingerprint
@@ -232,10 +203,10 @@ To make Github display your commits as "verified" you also need to add your publ
 
 ```bash
 # List keys + full fingerprint
-gpg --list-secret-keys --keyid-format LONG
+gpg2 --list-secret-keys --keyid-format LONG
 
 # Generate public key
-gpg --armor --export <fingerprint>
+gpg2 --armor --export <fingerprint>
 ```
 
 ## 3. Use Git with GPG
@@ -244,7 +215,7 @@ In order to make Git use your GPG key you need to set the default signing key fo
 
 ```bash
 # List keys + full fingerprint
-gpg --list-secret-keys --keyid-format LONG
+gpg2 --list-secret-keys --keyid-format LONG
 
 git config --global user.signingkey <fingerprint>
 ```
@@ -276,22 +247,22 @@ You can use `git archive` to create archives of your tagged Git release. It is h
 
 ```bash
 # .tar.gz
-git archive --format=tar.gz -o gpgit-1.0.0.tar.gz --prefix gpgit-1.0.0 1.0.0
+git archive --format=tar.gz -o gpgit-1.0.0.tar.gz --prefix gpgit-1.0.0/ 1.0.0
 
 # .tar.xz
-git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | xz > gpgit-1.0.0.tar.xz
+git archive --format=tar --prefix gpgit-1.0.0/ 1.0.0 | xz > gpgit-1.0.0.tar.xz
 
 # .tar.lz
-git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | lzip --best > gpgit-1.0.0.tar.xz
+git archive --format=tar --prefix gpgit-1.0.0/ 1.0.0 | lzip --best > gpgit-1.0.0.tar.xz
 
 # Verify an existing archive
-git archive --format=tar --prefix gpgit-1.0.0 1.0.0 | cmp <(xz -dc gpgit-1.0.0.tar.xz)
+git archive --format=tar --prefix gpgit-1.0.0/ 1.0.0 | cmp <(xz -dc gpgit-1.0.0.tar.xz)
 ```
 
 ### 4.2 Sign the archive
 Type the filename of the tarball that you want to sign and then run:
 ```bash
-gpg --digest-algo SHA512 --armor --detach-sign gpgit-1.0.0.tar.xz
+gpg2 --digest-algo SHA512 --armor --detach-sign gpgit-1.0.0.tar.xz
 ```
 **Do not blindly sign the Github source downloads** unless you have compared its content with the local files via `diff.` [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Make_a_detached_signature)
 
@@ -300,7 +271,7 @@ To not need to retype your password every time for signing you can also use [gpg
 This gives you a file called `gpgit-1.0.0.tar.xz.asc` which is the GPG signature. Release it along with your source tarball and let everyone know to first verify the signature after downloading. [[Read more]](https://wiki.archlinux.org/index.php/GnuPG#Verify_a_signature)
 
 ```bash
-gpg --verify gpgit-1.0.0.tar.xz.asc
+gpg2 --verify gpgit-1.0.0.tar.xz.asc
 ```
 
 ### 4.3 Create the message digest
@@ -319,9 +290,7 @@ sha512 gpgit-1.0.0.tar.xz > gpgit-1.0.0.tar.xz.sha512
 ### 5.2 Upload to Github
 Create a new "Github Release" to add additional data to the tag. Then drag the .tar.xz .sig and .sha512 files onto the release.
 
-The script also supports [uploading to Github](https://developer.github.com/v3/repos/releases/) directly. Create a new Github token first and then follow the instructions of the script.
-
-How to generate a Github token:
+The script also supports [uploading to Github](https://developer.github.com/v3/repos/releases/) directly. Create a new Github token first and then follow the instructions of the script. How to generate a Github token:
 * Go to ["Settings - Personal access tokens"](https://github.com/settings/tokens)
 * Generate a new token with permissions "public_repo" and "admin:gpg_key"
 * Store it safely
@@ -332,10 +301,24 @@ How to generate a Github token:
 You can also use your GPG key for email encryption with [enigmail and thunderbird](https://wiki.archlinux.org/index.php/thunderbird#EnigMail_-_Encryption). [[Read more]](https://www.enigmail.net/index.php/en/)
 
 ## Contact
-You can get securely in touch with me [here](http://contact.nicohood.de). Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues). More cool projects from me can be found [here](http://www.nicohood.de).
+You can get securely in touch with me [here](http://contact.nicohood.de). My GPG key ID is `9731 2D5E B9D7 AE7D 0BD4 3073 51DA E9B7 C1AE 9161`. Don't hesitate to [file a bug at Github](https://github.com/NicoHood/gpgit/issues). More cool projects from me can be found [here](http://www.nicohood.de).
 
 ## Version History
 ```
+1.3.0 (24.01.2018)
+* Reworked bash script completely
+* Simplified parameters
+* Added environment variable and git config support
+* Reduced output verbosity
+* Generate archive from local git source rather than downloading it from github
+* Do less unnecessary error checking, but simplify the code instead
+* Create signatures with strongest hash algorithm
+* Use ECC keys for GPG key generation if available
+* Added color output options
+* Fix pushing tag if a branch with the same name also exists
+* Added zip support
+* Added support for multiple compression/hash algorithms
+
 2.0.7 (27.06.2017)
 * Switch to Python3 from bash
 * New user interface with preview
diff --git a/gpgit.sh b/gpgit.sh
new file mode 100755
index 0000000..b615405
--- /dev/null
+++ b/gpgit.sh
@@ -0,0 +1,613 @@
+#!/bin/bash
+VERSION="1.3.0"
+
+# Avoid any encoding problems
+export LANG=C
+
+function setcolors()
+{
+    # Prefer terminal safe colored and bold text when tput is supported
+    unset ALL_OFF BOLD BLUE GREEN RED YELLOW MAGENTA CYAN
+    if tput setaf 0 &>/dev/null; then
+        ALL_OFF="$(tput sgr0)"
+        BOLD="$(tput bold)"
+        BLUE="${BOLD}$(tput setaf 4)"
+        GREEN="${BOLD}$(tput setaf 2)"
+        RED="${BOLD}$(tput setaf 1)"
+        YELLOW="${BOLD}$(tput setaf 3)"
+        MAGENTA="${BOLD}$(tput setaf 5)"
+        CYAN="${BOLD}$(tput setaf 6)"
+    else
+        ALL_OFF="\\e[1;0m"
+        BOLD="\\e[1;1m"
+        BLUE="${BOLD}\\e[1;34m"
+        GREEN="${BOLD}\\e[1;32m"
+        RED="${BOLD}\\e[1;31m"
+        YELLOW="${BOLD}\\e[1;33m"
+        MAGENTA="${BOLD}\\e[1;35m"
+        CYAN="${BOLD}\\e[1;36m"
+    fi
+}
+
+# Check if messages are to be printed using color
+if [[ -t 2 ]]; then
+    setcolors
+fi
+
+# Help page
+USAGE_SHORT="Usage: gpgit [-h] [-m <msg>] [-C <path>] [-o <path>] [-p] [-n] [-i] <tag>"
+read -r -d '' USAGE << EOF
+Usage: gpgit [options] <tag>
+
+GPGit ${VERSION} https://github.com/NicoHood/gpgit
+A shell script that automates the process of signing Git sources via GPG.
+
+${BOLD}Mandatory arguments:${ALL_OFF}
+  <tag>                    The name of the tag to create.
+
+${BOLD}Optional arguments:${ALL_OFF}
+  -h, --help               Show this help message and exit.
+  -m, --message <msg>      Use the given <msg> as the commit message.
+                           If multiple -m options are given, their values are
+                           concatenated as separate paragraphs.
+  -C, --directory <path>   Run as if GPGit was started in <path> instead of the
+                           current working directory.
+  -S, --signingkey <keyid> Use the given GPG key.
+  -o, --output <path>      Safe all release assets to the specified <path>.
+  -p, --pre-release        Flag as Github pre-release.
+  -n, --no-github          Disable Github API functionallity.
+  -i, --interactive        Run in interactive mode, step-by-step.
+      --<option>           Temporary set a 'gpgit.<option>' from config below.
+
+${BOLD}Examples:${ALL_OFF}
+  gpgit 1.0.0
+  gpgit -p -m "First alpha release." 0.1.0 --hash "sha256 sha512"
+  gpgit -C git/myproject/ -o /tmp/gpgit -n -m "Internal test release." 0.0.1
+
+${BOLD}Configuration options:${ALL_OFF}
+  gpgit.signingkey <keyid>, user.signingkey <keyid>
+  gpgit.output <path>
+  gpgit.token <token>
+  gpgit.compression <xz | gzip | bzip2 | lzip | zip>
+  gpgit.hash <sha512 | sha384 | sha256 | sha1 | md5>
+  gpgit.keyserver <keyserver>
+  gpgit.githubrepo <username/projectname>
+  gpgit.project <projectname>
+
+${BOLD}Examples:${ALL_OFF}
+  git config --global gpgit.output ~/gpgit
+  git config --local user.signingkey 97312D5EB9D7AE7D0BD4307351DAE9B7C1AE9161
+  git config --local compression "xz zip"
+EOF
+
+function interactive()
+{
+    if [[ "${INTERACTIVE}" == "true" ]]; then
+        [[ "${#}" -gt 0 ]] && echo "${*}" >&2
+        read -rp "Continue? [Y/n]" yesno
+        if [[ "${yesno}" != [Yy]"es" && "${yesno}" != [Yy] && -n "${yesno}" ]]; then
+            INTERACTIVE="false"
+            warning "Aborted by user."
+            exit 0
+        fi
+    fi
+}
+
+function msg()
+{
+    echo "${GREEN}==>${ALL_OFF}${BOLD} ${1}${ALL_OFF}" >&2
+}
+
+function msg2()
+{
+    echo "${BLUE}  ->${ALL_OFF}${BOLD} ${1}${ALL_OFF}" >&2
+}
+
+function plain()
+{
+    echo "    ${1}" >&2
+}
+
+function warning()
+{
+    echo "${YELLOW}==> WARNING:${ALL_OFF}${BOLD} ${1}${ALL_OFF}" >&2
+    interactive
+}
+
+function error()
+{
+    echo "${RED}==> ERROR:${ALL_OFF}${BOLD} ${1}${ALL_OFF}" >&2
+}
+
+function die()
+{
+    error "${1}"
+    exit 1
+}
+
+function kill_exit
+{
+    echo ""
+    INTERACTIVE="false"
+    warning "Exited due to user intervention."
+    exit 1
+}
+
+function command_not_found_handle
+{
+    die "${BASH_SOURCE[0]}: line ${BASH_LINENO[0]}: ${1}: command not found."
+}
+
+function check_dependency()
+{
+    local RET=0
+    for dependency in "${@}"
+    do
+        if ! command -v "${dependency}" &> /dev/null; then
+            error "Required dependency '${dependency}' not found."
+            RET=1
+        fi
+    done
+    return "${RET}"
+}
+
+# Trap errors
+set -o errexit -o errtrace -u
+trap 'die "Error on or near line ${LINENO}. Please report this issue: https://github.com/NicoHood/gpgit/issues"' ERR
+trap kill_exit SIGTERM SIGINT SIGHUP
+
+# Initialize variables
+unset INTERACTIVE MESSAGE KEYSERVER COMPRESSION HASH OUTPUT PROJECT SIGNINGKEY
+unset TOKEN GPG_USER GPG_EMAIL GITHUBREPO GITHUB PRERELEASE BRANCH GPG_BIN NEW_SIGNINGKEY
+declare -A GITHUB_ASSET
+declare -a HASH COMPRESSION
+
+# Parse input params an ovrwrite possible default or config loaded options
+GETOPT_ARGS=$(getopt -o "hm:C:k:u:s:S:o:O:pndi" \
+            -l "help,message:,directory:,signingkey:,local-user:,gpg-sign:,output:,pre-release,no-github,interactive,token:,compression:,hash:,keyserver:,githubrepo:,project:,debug,color:"\
+            -n "gpgit" -- "${@}") || die "${USAGE_SHORT}"
+eval set -- "$GETOPT_ARGS"
+
+# Handle all params
+while true ; do
+    case "$1" in
+        # Command line options
+        -h|--help)
+            echo "${USAGE}" >&2
+            exit 0
+            ;;
+        -m|--message)
+            MESSAGE+="$2\\n"
+            shift
+            ;;
+        -C|--directory)
+            cd "${2}"
+            shift
+            ;;
+        -o|-O|--output)
+            OUTPUT="${2}"
+            shift
+            ;;
+        -k|-u|-s|-S|--signingkey|--local-user|--gpg-sign)
+            SIGNINGKEY="${2}"
+            shift
+            ;;
+        -p|--prerelease)
+            PRERELEASE="true"
+            ;;
+        -n|--no-github)
+            GITHUB=""
+            ;;
+        -i|--interactive)
+            INTERACTIVE="true"
+            ;;
+        # Additional config options
+        --token)
+            TOKEN="${2}"
+            shift
+            ;;
+        --compression)
+            COMPRESSION+=("${2}")
+            shift
+            ;;
+        --hash)
+            HASH+=("${2}")
+            shift
+            ;;
+        --keyserver)
+            KEYSERVER="${2}"
+            shift
+            ;;
+        --githubrepo)
+            GITHUBREPO="${2}"
+            shift
+            ;;
+        --project)
+            PROJECT="${2}"
+            shift
+            ;;
+        # Internal
+        --color)
+            # En/disable colors
+            if [[ "${2}" == "never" ]]; then
+                ALL_OFF="" BOLD="" BLUE="" GREEN="" RED="" YELLOW="" MAGENTA="" CYAN=""
+            elif [[ "${2}" == "force" ]]; then
+                setcolors
+            fi
+            shift
+            ;;
+        -d|--debug)
+            set -x
+            ;;
+        --)
+            # No more options left.
+            shift
+            break
+           ;;
+        *)
+            die "Internal error."
+            ;;
+    esac
+    shift
+done
+readonly ALL_OFF BOLD BLUE GREEN RED YELLOW MAGENTA CYAN
+
+# Get tag parameter
+if [[ "$#" -lt 1 ]]; then
+    die "${USAGE_SHORT}"
+fi
+TAG="${1}"
+shift
+
+# Check if run inside Git directory
+check_dependency git sed grep awk || die "Please check your \$PATH variable or install the missing dependency."
+if [[ "$(git rev-parse --is-inside-work-tree 2>/dev/null)" != "true" ]]; then
+    die "Not a Git repository: $(pwd)"
+fi
+
+# Initialize variable config/defaults
+INTERACTIVE=${INTERACTIVE:-"$(git config gpgit.interactive || true)"}
+MESSAGE="${MESSAGE:-"Release ${TAG}"$'\n\nCreated with GPGit\nhttps://github.com/NicoHood/gpgit'}"
+KEYSERVER="${KEYSERVER:-"$(git config gpgit.keyserver || true)"}"
+KEYSERVER="${KEYSERVER:-"hkps://pgp.mit.edu"}"
+COMPRESSION=(${COMPRESSION[@]:-"$(git config gpgit.compression || true)"})
+COMPRESSION=(${COMPRESSION[@]:-xz})
+HASH=(${HASH[@]:-"$(git config gpgit.hash || true)"})
+HASH=(${HASH[@]:-sha512})
+OUTPUT="${OUTPUT:-"$(git config gpgit.output || true)"}"
+OUTPUT="${OUTPUT:-"./gpgit"}"
+PROJECT="${PROJECT:-"$(git config gpgit.project || true)"}"
+PROJECT="${PROJECT:-"$(git config --local remote.origin.url | sed -n 's#.*/\([^.]*\)\.git#\1#p')"}"
+SIGNINGKEY="${SIGNINGKEY:-"$(git config gpgit.signingkey || true)"}"
+SIGNINGKEY="${SIGNINGKEY:-"$(git config user.signingkey || true)"}"
+TOKEN="${TOKEN:-"$(git config gpgit.token || true)"}"
+GPG_USER="$(git config user.name || true)"
+GPG_USER="${GPG_USER:-"${USER}"}"
+GPG_EMAIL="$(git config user.email || true)"
+GITHUBREPO="${GITHUBREPO:-"$(git config gpgit.githubrepo || true)"}"
+GITHUBREPO="${GITHUBREPO:-"$(git config --local remote.origin.url | sed -e 's/.*github.com[:/]//' | sed -e 's/.git$//')"}"
+GITHUB="${GITHUB:-"$(git config --local remote.origin.url | grep -i 'github.com')"}"
+PRERELEASE="${PRERELEASE:-"false"}"
+BRANCH="$(git rev-parse --abbrev-ref HEAD)"
+GPG_BIN="$(git config gpg.program || true)"
+GPG_BIN="${GPG_BIN:-gpg2}"
+NEW_SIGNINGKEY="false"
+
+# Check if dependencies are available
+# Dependencies: bash, gnupg2, git, tar, xz, coreutils, gawk, grep, sed
+# Optional dependencies: gzip, bzip2, lzip, file, jq, curl
+check_dependency "${GPG_BIN}" "${COMPRESSION[@]}" "${HASH[@]/%/sum}" \
+     || die "Please check your \$PATH variable or install the missing dependencies."
+
+# Print initial welcome message with version information
+echo "${BOLD}GPGit ${VERSION} https://github.com/NicoHood/gpgit${ALL_OFF}" >&2
+echo "" >&2
+
+if [[ -z "${INTERACTIVE}" ]]; then
+    INTERACTIVE=true
+    interactive "Running GPGit for the first time. This will guide you through all steps of secure source code signing once. If you wish to run interactively again pass the -i option to GPGit. For more options see --help."
+    git config --global gpgit.interactive "false"
+fi
+
+####################################################################################################
+msg "1. Generate a new GPG key"
+####################################################################################################
+
+msg2 "1.1 Strong, unique, secret passphrase"
+plain "See: https://github.com/NicoHood/gpgit#11-strong-unique-secret-passphrase"
+
+# Create new GPG key if required
+msg2 "1.2 Key generation"
+if [[ -z "${SIGNINGKEY}" ]]; then
+    # Ask user about used name and email
+    plain "No GPG key registered with Git. Generating a new GPG key."
+    if [[ -n "$(${GPG_BIN} --list-secret-keys)" ]]; then
+        warning "Detected existing GPG keys."
+        plain "You can abort the script and set an existing key with:"
+        plain "${GPG_BIN} --list-secret-keys"
+        plain "git config --global user.signingkey <fingerprint>"
+    fi
+    read -rp "Enter username: " -e -i "${GPG_USER}" GPG_USER
+    [[ -z "${GPG_USER}" ]] && die "Empty username specified"
+    read -rp "Enter email: " -e -i "${GPG_EMAIL}" GPG_EMAIL
+    [[ -z "${GPG_EMAIL}" ]] && die "Empty email specified"
+    echo ""
+
+    # Generate strongest possible GPG key (ECC or RSA4096, depending on gnupg version)
+    interactive "Will generate the new GPG key with the selected parameters now."
+    ${GPG_BIN} --quick-generate-key "${GPG_USER} <${GPG_EMAIL}>" future-default default 1y \
+        &> /dev/null || die "GPG key generation aborted."
+    SIGNINGKEY=$(${GPG_BIN} --with-colons --list-secret-keys | grep "${GPG_USER} <${GPG_EMAIL}>" -B 2 | awk -F: '$1 == "fpr" {print $10;}')
+    NEW_SIGNINGKEY="true"
+    plain "Your new GPG fingerprint is: '${SIGNINGKEY}'"
+else
+    # Check if the full fingerprint is used
+    if [[ ${#SIGNINGKEY} -ne 40 ]]; then
+        die "Invalid GPG key fingerprint: '${SIGNINGKEY}'"
+    fi
+
+    # Print email and key information
+    SIGNINGKEY_OUTPUT="$(${GPG_BIN} --with-colons -k "${SIGNINGKEY}" 2>/dev/null)" || die "No public GPG key for fingerprint '${SIGNINGKEY}' found."
+    GPG_USER_EMAIL="$(echo "${SIGNINGKEY_OUTPUT}" | awk -F: '$1 == "uid" {print $10; exit}')"
+    plain "Using existing GPG key: '${GPG_USER_EMAIL}'"
+    plain "Fingerprint: '${SIGNINGKEY}'"
+    interactive
+fi
+
+
+####################################################################################################
+msg "2. Publish your key"
+####################################################################################################
+
+if [[ "${NEW_SIGNINGKEY}" == "true" ]]; then
+    msg2 "2.1 Send GPG key to a key server"
+    plain "Registering new GPG key with Git and uploading it to keyserver '${KEYSERVER}'."
+    interactive
+    ${GPG_BIN} --keyserver "${KEYSERVER}" --send-keys "${SIGNINGKEY}" &> /dev/null
+else
+    msg2 "2.1 Send GPG key to a key server"
+    plain "Make sure your key is available on a keyserver:"
+    plain "${GPG_BIN} --search-keys ${SIGNINGKEY}"
+    plain "${GPG_BIN} --keyserver ${KEYSERVER} --send-keys ${SIGNINGKEY}"
+    interactive
+fi
+
+msg2 "2.2 Publish full fingerprint"
+plain "Please publish the full GPG fingerprint on the project page."
+interactive
+
+msg2 "2.3 Associate GPG key with Github"
+plain "Paste the following command output to your Github profile GPG key settings:"
+plain "https://github.com/settings/keys"
+plain "${GPG_BIN} --armor --export ${SIGNINGKEY}"
+if [[ "${NEW_SIGNINGKEY}" == "true" ]]; then
+    ${GPG_BIN} --armor --export "${SIGNINGKEY}"
+fi
+interactive
+
+
+####################################################################################################
+msg "3. Use Git with GPG"
+####################################################################################################
+
+# Set new signingkey
+msg2 "3.1 Configure Git GPG key"
+if [[ "${NEW_SIGNINGKEY}" == "true" ]]; then
+    plain "Configuring Git with the new GPG key."
+    interactive
+    git config --global user.signingkey "${SIGNINGKEY}"
+else
+    plain "Git already configured with your GPG key."
+    interactive
+fi
+
+# Enable commit signing
+msg2 "3.2 Enable commit signing"
+if [[ "$(git config --global commit.gpgsign || true)" != "true" ]]; then
+    # Enable global commit signing. Can be still disabled locally.
+    plain "Enabling global commit signing."
+    git config --global commit.gpgsign true
+else
+    plain "Commit signing already enabled."
+fi
+
+# Check if tag exists
+msg2 "3.3 Create signed Git tag"
+plain "Fetching Git tags from origin."
+interactive
+git fetch origin --tags &> /dev/null
+if [[ -z "$(git tag -l "${TAG}")" ]] ; then
+    plain "Creating signed tag '${TAG}' and pushing it to the remote Git."
+    interactive
+    git tag -s "${TAG}" -m "${MESSAGE}" -u "${SIGNINGKEY}"
+    git push origin "refs/tags/${TAG}" &> /dev/null
+else
+    warning "Tag '${TAG}' already exists."
+fi
+
+
+####################################################################################################
+msg "4. Create a signed release archive"
+####################################################################################################
+
+# Create output directory
+if [[ ! -d "${OUTPUT}" ]]; then
+    plain "Creating not existing output directory: '${OUTPUT}'."
+    interactive
+    mkdir "${OUTPUT}"
+fi
+
+# Create new archive
+msg2 "4.1 Create compressed archive"
+for util in "${COMPRESSION[@]}"
+do
+    if [[ "${util}" == zip ]]; then
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.${util}"
+    else
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.tar.${util}"
+    fi
+    if [[ ! -f "${FILE}" ]]; then
+        plain "Creating new release archive: '${FILE}'"
+        interactive
+        if [[ "${util}" == zip ]]; then
+            git archive --format=zip --prefix "${PROJECT}-${TAG}/" "refs/tags/${TAG}" > "${FILE}"
+        else
+            git archive --format=tar --prefix "${PROJECT}-${TAG}/" "refs/tags/${TAG}" | "${util}" --best > "${FILE}"
+        fi
+    else
+        warning "Found existing archive '${FILE}'."
+    fi
+    GITHUB_ASSET["${PROJECT}-${TAG}.tar.${util}"]="${FILE}"
+done
+
+# Sign archive
+msg2 "4.2 Sign the archive"
+for util in "${COMPRESSION[@]}"
+do
+    if [[ "${util}" == zip ]]; then
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.${util}"
+    else
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.tar.${util}"
+    fi
+    if [[ ! -f "${FILE}.asc" ]]; then
+        plain "Creating GPG signature: '${FILE}.asc'"
+        interactive
+        ${GPG_BIN} --digest-algo SHA512 -u "${SIGNINGKEY}" --output "${FILE}.asc" --armor --detach-sign "${FILE}"
+    else
+        warning "Found existing signature '${FILE}.asc'."
+    fi
+    GITHUB_ASSET["${PROJECT}-${TAG}.tar.${util}.asc"]="${FILE}.asc"
+done
+
+# Creating hash
+msg2 "4.3 Create the message digest"
+for util in "${COMPRESSION[@]}"
+do
+    if [[ "${util}" == zip ]]; then
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.${util}"
+    else
+        FILE="${OUTPUT}/${PROJECT}-${TAG}.tar.${util}"
+    fi
+    for algorithm in "${HASH[@]}"
+    do
+        if [[ ! -f "${FILE}.${algorithm}" ]]; then
+            plain "Creating message digest: '${FILE}.${algorithm}'"
+            interactive
+            "${algorithm}sum" "${FILE}" > "${FILE}.${algorithm}"
+        else
+            warning "Found existing message digest '${FILE}.${algorithm}'."
+        fi
+        GITHUB_ASSET["${PROJECT}-${TAG}.tar.${util}.${algorithm}"]="${FILE}.${algorithm}"
+    done
+done
+
+####################################################################################################
+msg "5. Upload the release"
+####################################################################################################
+
+msg2 "5.1 Configure HTTPS download server"
+if [[ -z "${GITHUB}" ]]; then
+    plain "Please configure HTTPS for your download server."
+else
+    plain "Github uses well configured https."
+fi
+interactive
+
+function get_token()
+{
+    if [[ -z "${TOKEN}" ]]; then
+        plain "Please enter your Github token or generate a new one (permission: 'public_repo'):"
+        plain "https://github.com/settings/tokens"
+        plain "Tip: Configure your Github token permanant with:"
+        plain "git config --global gpgit.token <token>"
+        read -rs TOKEN
+    fi
+}
+
+function github_upload_asset()
+{
+    local filename="${1}"
+    local file="${2}"
+    local message
+    local mimetype
+    mimetype="$(file -b --mime-type "${filename}")"
+
+    # Upload Github asset
+    get_token
+    plain "Uploading release asset '${filename}'"
+    interactive
+    if ! RESULT=$(curl --proto-redir =https -s \
+            "https://uploads.github.com/repos/${GITHUBREPO}/releases/${GITHUB_RELEASE_ID}/assets?name=${filename}" \
+            -H "Content-Type: ${mimetype}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            -H "Authorization: token ${TOKEN}" \
+            --data-binary @"${file}"); then
+        die "Uploading file ${filename} to Github failed."
+    fi
+
+    # Abort in API error
+    message="$(echo "${RESULT}" | jq -r .message)"
+    if [[ "${message}" != "null" ]]; then
+        die "Github API message: '${message}' Check your token configuration: https://github.com/settings/tokens"
+    fi
+}
+
+# Upload to Github
+msg2 "5.2 Upload to Github"
+if [[ -z "${GITHUB}" ]]; then
+    plain "Please upload the release files manually"
+    interactive
+else
+    if check_dependency jq file curl; then
+        # Parse existing Github release
+        if ! GITHUB_RELEASE="$(curl --proto-redir =https -s \
+                "https://api.github.com/repos/${GITHUBREPO}/releases/tags/${TAG}")"; then
+            die "Accessing Github failed."
+        fi
+
+        # Check for existing release and assets
+        GITHUB_RELEASE_ID="$(echo "${GITHUB_RELEASE}" | jq -r .id)"
+        GITHUB_ASSETS="$(echo "${GITHUB_RELEASE}" | jq -r .assets[]?.name)"
+
+        # Create new Github release
+        if [[ "${GITHUB_RELEASE_ID}" == "null" ]]; then
+            plain "Creating new Github release '${TAG}'."
+            interactive
+            API_JSON=$(printf '{"tag_name": "%s","target_commitish": "%s","name": "%s","body": "%s","draft": false,"prerelease": %s}' \
+                       "${TAG}" "${BRANCH}" "${TAG}" "${MESSAGE//$'\n'/'\n'}" "${PRERELEASE}")
+            get_token
+            if ! GITHUB_RELEASE=$(curl --proto-redir =https -s --data "${API_JSON}" \
+                    "https://api.github.com/repos/${GITHUBREPO}/releases" \
+                    -H "Accept: application/vnd.github.v3+json" \
+                    -H "Authorization: token ${TOKEN}" ); then
+                die "Uploading release to Github failed."
+            fi
+
+            # Abort on API error
+            message="$(echo "${GITHUB_RELEASE}" | jq -r .message)"
+            if [[ "${message}" != "null" ]]; then
+                die "Github API message: '${message}' Check your token configuration: https://github.com/settings/tokens"
+            fi
+
+            # Safe new ID
+            GITHUB_RELEASE_ID="$(echo "${GITHUB_RELEASE}" | jq -r .id)"
+        else
+            warning "Found existing release on Github."
+        fi
+
+        # Upload release assets
+        for filename in "${!GITHUB_ASSET[@]}"
+        do
+            if grep -q "^${filename}$" <(echo "${GITHUB_ASSETS}"); then
+                warning "Found existing asset on Github: '${filename}'."
+            else
+                github_upload_asset "${filename}" "${GITHUB_ASSET[$filename]}"
+            fi
+        done
+        exit
+    else
+        warning "Please upload the release files manually to Github."
+    fi
+fi
+
+msg "Finished without errors."
diff --git a/img/screenshot.png b/img/screenshot.png
index 2d5c1e9..231a5de 100644
Binary files a/img/screenshot.png and b/img/screenshot.png differ
diff --git a/gpgit.py b/legacy/gpgit.py
similarity index 100%
rename from gpgit.py
rename to legacy/gpgit.py
diff --git a/legacy/gpgit.sh b/legacy/gpgit.sh
deleted file mode 100755
index ce47187..0000000
--- a/legacy/gpgit.sh
+++ /dev/null
@@ -1,681 +0,0 @@
-#!/bin/bash
-
-# Avoid any encoding problems
-export LANG=C
-
-shopt -s extglob
-set -u
-
-PROGNAME=$(basename "$0")
-VERSION=1.2.0
-
-################################################################################
-# Functions
-################################################################################
-
-function usage()
-{
-    echo "${PROGNAME} ${VERSION}"
-    echo "Usage: ${PROGNAME} <tag> [options]"
-    echo
-    echo 'Mandatory parameters:'
-    echo '<tag>           Tagname'
-    echo
-    echo 'Actions:'
-    echo '-h --help       Show this help message'
-    echo
-    echo 'Options:'
-    echo '-o, --output    The output path of the compressed archive, signature and message digest.'
-    echo '                Default: "git rev-parse --show-toplevel)/archive"'
-    echo '-u, --username  Username of the user. Used for GPG key generation.'
-    echo '                Default: git config user.name'
-    echo '-e, --email     Email of the user. Used for GPG key generation.'
-    echo '                Default: "git config user.email"'
-    echo '-p, --project   The name of the project. Used for archive geneation.'
-    echo "                Default: \"git config --local remote.origin.url \\"
-    echo "                           | sed -n 's#.*/\([^.]*\)\.git#\1#p'\""
-    echo '-g, --gpg       Specify (full) GPG fingerprint to use for signing.'
-    echo '                Default: "git config user.signingkey"'
-    echo '-w, --wget      Download source from a user-specified URL.'
-    echo '                Default: Auto detection for Github URL'
-    echo "-t, --tar       Valid compression options: ${config[COMPRESSION_ALGS]}"
-    echo '                Default: gz'
-    echo "-s, --sha       Valid message digest options: ${config[HASH_ALGS]}"
-    echo '                Default: sha512'
-    echo '-m, --message   Specify the tag message.'
-    echo '                Default: "Release <tag>"'
-    echo '-y, --yes       Assume "yes" on all questions.'
-}
-
-# Check if messages are to be printed using color
-unset ALL_OFF BOLD BLUE GREEN RED YELLOW MAGENTA CYAN
-if [[ -t 2 ]]; then
-    # prefer terminal safe colored and bold text when tput is supported
-    if tput setaf 0 &>/dev/null; then
-        ALL_OFF="$(tput sgr0)"
-        BOLD="$(tput bold)"
-        BLUE="${BOLD}$(tput setaf 4)"
-        GREEN="${BOLD}$(tput setaf 2)"
-        RED="${BOLD}$(tput setaf 1)"
-        YELLOW="${BOLD}$(tput setaf 3)"
-        MAGENTA="${BOLD}$(tput setaf 5)"
-        CYAN="${BOLD}$(tput setaf 6)"
-    else
-        ALL_OFF="\e[1;0m"
-        BOLD="\e[1;1m"
-        BLUE="${BOLD}\e[1;34m"
-        GREEN="${BOLD}\e[1;32m"
-        RED="${BOLD}\e[1;31m"
-        YELLOW="${BOLD}\e[1;33m"
-        MAGENTA="${BOLD}\e[1;35m"
-        CYAN="${BOLD}\e[1;36m"
-    fi
-fi
-readonly ALL_OFF BOLD BLUE GREEN RED YELLOW MAGENTA CYAN
-
-function msg() {
-    local mesg=$1; shift
-    printf "${GREEN}==>${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function msg2() {
-    local mesg=$1; shift
-    printf "${BLUE}  ->${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function plain() {
-    local mesg=$1; shift
-    printf "${BOLD}    ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function warning() {
-    local mesg=$1; shift
-    printf "${YELLOW}==> WARNING:${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function error() {
-    local mesg=$1; shift
-    printf "${RED}==> ERROR:${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function info() {
-    local mesg=$1; shift
-    printf "${YELLOW}[!]:${ALL_OFF}${BOLD} ${mesg}${ALL_OFF}\n" "$@" >&2
-}
-
-function error_exit
-{
-    local parent_lineno="$1"
-    local message="$2"
-    local code="${3:-1}"
-    if [[ -n "${message}" ]] ; then
-        error "Error on or near line ${parent_lineno}: ${message}; exiting with status ${code}"
-    else
-        error "Error on or near line ${parent_lineno}; exiting with status ${code}"
-    fi
-    plain "Please report this error with the full bash output to:"
-    plain "https://github.com/NicoHood/gpgit/issues"
-    exit "${code}"
-}
-
-function kill_exit
-{
-    error "Exited due to user intervention."
-    exit 1
-}
-
-function gpgit_yesno() {
-    [[ "${config[YES]}" == true ]] && return
-    while read -r -t 0; do read -r; done
-    read -rp "${BOLD}    Continue? [Y/n]${ALL_OFF}" yesno
-    if [[ "${yesno}" != [Yy]"es" && "${yesno}" != [Yy] && -n "${yesno}" ]]; then
-        warning "Aborted by user"
-        exit 0
-    fi
-}
-
-function gpgit_check_tool() {
-    if ! command -v "$1" &> /dev/null; then
-        error "Required tool $1 not found. Please check your PATH variable or install the missing dependency."
-        exit 1
-    fi
-}
-
-################################################################################
-# Parameters
-################################################################################
-
-# Trap errors
-trap 'error_exit ${LINENO}' ERR
-trap kill_exit SIGTERM SIGINT SIGHUP
-
-# Check for gpg version. On some distribution gpg 2.x is installed as gpg2.
-if ! gpg --version | grep "gpg (GnuPG) 2" -q; then
-    if ! gpg2 --version | grep "gpg (GnuPG) 2" -q; then
-        error "No gpg version 2.x available. Please install the newest gpg version."
-        exit 1
-    else
-        GPG_BIN=gpg2
-    fi
-else
-    GPG_BIN=gpg
-fi
-
-# Check if inside a git folder
-if [[ "$(git rev-parse --is-inside-work-tree)" != "true" ]]; then
-    error "Not a git repository."
-    exit 1
-fi
-
-# Check input param number
-if [[ $# -lt 1 ]]; then
-    error "Usage: ${PROGNAME} <tag>" 1>&2
-    plain "Use --help for more information."
-    exit 1
-fi
-
-# Set default values in config array
-declare -A config
-config=(
-    [OUTPUT]="$(git rev-parse --show-toplevel)/archive"
-    [USERNAME]="$(git config user.name)"
-    [EMAIL]="$(git config user.email)"
-    [PROJECT]="$(git config --local remote.origin.url \
-                 | sed -n 's#.*/\([^.]*\)\.git#\1#p')"
-    [GPG]="$(git config user.signingkey)"
-    [MESSAGE]="Release $1"
-    [COMPRESSION]="gz"
-    [COMPRESSION_ALGS]="gz|xz|lz"
-    [HASH]="sha512"
-    [HASH_ALGS]="sha256|sha384|sha512"
-    [URL]=""
-    [YES]=false
-    [BRANCH]=$(git rev-parse --abbrev-ref HEAD)
-)
-
-# Print help
-if [[ "$1" == "-h" || "$1" == "--help" ]]; then
-    usage 1>&2
-    exit 0
-fi
-
-# Parse input params an ovrwrite possible default or config loaded options
-GETOPT_ARGS=$(getopt -o "ho:u:e:p:g:w:t:s:m:y" \
-            -l "help,output:,username:,email:,project:,gpg:,wget:,tar:,sha:,message:,yes"\
-            -n "$PROGNAME" -- $@)
-eval set -- "$GETOPT_ARGS"
-
-# Handle all params
-while true ; do
-    case "$1" in
-        # Options
-        -o|--output)
-            config[OUTPUT]="$2"
-            shift
-            ;;
-        -u|--username)
-            config[USERNAME]="$2"
-            shift
-            ;;
-        -e|--email)
-            config[EMAIL]="$2"
-            shift
-            ;;
-        -p|--project)
-            config[PROJECT]="$2"
-            shift
-            ;;
-        -g|--gpg)
-            config[GPG]="$2"
-            shift
-            ;;
-        -w|--wget)
-            config[URL]="$2"
-            shift
-            ;;
-        -t|--tar)
-            config[COMPRESSION]="$2"
-            shift
-            ;;
-        -s|--sha)
-            config[HASH]="$2"
-            shift
-            ;;
-        -m|--message)
-            config[MESSAGE]="$2"
-            shift
-            ;;
-        -y|--yes)
-            config[YES]=true
-            ;;
-        # Internal
-        -h|--help)
-            usage 1>&2
-            exit 0
-            ;;
-        --)
-            # No more options left.
-            shift
-            break
-           ;;
-        *)
-            error "Internal error!"
-            exit 1
-            ;;
-    esac
-    shift
-done
-
-config[TAG]=$1
-
-declare -A compression_utility
-compression_utility=(
-    [gz]="gzip"
-    [xz]="xz"
-    [lz]="lzip"
-)
-
-# Validate compression parameter
-case "${config[COMPRESSION]}" in
-    @(${config[COMPRESSION_ALGS]}))
-        # Check if compression programm is available
-        gpgit_check_tool "${compression_utility[${config[COMPRESSION]}]}"
-        ;;
-    *)
-        error "Invalid compression option. Available compressions: ${config[COMPRESSION_ALGS]}"
-        exit 1
-        ;;
-esac
-
-# Validate hash parameter
-case "${config[HASH]}" in
-    @(${config[HASH_ALGS]}))
-        # Check if hash programm is available
-        gpgit_check_tool "${config[HASH]}sum"
-        ;;
-    *)
-        error "Invalid message digest option. Available message digests: ${config[HASH_ALGS]}"
-        exit 1
-        ;;
-esac
-
-################################################################################
-msg "1. Generate new GPG key"
-################################################################################
-
-# Check for existing key
-if [[ -z "${config[GPG]}" ]]; then
-    if $GPG_BIN --list-secret-keys | grep uid | grep -v -q revoked; then
-        error "GPG seems to be already configured on your system but git is not."
-        plain "Please use gpg --list-secret-keys to show existing keys."
-        plain "Afterwards set the key with git config --global user.signingkey <key>."
-        plain "See the readme for more information."
-        exit 1
-    else
-        plain "Generating an RSA 4096 GPG key for ${config[USERNAME]} <${config[EMAIL]}> valid for 3 years."
-        gpgit_yesno
-
-        # Generate ECC key command (currently not supported by Github)
-        #$GPG_BIN --quick-generate-key "testuser (comment) <name@mail.com>" future-default default 3y
-
-        # Generate RSA key command
-        # https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html
-        # gpg: revocation certificate stored as '/tmp/tmp.81v03YSxmI/openpgp-revocs.d/F4EDF85EFF03D746D17094D3C28B8F6BCCDF8671.rev'
-        config[GPG]="$($GPG_BIN --batch --generate-key <( cat << EOF
-            Key-Type: RSA
-            Key-Length: 4096
-            Key-Usage: cert sign auth
-            Subkey-Type: RSA
-            Subkey-Length: 4096
-            Subkey-Usage: encrypt
-            Name-Real: ${config[USERNAME]}
-            #Name-Comment: Generated with gpgit
-            Name-Email: ${config[EMAIL]}
-            Expire-Date: 3y
-            # Preferences: TODO https://security.stackexchange.com/questions/82216/how-to-change-default-cipher-in-gnupg-on-both-linux-and-windows
-            %ask-passphrase
-            %echo We need to generate a lot of random bytes. It is a good idea to perform
-            %echo some other action (type on the keyboard, move the mouse, utilize the
-            %echo disks) during the prime generation; this gives the random number
-            %echo generator a better chance to gain enough entropy.
-            %commit
-            %echo Key generation finished
-EOF
-        ) 2>&1 | tee -a /dev/fd/2 | grep "revocation certificate stored as " \
-               | sed 's,.*/\(.*\).rev.*,\1,')"
-        NEW_GPG_KEY=true
-
-        # Print new fingerprint
-        plain "Your new GPG fingerprint is: ${config[GPG]}"
-        $GPG_BIN -u "${config[GPG]}" --list-secret-keys --keyid-format LONG
-    fi
-else
-    plain "Key already generated. Using key: ${config[GPG]}"
-    NEW_GPG_KEY=false
-
-    # Check if the full fingerprint is used
-    if [[ ${#config[GPG]} -ne 40 ]]; then
-        error "Please specify the full fingerprint."
-        exit 1
-    fi
-
-    # Check if key exists
-    if ! GPG_KEY=$($GPG_BIN --keyid-format LONG --list-secret-keys "0x${config[GPG]}"); then
-        error "This GPG key is not known on this system."
-        plain "Check your git config or your GNUPGHOME variable."
-        exit 1
-    fi
-
-    # Check key algorithm for key
-    if grep -iq "[rd]sa1024" <(echo "${GPG_KEY}"); then
-        error "This key uses an insecure key algorithm. Please generate a new, secure key."
-        exit 1
-    fi
-fi
-
-################################################################################
-msg "2. Publish your key"
-################################################################################
-
-# Check if key was just created
-if [[ "${NEW_GPG_KEY}" = true ]]; then
-    # Refresh setting
-    config[GPG]="$(git config --global user.signingkey)"
-
-    # Upload key
-    msg2 "2.1 Submit your key to a key server"
-    plain "Uploading key ${config[GPG]} to hkps://hkps.pool.sks-keyservers.net"
-    gpgit_yesno
-    $GPG_BIN --keyserver hkps://hkps.pool.sks-keyservers.net --send-keys "${config[GPG]}"
-
-    # Generate public key
-    msg2 "2.2 Associate GPG key with github"
-    plain "Please visit Github and add the following GPG key to your profile."
-    plain "https://github.com/settings/keys"
-    gpgit_yesno
-    $GPG_BIN --armor --export "${config[GPG]}"
-
-    msg2 "2.3 Publish your fingerprint"
-    plain "Publish your GPG fingerprint (${config[GPG]}) on your project site."
-    plain "Also see https://wiki.debian.org/Keysigning"
-    gpgit_yesno
-else
-    plain "Assuming key was already published after its creation. If not please do so."
-fi
-
-################################################################################
-msg "3. Usage of GPG by git"
-################################################################################
-
-# Differenciate between new created key and (temporary) different key
-if [[ "${NEW_GPG_KEY}" = true ]]; then
-    GIT_CONFIG="global"
-else
-    GIT_CONFIG="local"
-fi
-
-#  3.1 Configure git GPG key
-msg2 "3.1 Configure git GPG key"
-if [[ "${config[GPG]}" != "$(git config user.signingkey)" ]]; then
-    # If the key differs from the local>global>system configured key, set it locally
-    plain "Git is not configured with this key."
-    plain "Configuring ${GIT_CONFIG} git settings with your GPG key."
-    gpgit_yesno
-    git config --"${GIT_CONFIG}" user.signingkey "${config[GPG]}"
-else
-    plain "Git already configured with your GPG key"
-fi
-
-# Check if commit signing is enabled for this repo and ask for a switch if not
-msg2 "3.2 Commit signing"
-if [[ $(git config commit.gpgsign) != true ]]; then
-    warning "Commit signing is disabled. Will enable it now ${GIT_CONFIG}ly."
-    gpgit_yesno
-    git config --"${GIT_CONFIG}" commit.gpgsign true
-else
-    plain "Commit signing already enabled."
-fi
-
-# Refresh tags
-msg2 "3.3 Create signed git tag"
-plain "Refreshing tags from upstream."
-gpgit_yesno
-git fetch origin --tags
-
-# Check if tag exists
-if ! git tag | grep -Fxq "${config[TAG]}"; then
-    # Check if every added file has been commited
-    if ! git diff --cached --exit-code > /dev/null; then
-        warning 'You have added new changes but did not commit them yet. See "git status" or "git diff".'
-        gpgit_yesno
-    fi
-
-    # Create new tag if not existant
-    plain "Creating signed tag ${config[TAG]} and pushing it to the remote git."
-    gpgit_yesno
-
-    # Create and push new git tag
-    git tag -s "${config[TAG]}" -m "${config[MESSAGE]}"
-    git push origin "${config[TAG]}"
-else
-    plain "Tag ${config[TAG]} already exists."
-fi
-
-################################################################################
-msg "4. Creation of a signed compressed release archive"
-################################################################################
-
-# Check if output path exists and ask for creation
-if [[ ! -d "${config[OUTPUT]}" ]]; then
-    plain "Output path does not exist. Create ${config[OUTPUT]} ?"
-    gpgit_yesno
-    mkdir -p "${config[OUTPUT]}"
-fi
-
-# Build archive path
-config[FILENAME]="${config[PROJECT]}-${config[TAG]}"
-config[EXTENSION]=".tar"
-config[FILE]="${config[FILENAME]}${config[EXTENSION]}"
-config[COMPRESSED_FILE]="${config[FILE]}.${config[COMPRESSION]}"
-config[TAR]="${config[OUTPUT]}/${config[FILE]}"
-config[COMPRESSED_TAR]="${config[TAR]}.${config[COMPRESSION]}"
-
-# Set github URL if not otherwise specified
-if [[ -z "${config[URL]}" ]]; then
-    # Download the github generated archive if available
-    if [[ "${config[COMPRESSION]}" == "gz" ]] && \
-       git config --local remote.origin.url | grep 'github.com' -q; then
-        GITHUB_REPO=`git config --local remote.origin.url | sed -e 's/.*github.com[:/]//' | sed -e 's/.git$//'`
-        config[URL]="https://github.com/$GITHUB_REPO/archive/${config[TAG]}.tar.gz"
-    fi
-fi
-
-# Download archive from URL
-if [[ ! -f "${config[COMPRESSED_TAR]}" && -n "${config[URL]}" ]]; then
-    msg2 "4.0 Download archive from online source"
-    # Check if compression algorithm is valid
-    if [[ "${config[COMPRESSION]}" != "${config[URL]##*.}" ]]; then
-        error "Online binary format (${config[URL]##*.}) does not match selected compression format (${config[COMPRESSION]})."
-        exit 1
-    fi
-    gpgit_check_tool wget
-
-    plain "Downloading source from URL ${config[URL]}"
-    gpgit_yesno
-    wget -O "${config[COMPRESSED_TAR]}" "${config[URL]}"
-fi
-
-# Create or verify archive
-msg2 "4.1 Create compressed archive"
-if [[ -f "${config[COMPRESSED_TAR]}" ]]; then
-    plain "Archive ${config[COMPRESSED_TAR]} already exists."
-    plain "Verifying git against local source."
-    gpgit_yesno
-
-    # Verify local source against existing tar
-    if git archive --format=tar --prefix "${config[FILENAME]}/" "${config[TAG]}" \
-         | cmp <(${compression_utility[${config[COMPRESSION]}]} -dc ${config[COMPRESSED_TAR]}); then
-        plain "Existing archive successfully verified against local source."
-    else
-        error "Archive differs from local source."
-        exit 1
-    fi
-else
-    plain "Creating release archive file ${config[COMPRESSED_TAR]}"
-    gpgit_yesno
-
-    # Create new archive
-    git archive --format=tar --prefix "${config[FILENAME]}/" "${config[TAG]}" \
-                | ${compression_utility[${config[COMPRESSION]}]} --best > "${config[COMPRESSED_TAR]}"
-fi
-
-# Create hash of the .tar.xz
-msg2 "4.2 Create message digest"
-if [[ -f "${config[COMPRESSED_TAR]}.${config[HASH]}" ]]; then
-    plain "Message digest ${config[COMPRESSED_TAR]}.${config[HASH]} already exists. Verifying it now."
-    gpgit_yesno
-    if ! "${config[HASH]}sum" -c "${config[COMPRESSED_TAR]}.${config[HASH]}"; then
-        error "Message digest could not be verified."
-        exit 1
-    fi
-else
-    plain "Creating message digest ${config[COMPRESSED_TAR]}.${config[HASH]}"
-    gpgit_yesno
-    "${config[HASH]}sum" "${config[COMPRESSED_TAR]}" > "${config[COMPRESSED_TAR]}.${config[HASH]}"
-fi
-
-# Sign .tar.xz if not existant
-msg2 "4.3 Sign the sources"
-if [[ -f "${config[COMPRESSED_TAR]}.sig" ]]; then
-    plain "Signature ${config[COMPRESSED_TAR]}.sig already exists. Verifying it with gpg."
-    gpgit_yesno
-    if ! $GPG_BIN --verify "${config[COMPRESSED_TAR]}.sig"; then
-        error "Signature could not be verified with gpg."
-        exit 1
-    fi
-else
-    plain "Creating signature ${config[COMPRESSED_TAR]}.sig"
-    gpgit_yesno
-    $GPG_BIN --local-user "${config[GPG]}" --output "${config[COMPRESSED_TAR]}.sig" --armor --detach-sign "${config[COMPRESSED_TAR]}"
-fi
-
-################################################################################
-msg "5. Upload the release"
-################################################################################
-
-# Github
-if git config --local remote.origin.url | grep 'github.com' -q; then
-    msg2 "5.1 Github"
-    gpgit_check_tool curl
-    plain "Uploading to Github. Please setup a Github token first:"
-    plain "(Github->Settings->Personal access tokens; public repo access)"
-    gpgit_yesno
-
-    # Create github release and upload the signature
-    # http://www.barrykooij.com/create-github-releases-via-command-line/
-    # https://developer.github.com/v3/repos/releases/
-    # https://developer.github.com/changes/2013-09-25-releases-api/
-    # https://developer.github.com/guides/getting-started/
-    while read -r -t 0; do read -r; done
-    read -rsp "${BOLD}    Enter your Github token:${ALL_OFF}" TOKEN
-    plain ""
-    API_JSON=$(printf '{"tag_name": "%s","target_commitish": "%s","name": "%s","body": "Release %s","draft": false,"prerelease": false}' \
-               "${config[TAG]}" "${config[BRANCH]}" "${config[TAG]}" "${config[TAG]}")
-    if ! RESULT=$(curl -s --data "${API_JSON}" "https://api.github.com/repos/${config[USERNAME]}/${config[PROJECT]}/releases" \
-    -H "Accept: application/vnd.github.v3+json" -H "Authorization: token ${TOKEN}" ); then
-        error "Uploading release to Github failed."
-        exit 1
-    fi
-
-    # Check for error
-    if grep -Eq '"message": ?"Bad credentials"' <(echo "${RESULT}"); then
-        error "Bad Github credentials."
-        exit 1
-    fi
-
-    # Check if release already exists
-    if grep -Eq '"message": ?"Validation Failed"' <(echo "${RESULT}"); then
-        if grep -Eq '"code": ?"already_exists"' <(echo "${RESULT}"); then
-            warning "Release already exists."
-
-            # Get release id for an existing release
-            # https://developer.github.com/v3/repos/releases/#get-a-release-by-tag-name
-            if ! RELEASE_ID=$(curl -s "https://api.github.com/repos/${config[USERNAME]}/${config[PROJECT]}/releases/tags/${config[TAG]}" \
-                              | grep '^  "id": ' | tr -dc '[:digit:]'); then
-                error "Accessing Github Release failed."
-                exit 1
-            fi
-        elif grep -Eq '"message": ?"Published releases must have a valid tag"' <(echo "${RESULT}"); then
-            error "Published releases must have a valid tag. Please try again later."
-            exit 1
-        else
-            error "Unknown Github error: $(grep '"message":' <(echo "${RESULT}"))"
-            exit 1
-        fi
-    else
-        # Parse release ID
-        RELEASE_ID=$(echo "${RESULT}" | grep '^  "id": ' | tr -dc '[:digit:]')
-        plain "Github release created."
-    fi
-
-    # Upload the generated archive if its not gz
-    if [[ "${config[COMPRESSION]}" != "gz" ]]; then
-        # Upload archive
-        if ! RESULT=$(curl -s "https://uploads.github.com/repos/${config[USERNAME]}/${config[PROJECT]}/releases/${RELEASE_ID}/assets?name=${config[COMPRESSED_FILE]}" \
-        -H "Content-Type: application/tar" \
-        -H "Accept: application/vnd.github.v3+json" \
-        -H "Authorization: token ${TOKEN}" \
-        --data-binary @"${config[COMPRESSED_TAR]}"); then
-            error "Uploading archive to Github failed."
-            exit 1
-        fi
-
-        # Check if archive already exists
-        if grep -Eq '"message": ?"Validation Failed"' <(echo "${RESULT}") && \
-           grep -Eq '"code": ?"already_exists"' <(echo "${RESULT}"); then
-            warning "Archive already exists."
-        else
-            plain "Archive uploaded."
-        fi
-    fi
-
-    # Upload signature
-    if ! RESULT=$(curl -s "https://uploads.github.com/repos/${config[USERNAME]}/${config[PROJECT]}/releases/${RELEASE_ID}/assets?name=${config[COMPRESSED_FILE]}.sig" \
-    -H "Content-Type: application/pgp-signature" \
-    -H "Accept: application/vnd.github.v3+json" \
-    -H "Authorization: token ${TOKEN}" \
-    --data-binary @"${config[COMPRESSED_TAR]}.sig"); then
-        error "Uploading signature to Github failed."
-        exit 1
-    fi
-
-    # Check if signature already exists
-    if grep -Eq '"message": ?"Validation Failed"' <(echo "${RESULT}") && \
-       grep -Eq '"code": ?"already_exists"' <(echo "${RESULT}"); then
-        warning "Signature already exists."
-    else
-        plain "Signature uploaded."
-    fi
-
-    # Upload message digest
-    if ! RESULT=$(curl -s "https://uploads.github.com/repos/${config[USERNAME]}/${config[PROJECT]}/releases/${RELEASE_ID}/assets?name=${config[COMPRESSED_FILE]}.${config[HASH]}" \
-    -H "Content-Type: text/sha512" \
-    -H "Accept: application/vnd.github.v3+json" \
-    -H "Authorization: token ${TOKEN}" \
-    --data-binary @"${config[COMPRESSED_TAR]}.${config[HASH]}"); then
-        error "Uploading message digest to Github failed."
-        exit 1
-    fi
-
-    # Check if message digest already exists
-    if grep -Eq '"message": ?"Validation Failed"' <(echo "${RESULT}") && \
-       grep -Eq '"code": ?"already_exists"' <(echo "${RESULT}"); then
-        warning "Message digest already exists."
-    else
-        plain "Message digest uploaded."
-    fi
-else
-    plain "Please upload the compressed archive, signature and message digest manually."
-fi
-
-msg "Finished without errors"
diff --git a/requirements.txt b/legacy/requirements.txt
similarity index 100%
rename from requirements.txt
rename to legacy/requirements.txt