Bog - An overview of life in the terminal

Disclaimer

This is by no means a tutorial nor is it meant to be comprehensive in scope, this is purely my opinion on what it means to live (mostly) from the terminal as well as some tools that I would consider necessary to do so. As well as some tips for said tools and some fun things.

Again, this is NOT a tutorial or anything of that nature. You should always do your own research on this stuff and experiment in a virtual machine or some other safe environment first. Alright, with that out of the way I feel I should say that I will be providing links to videos and homepages of tools as I mention them in case you’re interested in that specific thing.

Also, the entire inspiration for my whole setup and what got me into terminal things and made me realize that it was viable in the first place was this video which I highly recommend if you need some inspiration and/or are a terminal beginner.

The philosophy of the terminal life from my perspective

If you aren’t a daily terminal user you may be wondering why anyone would want to spend most of their time using a computer in this mythical, intimidating black box that usually only shows up when you’ve fucked something up big time. Like most things in life, if it’s scary that’s probably just because you don’t understand it and in the case of the terminal, once you take the time to learn how to use it it can be very productive and frankly safer than GUI things.

Which leads me to my first belief when it comes to the terminal which is: working with something at a lower level and having a better understanding of what’s going will make the experience overall more pleasant and productive. To go back to the GUI thing, since you’re aware of what’s going on and are typing at least most of the commands when using a terminal as opposed to just seeing a green progress bar as the program works in the background you’ll be able to catch execution errors early if you’re paying attention then stop the process which could potentially save a project. Another point that I think is important is that since you have a general idea of what’s happening and have some control over the process you can probably cut out some extra steps which then saves time.

My second belief when it comes to the terminal is: having some sort of constraint in your workflow (the terminal is a vast ecosystem and doesn’t really fit this but the thought still counts) will force you to either learn a new way to do something and/or think of a creative way to solve a given problem. Who doesn’t love learning something new or sharpening those creative/critical thinking skills? Personally, I’ve found that trying to restrict as much of my workflow and life to the terminal as I can has lead to discovering many tools which I never would have found otherwise which in turn has lead to more productivity (when I actually do things) and overall just a more fun computing experience.

My third belief when it comes to the terminal is: it’s fun! Being able to have a simplistic (on the surface) interface for the computer that you can pretty easily learn how to use and build your own tools for is a wonderful thing, and is something that just doesn’t really work with GUI stuff as much.

Here’s a tl;dr list.

Having a deeper understanding of a tool/system is safer and more productive in the long run over initial ease of use.
Constraints allow for (and sometimes even forces) more creativity and learning opportunities which is good.
It’s fun to have an easy to use hard to master tool that will be on pretty much every system you’ll ever touch.

Essential terminal tools in my opinion

As with any workflow, there is a base set of tools that most people would consider necessary to complete the job. Below are the things that I consider essential and will be talking more about, these are not the be all end all for what you need so again, do your research. However, I think these are sensible starting places for most people.

A terminal emulator of course. A terminal emulator is just as it says on the tin, it’s a program that emulates when computers were terminals connected to mainframes and allows the user to interact with a computer on a deeper level by giving commands to a shell.
tmux is a terminal multiplexing program that will supercharge anybody’s workflow once they learn the basics of how to split panes and stuff. It is also a session manager so you can setup a tmux session on a remote machine, ssh into that and do your thing then turn the local machine off which normally will mean you have to ssh back in but with tmux you simply run tmux a -t <session name> and you’re back on the remote machine.
vim (which stands for Vi IMproved, and is an improved version of the original vi program) is a highly configurable and extensible, lightweight text editor. This is where I and most people will be spending most of their times if they are a developer. There are alternatives to vim such as emacs, helix and many many more but vim is a pretty standard choice.
fzf is what’s known as a fuzzy finder, which just means that it will search for all results containing any combination of the characters entered but giving precendence to results that match the input closest. This specific fuzzy finder is very popular and can do a lot of things.
dmenu is “a dynamic menu for X… It manages large numbers of user-defined menu items efficiently”. In practice it is essentially a scriptable application finder which is very useful.
If you are a developer then you will want a compiler for your language of choice if it’s a compiled language, I write mostly C so my compiler of choice is gcc. I won’t really go too much into this since if you’re a developer you already know all the tools you need to make programs and if you aren’t then you’re better off looking up the setup for your specific language.
Once you’re sucked into the terminal you’re going to need to know your way around, which 99% of cases will mean having basic bash knowledge. There are alternative shells such as zsh and fish but a majority of systems will be running bash (which stands for Bourne Again SHell if you were curious, and is an improvement of the original SH).

Terminal emulators

Options

There are lots of options available for what terminal emulator to use, and I mean alot… like almost 50 according to wikipedia and there’s probably many more not on that list.

It doesn’t really matter which one you pick but kitty/alacritty are popular choices that also support images right in the terminal!

What I use

Personally I use the st and it’s been great for the last ~2 years. As for reasons why I use it, I got sick of xterm and since I was just starting learning C at the time I figured it would be a good choice since it’s written in C and is easy to extend once you know what’s going on. It’s also fast and lightweight which is always a plus.

Bash tips

You can use bash as a file browser pretty easily (thats what i do) with the variations of the ls command and the cd command (note that these commands can be run from any folder to operate on any folder as long as you have the path and permissions) i.e.

$~:ls ## this shows the current directory (folder)
 blog                 Downloads        personal      tmux-client-2167.log   winsc
 builds               ghidrastuffs     programming   tools
'COGMIND (Beta 15)'   ly-session.log   streamstuff   vimstuffs
 Desktop              Music            test.mp4     'VirtualBox VMs'
 dotfiles             Notes            tidal         win10

$~:cd blog/ ## this moves into the specified directory

$~/blog:ls -a ## this shows all files including the hidden ones (commonly called dotfiles as they start with a .)
.       commands          dist-newstyle  .gitignore  .jj        notes           site.hs
..      configuration.hs  docs           images      .jjignore  posts           tags
_cache  css               .git           index.html  LICENSE    progblog.cabal  templates

$~/blog:cd images

$~/blog/images:ll ## this shows all the important metadata of the files in the current folder
total 44
drwxrwxr-x 2 void users  4096 Aug 10 18:23 addingfeatures
-rw-r--r-- 1 void users  2908 Aug 10 18:23 base.png
drwxr-xr-x 3 void users  4096 Sep  2 22:26 boottimes
-rw-rw-r-- 1 void users  1054 Aug 10 18:23 codeberg32x.png
drwxrwxr-x 4 void users  4096 Sep  3 22:25 questforsub1g
-rw-r--r-- 1 void users  2130 Aug 12 17:41 signpost32.png
-rw-r--r-- 1 void users 11375 Aug 12 17:41 signpost96.png
drwxr-xr-x 2 void users  4096 Sep 13 19:52 termlife
-rw-rw-r-- 1 void users   538 Aug 10 18:23 twitch48x.png

You can move/rename files and directories by using the mv command, which also supports recursive operations with the -i flag i.e.

mv file1.txt folder/file1.txt ## move a file
mv file2.txt ./file21.txt ## rename file
mv -i folder/ newfolder/ ## move all contents of folder to newfolder

The tree command is another good one to know about, it’s like ls but displayed as a tree which some people find much easier to read, and since it’s recursive it allows for very easy viewing of a directories structure i.e.

$~/blog/images:ls
addingfeatures  boottimes        questforsub1g   signpost96.png  twitch48x.png
base.png        codeberg32x.png  signpost32.png  termlife

$~/blog/images:tree
.
├── addingfeatures
│   ├── hakyllmain.png
│   ├── hakyllrss.png
│   └── hakylltags.png
├── base.png
├── boottimes
│   ├── boot.svg
│   └── part2
│       └── newboots.svg
├── codeberg32x.png
├── questforsub1g
│   ├── p1
│   │   ├── 17g.png
│   │   ├── 28g.png
│   │   ├── 699.png
│   │   ├── 796.png
│   │   └── 995.png
│   └── p2
│       ├── largevim_browser.png
│       ├── largevim.png
│       ├── largvimguibrowser.png
│       ├── nolsp.png
│       └── smallvim.png
├── signpost32.png
├── signpost96.png
├── termlife
│   ├── newsboatfeed.png
│   ├── newsboatpost.png
│   ├── newsboatsel.png
│   ├── rmpc.png
│   └── weechatstart.png
└── twitch48x.png

8 directories, 25 files

grep is something that I don’t really know/use enough to talk about but it is very handy when you need it so look into it if you often do things with multiple files at once.
Creating little scripts in bash is pretty easy, just make a .sh file and script out whatever you need it to do. I personally use bash scripts to display and send notifications for my laptop battery percentage, here is the script to send the notifications

#!/usr/bin/env bash
chars=",%"
export DISPLAY=:0
PERCENT=$(acpi -b | awk 'NR==1{print$4}' | cut -c 1-3 | sed "s/[$chars]//g")
 if [ "$PERCENT" -lt "50" ];
 then
	 if [ "$PERCENT" -lt "25" ];
	 then
		 notify-send -u critical "Battery" "Battery below 25%"
	 else
		 notify-send "Battery" "Battery is below 50%"
	 fi
 fi

You can use pipes to chain commands together, a common one is ls <folder> | grep *.<extension> to show only files with a desired extension in the specified folder. There’s way too many things you can do with pipes for me to talk about so look into that as it’s incredibly useful.
If you ever need to know what a specific command does you can check the man pages by typing man <command> and if it has a man page it will pull that up so you can read all the things that it does. I recommend piping that into less so you can actually read it in a way that’s not horrible if you haven’t changed the default pager.
You can customize bash by modifying the ~/.bashrc file, you can set aliases, path options, and custom functions. This is another thing that’s way to much to talk about here but definitely worth looking into.
To read any text based file you can use a pretty easy to read combo of cat | less and if you want just the top or bottom of a file you can use head or tail respectively (head and tail have a few flags, the most common one being the -n flag which lets you specifiy how many lines to show) i.e.

$~/blog:head index.html
---
author: ThePragmaticProgrammer
---
<body>
  <h1>Welcome to pragprogs hodgepodge Blog Bog!</h1>
  <h2>Recent Posts</h2>
  $partial("templates/post-list.html")$
  <h2>Who am I?</h2>
  <p>Hi! If you're on this page then you probably know who I am, but just in case; I'm ThePragmaticProgrammer (aka pragprog because that's an obnoxiously long name lol), a sarcastic and dry {take
your pick of the following}:</p>
  <ul>

$~/blog: tail index.html
  <h2>What do I do?</h2>
  <p>Officially, I am a programmer/electronics nerd who occaisionally plays chess and/or video games on livestream at a little unknown website called <a href="https://twitch.tv/thepragmaticprogrammer">Twitch</a>. Unofficially, I also enjoy consuming/creating music/books/writing as well as working out when not studying.</p>
  <h6>find all posts in the <a href="/archive.html">archives</a>.</h6>
	<footer>
          $if(author)$
              Written by $author$
          $endif$
          Generated using <a href="https://jaspervdj.be/hakyll/">Hakyll</a>
	</footer>
</body>

Something I didn’t find out about until recently was how to pause a process. You can do this by typing “ctrl-z”, similarly you can use “ctrl-c” to kill a process, on a running process. This is handy if you want to check the state of something during execution or simply need to be there to monitor and have to get up to do something then when you’re ready for it to start again you type “fg” and it will resume running.
You can use the - argument in the cat command to send the process to STDIN for user input.`

tmux tips and tricks

By default tmux has some strange keybinds so I recommend doing the following:

Change default leader and split keys by adding the following to your ~/.tmux.conf file

# change default keybind to ctrl-space
unbind C-b
set -g prefix C-s
# change defualt pane split keybinds
unbind v
unbind h

unbind % # split vertically
unbind '"' # split horizontally

bind v split-window -h -c "#{pane_current_path}"
bind h split-window -v -c "#{pane_current_path}"

If it’s your thing you can also set the tmux history search thing to have vim mode bindings by adding set-window-option -g mode-keys vi to your config.
You can of course customize the appearance of tmux which I won’t talk about but here’s the colour palette that tmux uses by default.
A cool thing I found out a month or two into using tmux is that you can display script outputs in the status bar, which I use to display the percentage and estimated time remaining for my laptop battery but you can use it for whatever really. Below is the ~/.tmux.conf line as well as the bash script and then how it shows in my tmux status bar.

set -g status-right "#[fg=colour13]  %d-%m-%Y %H:%M | #(~/programming/bash/bat.sh)"

#!/usr/bin/env bash
chars=", %:"
if [ $(acpi -b | awk 'NR==1{print$3}') = 'Not' ] ; then
	chargestate=$(acpi -b | awk 'NR==2{print$3}' | cut -c 1-3)
	charge=$(acpi -b | awk 'NR==1{print$5}' | cut -c 1-4 | sed "s/[$chars]//g")
	bat=$(acpi -b | awk 'NR==2{print$2}' | cut -c 1-4 | sed "s/[$chars]//g")
else
	chargestate=$(acpi -b | awk 'NR==1{print$3}' | cut -c 1-3)
	charge=$(acpi -b | awk 'NR==1{print$4}' | cut -c 1-4 | sed "s/[$chars]//g")
	bat=$(acpi -b | awk 'NR==1{print$2}' | cut -c 1-4 | sed "s/[$chars]//g")
	etr=$(acpi -b | awk 'NR==1{print$5}' | cut -c 1-5)

fi	
if [ "$bat" = '0' ] ; then
	if [ "$chargestate" = 'Cha' ] && [ "$charge" -gt 80 ] ; then
		echo "fully charged"
	elif [ "$chargestate" = "Cha" ]; then
		echo $charge% Charging
	else
		echo $charge% ETR:$etr
	fi
else
	if [ "$chargestate" = 'Cha' ] ||  [ "$chargestate" = 'Ful' ]  && [ "$charge" -gt 80 ] ; then
		echo "fully charged"
	elif [ "$chargestate" = "Cha" ]; then
		echo $charge% Charging
	else
		echo $charge%
	fi	
fi

Another super helpful thing you can add to tmux is the tmux-resurrect plugin which lets you save and reload tmux pane layouts. This can be done by adding the following to your ~/.tmux.conf file, keep in mind that you will need tpm installed for this to work.

# load TPM at start
run '~/.tmux/plugins/tpm/tpm'

# plugins
run-shell ~/.tmux/plugins/tmuxres/resurrect.tmux

fzf tips

You can hook fzf into vim by using the fzf.vim plugin which lets you do all the fzf stuff straight from vim! You can do this by adding the following two lines to your vimrc plug section if you use vim plug Plug 'junegunn/fzf', { 'do': { -> fzf#install() } } and Plug 'junegunn/fzf.vim'. Personally I use it mostly to see what files are in a git repo exclusively and to show the buffers open, as shown below.

If you have ripgrep installed you can use that in fzf instead of grep to make it much faster, simply add the following to your bashrc. This will also show files in gitignores and hidden files.

if type rg &> /dev/null; then
  export FZF_DEFAULT_COMMAND='rg --files --no-ignore-vcs --hidden'
  export FZF_DEFAULT_OPTS='-m'
fi

By default fzf is hooked into your bash history so you can hit “ctrl-r” in a terminal window to fuzzy find through your bash history which is very handy.

fzf going through bash history, note that the artifacting is a result of converting to gif and making it small not fzf

This is a great blog series if you’re interested in doing more stuff with fzf.

vim tips and tricks

Quickfire round of useful but basic commands:

the “*” and “+” registers are the system clipboard registers which you can paste to and from in vim or other applications.
use :s find and replace stuff (.,+/- for from current line i.e. :1,10s/<term>/<replacement>/ for lines 1-10 etc. Optionally, you can add a /g to change all occurrences in a line).
you can search forward and backwards in a line using f/t for forward and F/T for backward, where f/F includes the search term and t/T does not.
you can search forward through a file with / and backwards with ?, note that you use n and N to move through the matches (also the same when using f/t searches).

The talks from thoughbot are often great vim resources for learning niche little things. One I watched recently that was quite good was this.
If you plan on using vim then I would say it’s absolutely required to learn vim motions, there’s lots of resources out there for this but some of my favourites are this stackoverflow article and learn vim for the last time… there is of course also the built in guide you can access by typing :Tutor.
You can set persistent undo in vim by adding the following to you ~/.vimrc file set undodir=~/.vim/undo and set undofile which when combined with a plugin like mundo lets you see and navigate through a files change history, just make sure that the ~/.vim/undo file actually exists.
Vim is very customizable, in the ~/.vimrc file you can set pretty much every behaviour of vim and set custom keybinds, this can be a bit finnicky if you do it wrong so make sure to read about how to do it.
Vim has a huge plugin ecosystem so I won’t dedicate too much to this as there are so many but the ones I would recommend to get a developer friendly environment without becoming hugely bloated are vim-lsp, asyncomplete-vim, and vim-gutentags. Again there are a ludicrous amount of plugins available so look around for stuff that suits your needs, also basically anything by tpope is worth having.
You can use vim as the pager for man pages which is even better than piping it through less as you have sytnax highlight as well as full text search. You do this by adding the following to your ~/.bashrc file, export MANPAGER="vim +MANPAGER --not-a-term -".
I don’t know enough to talk about this but the quickfix window is incredibly powerful, especially if you want to make plugins, so I would recommend reading into that.
Netrw seems to get a lot of shit but you can have a pretty usable experience by adding the following to your vimrc, this will make it kinda like a kneecapped NERDtree but it also is much smaller so if that’s what you care about (like me) then this is a good compromise.

let g:netrw_liststyle = 3
let g:netrw_browse_split = 4
let g:netrw_winsize = 15

You can add tabs to your vim by running :tabnew and then switch between them with “gt” and “gT” in normal mode.
A very useful thing you can do in vim that’s not really talked about when looking up vim guides is you can paste results from outside commands with :read.

vim reading from outside and pasting into buffer, again the artifacting is from the gif making process

dmenu tips

I originally had more of a section planned for this but I realized I didn’t have much I could say about dmenu since I haven’t messed with it too much so here’s a video showing some stuff that dmenu can do.

basic jj workflow

jj is a git compatible version control system that’s so far been way more nice to use than git. The basic workflow is as follows:

jj git init to create a new git AND jj repository in the current folder
Changes are saved automatically so simply start editing files, no need to git commit every time you do something
jj git export to send any changes made to the git version of the repo
You can view commits/changes with the jj st and jj diff --git commands
Pushing/pulling from a remote source is a bit more complicated but here are the commands

jj bookmark set --revision @ main --> set head to most recent
jj git push -r @ --> push to main
jj git fetch && jj rebase -d main --> equivalent to git pull

There are many more commands to jj naturally so if you’re looking for a git replacement that’s compatible I recommend looking through the docs for jj and giving it a shot. Also to stop tracking a file you add it to the .jjignore file and then run jj file untrack <filename>.

internet things

You might think that using the internet would be impossible from the terminal but that’s actually the opposite! The internet was originally created on terminal based machines (by internet I’m referring to any interconnected LANs/machines that are not in the same building i.e. bbs).

Web browsing

For web browsing you have a few options, I use w3m but there is also lynx, links, eww and probably many more. One really cool thing about w3m is that you can have not only inline image support on most modern terminals but also external browsers for say, watching youtube videos or viewing images. To do this simply go to your w3m config which is usually ~/.w3m/config and add the following:

# enable video playback
extbrowser mpv -ytdl --vo=gpu --ao=alsa
# open images
mailcap /home/void/.w3m/mailcap, /etc/w3m/mailcap, /etc/mailcap

Then in the same folder make a mailcap file and add the following, replacing sxiv with your image viewer of choice.

Image/Gif; mpv --loop '%s'
Image/svg+xml; krita '%s'
Image/jpeg; sxiv -s f  '%s'
Image/png; sxiv -s f  '%s'
// you can also add the following line to open pdfs, replacing zathura with your pdf reader of choice
application/pdf; zathura '%s'

Like most things in this post, w3m is of course completely customizable via those two files so look around the docs and change keybindings and such to your liking.

RSS news

If you want to keep up with news but don’t like GUI web browsers or just find news sites to have too much bloat then most blogs and news sources also have an rss feed integration (including me) which essentially just takes all the text and images from a post and saves it in an xml file for viewing from something like a terminal.I use newsboat for my terminal rss reading but there are a few others such as nom as well as GUI apps like fluent reader and akregator. I do most of my rss reading on my phone but adding a feed to newsboat is dead simple, just open the ~/.newsboat/urls file (or make one if it doesn’t exist) then slap that rss url in there i.e.

https://progblog.pages.dev/rss.xml
https://hackaday.com/rss.xml
https://news.ycombinator.com/rss

Once you have some feeds, you can open the program with newsboat and then pick your feed from the feedslist.

It’s pretty hard to read on my terminal but the bottom row has keybinds for operating the program. Most importantly are “r” for refreshing the source which will unsurprisingly look for new posts in that feed and “ENTER” to select items.

IRC

For IRC I use the wonderful weechat client. IRC is a deep rabbit hole that I don’t really know enough about to go into but if you’re sick of big corporations training A.I on your chats and/or stealing data from your chats look into it. It is not really secure by default but it’s decentralized so that’s the main appeal of it to most people I would think. It also has bridges for a whole swath of programs including slack, mattermost, matrix, and discord. Also, if there’s no bridge for a chat app that you use you can make one!

Weechat looks a little daunting at first but you have the main buffer on the right which is where all the messages will go and then the buflist on the right where all the servers you are connected to go. There is also usually a nicklist, a list of everyone connected to the server, on the right but I have disabled that to save screen space. Weechat also has a really good quick start guide.

fun stuff

This is the section of things that I find fun and use regularly but that aren’t necessarily related to development or are not really specific to being terminal based but still make the experience better.

mpv + streamlink + your IRC client of choice = the best twitch experience. There are a few alternatives such as streamlinkerino or grabbing the web socket stream directly with vlc but this is probably the easiest setup to use. Here is a guide on how to connect to twitch chat using IRC. Some popular clients are halloy, weechat, and irssi. Setting any of them up is beyond the scope of this post but it’s pretty easy after some searching.
terminal.sexy is a website that lets you create terminal colour schemes either manually or with the ever helpful randomizer. If you want to change the colour scheme of your terminal or terminal app (i.e. vim) but don’t have any ideas or you’re like me and don’t know colour theory then this is the place for you, it even has a preview of what the colour scheme will look like in the context of a text editor.
terminaltrove.com is a collection of terminal based apps, so if you’re looking for a popular terminal app or want to find apps written in a specific language then you can probably find it here. Obviously it won’t have every app ever made or anything but it has a good selection and search/filter options.
If you’ve read my previous posts then you should be aware of syncthing and what it does, but if not then here’s a quick overview. Syncthing is a free and open-source file synchronization program (think Google cloud or dropbox) which I highly recommend using over both of those since it’s fairly simple to setup and has been a wonderful experience so far, it also happens to pair very nicely with my next point. One thing to note, syncthing does not have an official android app anymore however there is this which I have been using and seems to be perfectly usable.
Markdown notes have personally been a game changer for me since I started using them a couple of months ago. Having all of your notes in an easy to read and purely textual format that’s standardized and easy to share across devices is a huge QOL thing and very convenient. Markdown is also incredibly easy to learn and basically every device will have some form of markdown viewer availble.
Using mpd + rmpc is a great way to add music player capabilities to your terminal, there are other ways to do it such as ncmpc but rmpc has been great so far for me and is very customizable. Bread on penguins has a great video going all of the features and stuff if you’re interested. Also here’s how I have configured mine to look, note that I haven’t changed any of the keybindings

Tiling window managers such as i3, xmonad, sway, bspwm, etc are a great addition to your setup if you want to maximize your screen real estate and want to get rid of the pesky mouse. They are a bit of a trip to learn since they offer completely keyboard based navigation but once you get used to it it’s not that bad and they are almost all completely customizable with some even offering the ability to make layout templates.
scrot is an easy to use command-line tool that lets you take screenshots (full screen)/screengrabs (smaller sections of the screen) very easily, it supports countdown timers and different file formats but I don’t use the timer feature and have only saved them as png files so I can’t speak to how well those perform. Setting it up to take a screengrab is super easy, just setup a keybind or run the following in the terminal scrot -s and your screen will have a gray overlay in which you click and drag over the spot you want to capture.
zathura is a general purpose document viewer with support for a whole bunch of things such as pdf, epub, djvu and more. It is intended to be used mouse free and by default has vim keybinds for navigating documents as well as a vim like command line accessed via the colon key. It is also incredibly fast and customizable, I definitely recommend checking it out if you read pdfs or other things like that regularly. I am not sure how it is for editing said documents as I don’t do that but for reading it’s great. By default the theme is pretty harsh but you can copy a theme from here or make your own completely custom one pretty easily.

Conclusion

As is tradition, thank you for reading! This post was my longest to date and also my least focused post so hopefully it wasn’t a mess to read :eek:. I hope this post was able to inspire you with some ideas on configurations or tools to check out with your terminal if you use it and/or inspire you to give learning how to use the terminal a shot! I promise it’s not that scary.

At the time of writing I don’t have the table of contents thing working yet because apparently that’s the hardest possible thing to do in Hakyll (probably not but it’s not easy) however I have added some QOL stuff which includes:

Proper syntax highlighting on all posts
An estimated reading time calculation
LaTeX rendering (mostly, defintions/lemmas/proof sections don’t work) with MathJax i.e. \[F(x) = \int^a_b \frac{1}{3}x^3\]