I can only recommend you use and learn to work with Git.

I can give you a quick and easy way to set up your own personal github. Even your personal Arch Linux repository.

The goal is not to use a gui but get the work done via the terminal with SSH and GPG.

Use only two bash scripts to maintain your github

This tutorial is intended for the use of git/Github for just one person. No collaboration with others.


Why do I need a github?

  • Easy and quick installation of configs and packages
  • It is a backup system for you.
  • Moving from pc to pc and syncing the latest work via github.
  • You can easily share files with others.
  • Some distros make installing from github very easy – like Arch Linux
  • Communicate with others via github.
  • Github has a system to follow up issues.
  • More visibility for your projects.
  • Share your packages via a repository that pacman can read

What can I share on github?

  1. files
  2. scripts
  3. icons
  4. themes
  5. config files
  6. settings from applications
  7. packages
  8. repository

We need SSH and GPG to connect to Github

We want two factor authentication


SigLevel = Optional TrustedOnly
Server = https://teachingarco.github.io/$repo/$arch

You need to get three files to get started for your own project

  • README.md (info about the project)
  • up.sh (run this every time you want to push code online)
  • setup.sh (run this once at the start)

Phase 1

  1. Create a mail account specifically for your new distribution – teachingarco@gmail.com
  2. Create an account on github
    1. Enter username matters – it will be part of the url to navigate to your projects
    2. Confirm code via mail

Phase 2

  1. You can create repositories either private or public. If you want to create a package repository for pacman you will need to make it public.
  2. We make our code publicly available.
  3. The default branch name these days is main.
  4. We git clone the repository we have created to our computer.
  5. There is a hidden folder in there. Check the config file in .git. Nothing to change at the moment.
  6. Gitignore is an interesting file to learn about.
  7. We get the three files we need from a working repository.
    1. setup-git-v5.sh
    2. up.sh
    3. README.md
  8. We change the content of these three files – this is important!
  9. We go over the changes in setup-git-v5.sh.
  10. We go over the commands in up.sh.
  11. We explain that scripts need to be exectuable
    1. chmod +x to make executable
    2. chmod -x to remove executability
  12. We push online for the first time with the script up.sh
  13. We shoud first (one time shot) run the setup-git-v5.sh.
  14. We push again and read the message
  15. We get a key fingerprint question and we say “yes”

Phase 3

  1. We activate the two factor authentication layer to sign in into Github
  2. Install google authenicator or other apps to authenticate
  3. Scan the QR code that is shown on the github page
  4. Test the login process

Phase 4

  1. Go to your settings on github and look for SSH and GPG keys
  2. Generate a SSH key – follow the text on github
  3. Copy/paste the content of the pub file into github
  4. Generate a GPG key – follow the text on github
  5. Popup for the passphrase matters – never ever forget the password!!
  6. The created pgp public key block is also copied in a file for my personal convenience
  7. Copy/paste all code from the terminal starting with “—- BEGIN PGP PUBLIC KEY BLOCK ” till it ends with “—END GPG PUBLIC KEY BLOCK —”  into github
  8. We push the data to the internet after setting the SSH key and the GPG key

Phase 5

  1. Keep the sources you find safe for another day
  2. We want to have a package that contains our current look – our dot files
  3. We copy/paste the .config over and eliminate the elements we do not want on our future system
  4. Use Disk Usage Analyzer to decide what you need or have to remove
  5. Listen to the reasons why I am removing or keeping files and folders
  6. We rename our project – adding prime to the end everywhere so we can make multiple designs
  7. We explain that we have the opportunity to use this repository when we build an iso – using the personal folder

Cleaned the names and code up a bit after creating the videos.

Setup.sh is a nicer name.


Here we continue to teach for isobuilders


Phase 6

We want to share or install our config
We want to be able to do “sudo pacman -S …”

  1. Copy/pasting the code in the .config folder can always be done but can it be installed via Pacman
  2. Learn from the PKGBUILDS from others like ArcoLinux
  3. We get one of the PKGBUILDS and start changing the lines for prime-xfce-git
  4. We create a new github repository for prime-xfce
  5. First run setup.sh then run up.sh in that order
  6. We use parameters where we can to be efficient
  7. The readme.install file shows info to the user when the package is installed or upgraded
  8. My preference is to mimic the structure of Linux so we change the github to /etc/skel/.config
  9. We have a package now called prime-xfce-git-…-pkg.tar.zst

Phase 7

Let us create a repo to host all our packages on

  1. Organize and name your folders with the future in mind
  2. We create a repo on github called prime_repo (note the underscore!)
  3. We learn from the nemesis_repo
  4. Go to settings on github and look for pages – but first we need to push something online to be able to select main there
  5. We create the repo locally. The folder x86_64 has to be created for pacman.
  6. Use the three maintenance github files again to push the data online
  7. Since this is a repository we need to add update_repo.sh as a file and in the up.sh file
  8. Make the update_repo.sh executable and edit the file to reflect your repo name
  9. Now we can go to the settings on github and set everything right for pages.
  10. We need to test that it works
  11. We add a few lines to /etc/pacman.conf via ATT we found out how it is done for nemesis_repo
  12. We copy/paste and change the lines for prime_repo
  13. Type “update” and see if pacman finds the database
  14. We create a new repository to keep track of our PKGBUILDS as well

Phase 8

Building an ArcoLinuxS iso with our prime Xfce package

You can add your personal repo to any Arch Linux based system

  1. Let us build an ArcoLinuxS iso and add our package prime-xfce-git to the iso
  2. We git clone the ArcoLinuxS iso to the desktop
  3. We add our prime-xfce-git to the bottom of packages.x86_64
  4. We add the two lines into pacman.conf so pacman knows where the prime-xfce-git package is
  5. Then we get rid of the conflicting packages
  6. We update our choices of the prime package as well, upload it to github and build a new package
  7. We realize we need to add the arcolinux-arc-dawn-git
  8. At the end you can see what changes we have made with gitahead
  9. The strange behavior at the end was because we needed to update our machine and reboot


Phase 9 – why not use the /personal folder

You can add your /personal folder to any ArcoLinux iso

In this video, we introduce a new article focused on leveraging Git for managing and backing up configurations for various window managers like XMonad, BSPWM, and i3. This guide is essential for anyone looking to preserve their custom configurations or adapt and share scripts like the ArcoLinux Nemesis scripts. The tutorial emphasizes using secure methods like SSH and GPG for connecting to GitHub and implementing two-factor authentication for added security.

We walk through the entire process, starting from creating an email account for GitHub registration to setting up a repository and explaining every step in detail. The guide also covers how to manage files, with all necessary files included for ease of reference. The tutorial is divided into phases, including setting up GitHub, securing the connection, and managing two-factor authentication, with an emphasis on the importance of security in these processes.

For those who find the process daunting, there’s an easier method highlighted for transferring configurations directly onto an ISO, bypassing the need for complex GitHub or GitLab setups. This alternative method involves using the “personalfolder on ArcoLinux ISOs to include your custom configurations directly.

Overall, the video serves as a comprehensive guide for managing and backing up configurations using Git, with additional tips for those looking to incorporate their customizations directly into ArcoLinux ISOs. Whether you’re a seasoned developer or a newcomer to Linux, the tutorial provides valuable insights into securing and personalizing your Linux environment.

Phase 10 – create your own mirrolist

I have more than one source – github/gitlab/bitbucket/…

The discussion revolves around a scenario where the prime-repo is simultaneously hosted on Bitbucket, GitLab, and GitHub. The challenge encountered is that Pacman, the Arch Linux package manager, is unable to distinguish among these three databases due to them sharing the identical name, leading to potential issues during package downloads.

The proposed resolution is the introduction of a mirror list. This approach facilitates specifying multiple sources for package retrieval, granting users the autonomy to select a source or allowing for an automatic alternative selection if the primary source is unavailable. The speaker recommends naming the file in accordance with the distribution, opting for “Linux Prime” in this instance, and proceeds to demonstrate the process of crafting and populating a mirror list file with URLs from the three repositories.