Merge remote-tracking branch 'refs/remotes/origin/master'

13 files changed, 1292 insertions, 190 deletions

diff --git a/README b/README
index 0a61f9c..f70ea15 100644
--- a/README
+++ b/README
@@ -53,3 +53,7 @@ For a generic new host HOST:
 On Debian:
 
 sudo useradd _greetd video
+
+sudo ./etc/resolv.conf
+
+edit etc/network-setup.sh and run it
diff --git a/dot_config/encrypted_private_wpa_supplicant.conf.tmpl.asc b/dot_config/encrypted_private_wpa_supplicant.conf.tmpl.asc
index 218fcc9..d1d2b5c 100644
--- a/dot_config/encrypted_private_wpa_supplicant.conf.tmpl.asc
+++ b/dot_config/encrypted_private_wpa_supplicant.conf.tmpl.asc
@@ -1,69 +1,70 @@
 -----BEGIN PGP MESSAGE-----
 
-hQUMAwAAAAAAAAAAASf/S6S70ZhfQb3df8ySmOX8+JA/9/tsGPiO5JYN3xpZeziJ
-DnJtR1G4y1wkNAyESKnZsdV/ZYzyFKJQuk2xx4j6u/0ndgk2BNHvinv6dU+y+9KS
-zyFgTgaFOD3UtozkUI2UayC8tFSe0XjxSVbxnx6A5M4zwK6j2TIwSY4bcrmLs3lU
-a2FV9ieJUsyu0HG2KUGhPE493f5ppBUwdzd+qTDUXZi00STK7m0wUPcuItFpQdRh
-otdAR9EA/wR1EqM50n3f1vZ8O6x2AVAzR9sTUnU2xk+BHsRIgabPafB4MbSa8PyF
-XNieKrlBZUwGNnFiR8j3MYr4ZCyd00T8dlwabAyCIF7Nr/pgoLjCDA0RZE+ymCE+
-2BMV/kW46f9qrCBox7Djhb4niIOwV1qpWehdv8IxFDqSyWnmH2qZD8VsiUiUx8+P
-Pi3u7HJcC7Vx0Gwu3LXPIFsobaIFJd23Bmw7zkkX+th0WjmlsEfwtAaTb78Y5ChC
-b5otYAY59j12cYxlxfihAz8yFz7Rxd42B9PuImy4X98pQWJ+tCUTLPsBBhvkk1ni
-s9Rbb2A7QKIAcxSageN384eMk3ElLR/wOVQzyZus5m26hMmSb0stpaSmNwlOPkmk
-jJxs0B3G2t1vPotPdDsNq159V3HPxIhK9660GGYY2dRhucRa/kn5efYfLuEnmbcw
-GV2C+lGwkT9AbTMu2GAnV6sY2ZaFE+DPdWPAh0y9kixRZjiJqC1fnkZ8S317DBtu
-AP7OHkyVo2zFQT7E7TtuZHa7UEoeVv31fm6XLR4lKUohrpZy15ZPxk7LFyM6Ccwr
-AGNbY0Yf8mMXOE+VXaXyJXoot1GjiyOVYOPMZq57N5MHkt7mtVPIRbKbY5fGDCZi
-eQn5De9w7v5ZTBkl47VSwQ5cpLEs+dhLrhTBn+EclQ/DwUrD+fqu7WBKLxbcTJk9
-+IqfTRr68W+rfMrLrAwML4OdAsEq2jg1VQe87pgboa2MXqmtyg90aRtUe/cMKA1C
-+zt2/NWr0TFnGYBEWzvFF1/dTp2z0h7TKYJC7r0ZQz6BhKHc3nZOID8oy4AzBm29
-ggLnwZd4xPlGVbWEpNwWVtLbikvwvGnlOqMzbfC36hv2wWcCSnosB9zVTApP/dHT
-hqK889m1bpmjzbSv1fmNEoDAsuKseXXaRSFWYlX9XpaDNYnV87TLjx1Ta+TEIlam
-ZMjcYbqDI4g0hMM70abs0Owk6WbNFycZFURFUySJW9QTDtGvybNIZmJwO49hswQp
-HiJbi+h56dN6idWZzoy9eJkzEnTSjB23E5KGCSewnr61LcPCr7J8gmynDO2jaG6n
-AlzIXe1E513A0BeHfHzxwD7sSQ9Uf3rt3dZNquiu1eRBU5X2DhON481Y+owYXBl1
-ntYlF8HhT/XhL3h9NfDKDC6I0ftcisWWTmJKiYeOFZyyL6dYYxUKyIJ1gJ6mr/Yg
-GCrCk4pizYnKx5UxrFpUOPjfTLGoGromdmjcqGDbLoX1274JClamqn2TqILqkM/g
-7QtWkT12bgQ0hLX9YaQUEPEmlCRxnT0rzNqo0f3PIxLrjqdU7wFY70kvoD1/4K97
-I1K9dybJ3NQaMbN12ZHS81XraQFXlKOC2QagxjQt0Eyp3PdkePxbr2MO1RiqCqdX
-LTFRjf57MjZaoVilyqIZDvmNA1PjOosm7gv8NozyH7irXkP3RTNjTc0BgJmJCkXS
-6gGnupCVClAw89pk7tXBCpGDP6r5db34RKI6q++RvxeK21v4s6NwuY2gQ+KltY1F
-C8Z0HWBWqAZCPtBmS6HNEkBXGj0n4gpSQROd7PWtm4R12ttYPcCK6MfvEvNRLepA
-g8234iOl55ILisLPT0nHU3mWeYFtfL7e8Ot59r4hyQTG8Mh7D3H9j+IEbnxIruaw
-kaT2BtVTpp9/0uqeYcVOe1tUQaw0TDlLYHJmb9+Juz/ObNMTyc8b3gfm1M1eYKL0
-1RjOv29YWVpQnuhs6vnVubwycJK2fyXuO+nR+1KEkE2gounbvnpYt1At4v+0J8qB
-sv7UmWgh0aROzMpG6zRX33wvEsaxehzgt4gqdpSYaLO/sVNNtSRD1foiJSj0TWKK
-xkEs6s1/c/UJkI+SriAGVe7adeQPliUENOfN/e0zUVGR1xe/7a3R+fuE5GSKwq0x
-NB9mKPmWl0BQTpoXPuxYC6JRTJsA1uya5vgM76IjUeRJNErs2f42o3YphC9xc2eE
-UagoeNBZlz5DdscTRtrbw8JHrR6kmOs4tWuo+f68MhzLpLDNsajxq4iW/GF1ZEjD
-hOrRNuk6HvOQDFplyunXnSnSqJ6oQvGYGjzp15NPN31NkjOeLbYSIOBEVoB2fn2o
-qRTB9mpK5VA40D+4Jxbm65imO6Y0jxazKcikL9ox11YKN7XJpBuf+Nf37PPleZzO
-TkCLoHyDe0pjqVEKoT9ipvqhtR1aoPnGQ1FtUK0WNaCuRb2aqP4EVkYDNV7atbpP
-lvCnWw1ey4SMw5aEi+B3VxS9FgcNhSvRDDrCmpoh4CjUehY3URKpwtXeYFPCDoMf
-IYillLTgbaRqfa74/n8lwMLi22j+pBOyiUg1cTH37gs2jgPIXD4spnCPfxhvVp+y
-BOtoXPOlUptRGyrnmVRodz5ZlUQV+8mI2JpvFkYS0BvhjuEZbxywZHZHSNbEOmRJ
-sz1qZ9GjnDaS8+pF9kP6+RiM1xJPf0F2zl2jlCRMS7FfFEl57Hvfi++tdkeBnQb0
-gvnPF11Q40X8bVg01PtV5Zk2uZ4DHVRFpWw3S1cyWxykakSAj1gc8MsWDdmwMBKH
-U4v+/VD8IHGKk7oMdf9ueVqQUOv0KzeasR9TsC4GxbMOqfj/qmgawg5jhUln9q+v
-Gsbeh3gIrOQzwm3NeXccSEVuf2bIqiRa8UXQwZPCoP+wK8RXcdoEKT1DR/S3UKGx
-JasTGGdavniZbmWgEDbzn5WuteOcisx4G7sGodatin/FtJTlvCtINXLYMVdwzHE5
-2RAO73Bq4Jk6FPYBHbn6eD53SO7iXFLhqDuIJRPMh23KDcvQ5WeeleBEZZzKea/+
-sjlA1fWN2eM2WjMwwTkFAhXpUR5CBFDKfyo+MSneIcAiXbID055v12eJTzc5fd9x
-WBChONEC6EakDBjnNa6+ezuBcDXkcGnOfuFktB2lwCVuHsmppvD/TPnfLCaCefXV
-bCeyZsoXr3H/bSYqZPEzErglajcDuknFvvRMeXFt6PEapj2R1vGswvaN0dA7r5CN
-oH6rQXA7ZroTwmT+bDh7//hACiiKlDv2Ity4HaHRixvFhlV9mXZvPZSmt+cyZdSH
-g/C7+sxHRwf+rsK5LUr18pG9E65OhVlTTXKG1UwLxsQSfRVl0ubrEe8POPYT3cEm
-8bAUFDptGbcnVPJ2UKDYSog1PKew47mgNEfJp5XMAy3+nwH/HYFPKp6l9Tsz0bXf
-oYnWQah3Dk97utJOZq5WrDrK4tKjyyrqUaTBwHm8g8usnTKoMgBZBMGJo7hORZ45
-k0OQl5GPkLp8UDRaTmwpPfeBVPidBS9gSaMQd9AiIbxYSvSPsp4d0PK5DHKvUviR
-nOSrECvA+WoL19HqXxdI110+M4/uH+iU1eFGbOS8bbX/TQcoqif7Cem7jkgIlCvw
-r2BUVV3+tMHH+B1vTjUuS0xSq+7ks1P6ANSLOXVazwHgB76SAX3rWJ/4r9+tGJpA
-oSIdRIbdOO15d2W9CP/JZD1htBT+mkbzkLH0CDYx/ek6DuWI1DsbthBzWwVp1D03
-TAnAW5we3eWBke2Bloa+wb9fwn+ufs8OwdAkhTUr6wKnJXTgpNjOf3p4xrXjPSAs
-3KM+V/3nn3lgqRO1V/zE1xiXJh07CqjTG/wwknhG/6Xcwg68Rfb40fCuLbvGOwwD
-Uw0l9TnFLkGFuL9nCtMf+Y4rvdNiYqjmUJXIPaIaLIZhI0GyLdlmu0DO1tI+KNKO
-rDXrcgpOPCbQWTkUw4St3Ovgk9O90JPLk41eiI5XHcXsxHUxA3Y2AG50Lch1pgM0
-9M+84DXC9IRaeg2jAeswOh1NjiVOwS6AdVne2fbUZRC9xKQNJlWGocdNKjWPt84b
-qwzBGOFgklYUOdUZp9AMNfnViSnftHPUh2WQ+gx4BY4agalTXJBGsfUUjR0tGcM=
-=qgRa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+=DvQa
 -----END PGP MESSAGE-----
diff --git a/dot_config/environment.d/01_PATH.conf b/dot_config/environment.d/01_PATH.conf
index 104fba4..2d43e7a 100644
--- a/dot_config/environment.d/01_PATH.conf
+++ b/dot_config/environment.d/01_PATH.conf
@@ -1,16 +1,9 @@
 PATH="${PATH:-/usr/local/bin:/usr/bin:/bin:/usr/local/games:/usr/games}"
-for dir in \
-    "/usr/games" \
-    "/usr/sbin" \
-    "/sbin" \
-    "${HOME}/.cabal/bin" \
-    "${HOME}/.cargo/bin" \
-    "${HOME}/bin"; do
-    case :$PATH: in
-        *:${dir}:*)
-             # ${dir} already in PATH
-            ;;
-        *)
-            PATH="${dir}:${PATH}";;
-    esac
-done
+PATH="/usr/games:${PATH}"
+PATH="/usr/sbin:${PATH}"
+PATH="/sbin:${PATH}"
+PATH="${HOME}/.opam/default/bin:${PATH}"
+PATH="${HOME}/.opam/beluga/bin:${PATH}"
+PATH="${HOME}/.cabal/bin:${PATH}"
+PATH="${HOME}/.cargo/bin:${PATH}"
+PATH="${HOME}/bin:${PATH}"
diff --git a/dot_config/environment.d/02_xdg-base-dirs.conf b/dot_config/environment.d/02_xdg-base-dirs.conf
index 6da8783..0e434e0 100644
--- a/dot_config/environment.d/02_xdg-base-dirs.conf
+++ b/dot_config/environment.d/02_xdg-base-dirs.conf
@@ -1,4 +1,4 @@
-XDG_CACHE_HOME=${HOME}/.cache
-XDG_CONFIG_HOME=${HOME}/.config
-XDG_DATA_HOME=${HOME}/.local/share
-XDG_STATE_HOME=${HOME}/.local/state
+XDG_CACHE_HOME="${HOME}/.cache"
+XDG_CONFIG_HOME="${HOME}/.config"
+XDG_DATA_HOME="${HOME}/.local/share"
+XDG_STATE_HOME="${HOME}/.local/state"
diff --git a/dot_config/environment.d/04_texmf.conf b/dot_config/environment.d/04_texmf.conf
new file mode 100644
index 0000000..83c3da3
--- /dev/null
+++ b/dot_config/environment.d/04_texmf.conf
@@ -0,0 +1 @@
+TEXMFHOME="${HOME}/.texmf"
diff --git a/dot_config/neomutt/accounts/kavanagh.ryan.uqam.ca/format.rc.tmpl b/dot_config/neomutt/accounts/kavanagh.ryan.uqam.ca/format.rc.tmpl
index b0d2ded..4e4aa72 100644
--- a/dot_config/neomutt/accounts/kavanagh.ryan.uqam.ca/format.rc.tmpl
+++ b/dot_config/neomutt/accounts/kavanagh.ryan.uqam.ca/format.rc.tmpl
@@ -7,3 +7,5 @@ set status_format = '-%r-UQAM: %f [Msgs:%?M?%M/?%m%?n? New:%n?%?o? Old:%o?%?d? D
 set attribution = "Le %d, %n a écrit:"
 set attribution_locale = "{{ if (eq .chezmoi.os "openbsd") }}fr_CA.UTF-8{{ else }}fr_CA.utf8{{ end }}"
 set date_format = "%a %d %b %Y à %I:%M:%S%p %Z" 
+set forward_attribution_intro = "----- Message transféré de %f -----"
+set forward_attribution_trailer = "----- Fin du message transféré -----"
diff --git a/dot_config/neomutt/encrypted_private_alias.rc.asc b/dot_config/neomutt/encrypted_private_alias.rc.asc
index c6088ba..99d9ddb 100644
--- a/dot_config/neomutt/encrypted_private_alias.rc.asc
+++ b/dot_config/neomutt/encrypted_private_alias.rc.asc
@@ -1,74 +1,74 @@
 -----BEGIN PGP MESSAGE-----
 
-hQUMAwAAAAAAAAAAASf9EDR4J9+g8j1umPcWC5xpRmyb8xSafaL8vi+tAbmbso+a
-0GYzfzwfWLdFZQM2DKqPzWzG9uCX0ATtRbdCyAUN7kHi2F8R5GEK1V52r7pOeqDF
-MFT+7tXODCLa6J7d7mNMn7DsJqe/fj+rPyWK4qI60L353FoOZ93SJAg26+uSnzoc
-iHgtUVDp7V+sMFR3FICUoyzofI9nbLrfx1L1Pl/d6xr/+slFDouWPb+T8q/GmUZA
-XCQ09iIahrUH3DiSypwGzbCgwIc4vbXo6tcWRkA4AcLfgwCGQ+k+4JVMWfiYZj2i
-/16LF3NXkllNwW1Is3XFDeusjC6GtFtHcPknl+kjL8wbTs2bQ6jXa0Nacw5C2RIN
-wC5+dNNnHzSVe8FVZCfIYC4B62RrQ7w6pkftZEilMCGyh1on1/mLoFKaz0RiSPde
-xTZF6pFKJRvHUZ3PFxxqJ4IREQ7XzFBOlR6YcN7HcbwgrvS5aY0swYMrgCR+Kby6
-n2TbxVmwb1ab2c6YlatxeVnNlU7vrk6wGYEeqO/ulib6s9316ai/mb+5b9t7e3VN
-f2Ldk3xMV84e9F+p2JLv7LH8lRH/6gLauRbGSz62dGPjB5uecnrK5vI/TCHxOLX1
-LNBL2vRaDBV3Hz/ZIPzPo/f0a9Kh4NS0/600FvYosoVa1B+s7QOKgJ2VNhIxzdoM
-aUEVoEpq9Sc+3oCYS87RpFlPD9taZ3BgHUYLrt99RlEof4qncNo6+EPnW8n8se8F
-VF1ke8F3o2/X6S9jmD0BTIZmFuul3ZcBLb7EJKWl+Rz0+h6aDoJNv322SYErMp3I
-mdYghu/HjfRPcrZZf0i1pW6AHrI7Mr8wP7Ot92kj4V9gt06dsGnmGfM+uefwtLUx
-5mBgWBcHKJ1rXhqUHiUmvUmjPEOkFg8xN6023ZCllo0Xs+A7KbQLjnTZ7L+sTiTL
-NdiL2ZA/Q7oefax45uhUunTSPe0PwVBigcKWK0/CYTlwLf5ijy02qk+SJR4RPSd9
-A57jprAbhUzyzwej7QQESfEKojzM6YaVr4dgjgjBXWHJyZCVbeV9gi3d3kiWHd1P
-lwBir0oT0cdbYdj70hZAsTmDCP3uTMWM1YiSgH1ZpdBDxpyGexXIwYVZEUQBKczb
-fOqlsittyw471Dt/pip5KvyU6R25sDO2jQ+ScFuSpdXAyLxA09JkGo1BPpOL3A7R
-JWH+H+duNeN0VLCKhgdo51hiDQmdwwwlFNAWLFUAwhIvaW1qONTxkD6Vsaox7J4+
-28YYyqSqXWXbvu1AQUUGDdm5+VYMNwdgQutaOytYJBcfTsCoHDIOarK+f83TsOgY
-Kefy8immPdg7JajksYmBdmGJLPZLyvRaSnCliZSzJ663soFlF7gF5Psxrnmdmz1r
-8clYwMJRNrsVWrxEuqo8tTl2s4iszIAsd58lXPeEO/jUj936Ax3cYFe1VpGDIbT9
-MESTRONwbLut2nZmTXoYTsDySY1yhQbWCYnsUk5pyR/I4BmtESg8sOEx92HyaX1y
-pcuAunfK7ahYctd6Ls4njcGT5FeZaOWwsQFBpw7EYZS3DifXMmXJj7qcgw9ufd43
-rJc7j27DCucb+OjcteCHD43XQJOmRJQ2Mu9nlyGWiUZfM57BPs9D1Dw8w3CdQ8u9
-XqNVyXREittRGSuEsKGLpEIDUZwU5HV9TUi4X0zEo4eRNBKikl29cYXYAF1w/VHS
-6gEcWLY77jv0gfxw1ZKuiTUjvzsfuAdEdQgSOyJ5gF9ErKiT/jA56BxqXJU3oydw
-rRUNbiD0u6McjttEfEjGzXQJJaZ2hAgymmsaLpxaWYfux5kpmFOifKgKdTCpoabV
-5R9vwAaeRr623x7CagzwL2nGeZHIHEqla3qXfeROLH8Gq296OdwPJ5E+kd9axnP3
-wKCRyYXSBAWmi7Hr0TnLAB897v2oxtj1oDhbZuH1kJa1t+ukmPdxXIEZfqG8NttV
-MHV9fLc195Iufwwo3MYBqIfitxQMDe69Zk6GDXfKv6bH/sHWZsrV1ljg+OlQ/rPZ
-EdrOV+rb0+5V8j9y4cg1UnG91e6Gr/kwImc2hg1Ze3I+mT9MJ8WsoQ8Yv3kxc1gu
-Y7KSGyZyR+tzsUzM91a8UlAvdZCskp0cYXG3N4nqNDID5JOX1hVJEi26nQ/weI4N
-HZPb9ydA++UqAGm+SvUD/evSfY3FJZzo1hl4OZarderLSYZR81+9wsH/0rjMi16n
-8OhCuedSxh2BextydbSNcz3POiZnPTwLJfE5KJs0xj0Z22E9uvjUYZI13rqdSwGV
-QnaEvDwHgF/XCigw1/QmFcugiMZk8mi9gfvnYNlDB/schFTS6jeznAjlnO/dpP4J
-TsKBF19kQwf5ETIIc0mb7H3Hh85XZ17CaoDajnKb/GUBNXjQr++I8Nf7U/BkefNC
-uJbsxM13aYnTvPWYAOHCJOnpasLpwK3rJjqlk5IkXZ5geW/JgnluMfz7r9gnRq5n
-H7SN4onaBBaLfmMEYDc2wJKFR6CV8JRbjWqI3qHX9JL5E6yeXOSg4e1lh1nxATrx
-9/vX2YGY+X6J1aZciEW3Veh6fAGlFVL1JS7xdSIDhMwat2RgXVHA8ZREm4OS4Cm9
-mKF+4HcRvZKKxfpFyivi7lrONgeT5MTy8GKE6XA6DQoiqlUpBB9ef4eHzO2VYsiL
-lCOcLkB4/j26zIRJ7/vRi7JIUsqGHa+XvK59gCh9eISEadJD80KIZyuqpnc3P6sV
-GzgA22I01+LqyyDoHbck/kAWR8L4m8DHgcKYrC6Hzfa6CWNnqGHAU2jAJwMdtf+U
-6G+uvyfYCbIkFLPov1DAQ2/2aUva1AjZyqdncel48M3Y/vGk2WFkwkz+p9ctIKwL
-mxJnxDs6Skx03I5VTC1dmx5bJJD3DwgtupdqD3esrYVIWZuadeP41pqt5ofjirRh
-q8wy4sR3Rqx6zR/GL6frGWhSrZJQE+P1TNhYGDUJkrKdgPWHOfThaSJZHItohpLB
-4/pbzdzjcb4ICRksYmBENmipvOcHkhj+tmySc+Nu78mM67WKww+NSMZpzTTwU1Op
-aBMuSc41e8wppIxKbK+tDvfp9QcTk0tOGescXr+SznAI77+BySKRtfS2ETbxO/u/
-Pgs2meuAl809OUeUZPvTb+QoMBiZ1EhBPb37DapY/ndRWa0e4V3YFzCyo9/AgLBs
-rsas55T/Mm38NybrXHNfflJTF71nqGGt+eIawSrc1vylU6vRu94N3TloS5Ve2H/k
-1lNBZkIl+vtiSdkbKoNYepQzlv4eDyMv7lwzC8AS41e5TW57EfSPJxHwodEvqmvH
-QlD1JZIBwpS+kDjprTcU7+LgM2sYTIExl1Cu18DVpoOoIjl0WZ4fpCRnxuhTiZY9
-Fyno5Uhaq/A99UzBIP5rXQNw+MmR67VnKe2zfC9BK7BPxVQKjzzXFI1JfH+6w049
-2I4iTP3SGyT7qZeUrqNCAeNgzeuKOUxPI3RsPmLBYkuMYbOQLbw1a84Ljr1inlp+
-3sPuM0hKEjv/XR/GFgui8jPrEMKG5WCkWVnN+4a3rE3vFDIBhpKnO7cwOfuzi+Dg
-BPorrsnYc9DCwXGY3TTthwAd/teyynJklB+s4T84QsTToR1d+4cf6HZZYuDXoeRc
-r74bVHPhDI1//iUVHqfoJkXOIDD66IKhFhGGdCnt524YqePtoRwbaPbVPQXtoAxD
-bZp5J1WNWDBz70pREJdhuEelTMyQrp3xRwcRkZiZXQeUiZRAzRalFOGm63RjpEIw
-v8HBO5a19BjCdgYW6PaSUPZw/36xO/FadZ6STzkn+Njmtepp3mTfLRsLzt8AAR97
-0tiV1H4MH5tlp5J9ZUAebTifL/Q2H1AxccZCL1vbQK1dV4BTTM6yeYzcf5VunOQy
-ijPREjpM5WXd33tMQ8kacec3FVN28Cd87KBaa/h/Z2JWLdMteVDVagCw+KzOFV+A
-YYzy2CfoICv66fcZOkf/jfVT1x22MJQf0vb9yqA3qfWMlNwT7JgtZCN4kSSPWLXt
-Hkwa93DRyWtZvFIrTPU6A3t1UNwmq+KT3CjPVDPEATTBMZzVCyRlcHM225jlZjCz
-YZF1+CMyvdHiVG0+SMMSsPqyGtEtynlBYzTz2y6Li9a7KbJ/xQ0UhxbNTKkdVzvL
-Loi15cSTXzai2eYffM1I6Q3Ed6SMZy1pXzSz9tMzVcDSJaWHiiXi1FeCJpDtBqLm
-2clJszpfbByW73UsCK8JDmCoM9tlhHaU0JG2EgPc/1T8oh085hL0cbLblX8quapO
-einpVTtxexi3vto8uR88yPaf9Ct6X4bsKAXboEyMeGNxyu75ks0pG6JWJjM3YAex
-/S5DsjkycdemMDcY+7WGrkhKeJNq3txcu7nZE99G5oXeWKapdVUTcWYjio2QUtc0
-RRk0FoX4d6conkmyp0Bz173jFAS7amIzGqFJbaxo4w==
-=rL3g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+=9dIs
 -----END PGP MESSAGE-----
diff --git a/dot_config/sh/01_environment.d b/dot_config/sh/01_environment.d
index eea2917..b84226f 100644
--- a/dot_config/sh/01_environment.d
+++ b/dot_config/sh/01_environment.d
@@ -1,8 +1,8 @@
 #!/bin/sh
 
-for f in ${HOME}/.config/environment.d/*; do
-    . $f
-    for VAR in $(sed -n '/^[^#]/ s/=.*//p' $f); do
-        export $VAR
+for f in "${HOME}/.config/environment.d/"*; do
+    . "$f"
+    sed -n '/^[^#]/ s/=.*//p' "$f" | while read -r VAR; do
+        export "${VAR?}"
     done
 done
diff --git a/dot_config/sh/10_aliases b/dot_config/sh/10_aliases
index 36bac36..1b8f65d 100644
--- a/dot_config/sh/10_aliases
+++ b/dot_config/sh/10_aliases
@@ -1,3 +1,5 @@
+#!/bin/sh
+
 alias apt-upgrade='sudo apt-get update && sudo apt-get dist-upgrade'
 
 alias 1920s='mplayer -playlist http://kara.fast-serv.com:8398/listen.pls'
@@ -10,14 +12,16 @@ alias links2-fb='links2 -driver fb'
 alias itp='reportbug -M -B debian --email rak@debian.org --paranoid -K $GPGKEY wnpp'
 alias gibuild='gbp buildpackage --git-builder="sbuild -sAd u"'
 alias gibuildi='gbp buildpackage --git-ignore-new --git-builder="sbuild -sAd u"'
-alias dquilt="quilt --quiltrc=${HOME}/.quiltrc-dpkg"
+alias dquilt="quilt --quiltrc=~/.quiltrc-dpkg"
 
 alias vi='vim'
 
 alias sm='tmux attach -t mail || tmux -f ${HOME}/.tmux-mail.conf attach -t mail'
 alias sshfw='ssh -oForwardAgent=yes'
 
-alias llocate="locate -d ${XDG_STATE_HOME}/plocate/home.db"
+# escape ${XDG_STATE_HOME} to use the value when invoked rather than
+# the value at definition time
+alias llocate="locate -d \${XDG_STATE_HOME}/plocate/home.db"
 
 # Alias/custom commands
 #
@@ -27,7 +31,7 @@ alias llocate="locate -d ${XDG_STATE_HOME}/plocate/home.db"
 # deleting files.
 # Furthermore, be verbose about what each command is performing to be present of
 # what is occuring every time.
-if test `uname` = "Linux"; then
+if [ "$(uname)" = "Linux" ]; then
     alias cp="cp -iv"
     alias mkdir="mkdir -v"
     alias mv="mv -iv"
@@ -42,7 +46,7 @@ if test `uname` = "Linux"; then
     alias chmod="chmod -v"
     alias ls="ls --classify --color=always" # Add all colours and
                                             # have fancy symbols for files, etc.
-elif test `uname` = "OpenBSD" && test -x /usr/local/bin/colorls; then
+elif [ "$(uname )" = "OpenBSD" ] && [ -x /usr/local/bin/colorls ]; then
     alias ls="colorls -G"
 fi
 
diff --git a/dot_emacs b/dot_emacs
index 5863e8e..08ff547 100644
--- a/dot_emacs
+++ b/dot_emacs
@@ -99,7 +99,6 @@
    ("C-;" . avy-goto-char)))
 
 (use-package beluga-mode
-  :load-path "~/.opam/default/.opam-switch/sources/beluga/tools/"
   :mode "\\.bel\'")
 
 (use-package bibtex
@@ -286,6 +285,9 @@ Extended Format date in the date field and return it as a string obeing
   (add-to-list 'ivy-initial-inputs-alist
 	       '(counsel-M-x . "")))
 
+(use-package csv-mode
+  :ensure t)
+
 (use-package cus-edit
   :custom
   (custom-file null-device "Don't store customizations"))
@@ -434,7 +436,7 @@ Extended Format date in the date field and return it as a string obeing
 (use-package latex
   :ensure auctex
   :after info-look
-  :mode ("\\.tex\\'" . TeX-latex-mode)
+  :mode ("\\.tex\\'" . LaTeX-mode)
   :init
   ;; http://www.cs.au.dk/~abizjak/emacs/2016/03/06/latex-fill-paragraph.html
   (defun ales/fill-paragraph (&optional P)
@@ -578,11 +580,6 @@ Otherwise split the current paragraph into one sentence per line."
   (message-citation-line-function 'message-insert-formatted-citation-line)
   (message-send-mail-function 'message-send-mail-with-sendmail))
 
-(use-package mingus
-  ;; mpd client
-  :custom
-  (mingus-mpd-host "asteria.home.arpa"))
-
 (use-package minibuffer
   :config
   (add-to-list 'completion-styles 'substring)
diff --git a/dot_emacs.d/lisp/beluga/beluga-mode.el b/dot_emacs.d/lisp/beluga/beluga-mode.el
new file mode 100644
index 0000000..8c04209
--- /dev/null
+++ b/dot_emacs.d/lisp/beluga/beluga-mode.el
@@ -0,0 +1,1113 @@
+;;; beluga-mode.el --- Major mode for Beluga source code  -*- coding: utf-8; lexical-binding:t -*-
+
+;; Copyright (C) 2009-2018  Free Software Foundation, Inc.
+
+;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
+;; Maintainer: beluga-dev@cs.mcgill.ca
+;; Version: 0
+;; Keywords:
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; BUGS
+
+;; - Indentation thinks "." can only be the termination marker of
+;;   an LF declaration.  This can mess things up badly.
+;; - Indentation after curried terms like "fn x => fn y =>" is twice that
+;;   after "fn x y =>".
+
+;;; Code:
+
+(eval-when-compile (require 'cl-lib))
+(require 'smie)
+
+(require 'ansi-color)
+(add-hook 'compilation-filter-hook 'ansi-color-compilation-filter)
+
+(provide 'beluga-unicode-input-method)
+(require 'quail)
+
+(defconst beluga-input-method-name
+  "beluga-unicode"
+  "The name of the Beluga unicode input method.")
+
+(quail-define-package
+ beluga-input-method-name ;; name
+ "UTF-8"                  ;; language
+ "B"                      ;; mode-line "title"
+ t                        ;; guidance
+ "Beluga unicode input method: actually replaces keyword strings with
+a single unicode character instead of merely representing the keywords
+in unicode using Font Lock mode."
+  nil nil nil nil nil nil nil nil nil nil t)
+;; This very final t is the SIMPLE flag of quail-define-package, and
+;; causes Quail to not affect the meanings of C-{f,b,n,p} or TAB.
+
+(quail-define-rules
+ ;; Greek letters
+ ("\\alpha" ["α"])
+ ("\\Alpha" ["Α"])
+ ("\\beta" ["β"])
+ ("\\Beta" ["Β"])
+ ("\\gamma" ["γ"])
+ ("\\Gamma" ["Γ"])
+ ("\\delta" ["δ"])
+ ("\\Delta" ["Δ"])
+ ("\\epsilon" ["ε"])
+ ("\\Epsilon" ["Ε"])
+ ("\\zeta" ["ζ"])
+ ("\\Zeta" ["Ζ"])
+ ("\\eta" ["η"])
+ ("\\Eta" ["Η"])
+ ("\\theta" ["θ"])
+ ("\\Theta" ["Θ"])
+ ("\\iota" ["ι"])
+ ("\\Iota" ["Ι"])
+ ("\\kappa" ["κ"])
+ ("\\Kappa" ["Κ"])
+ ("\\lambda" ["λ"])
+ ("\\Lambda" ["Λ"])
+ ("\\lamda" ["λ"])
+ ("\\Lamda" ["Λ"])
+ ("\\mu" ["μ"])
+ ("\\Mu" ["Μ"])
+ ("\\nu" ["ν"])
+ ("\\Nu" ["Ν"])
+ ("\\xi" ["ξ"])
+ ("\\Xi" ["Ξ"])
+ ("\\omicron" ["ο"])
+ ("\\Omicron" ["Ο"])
+ ("\\pi" ["π"])
+ ("\\Pi" ["Π"])
+ ("\\rho" ["ρ"])
+ ("\\Rho" ["Ρ"])
+ ("\\sigma" ["σ"])
+ ("\\Sigma" ["Σ"])
+ ("\\tau" ["τ"])
+ ("\\Tau" ["Τ"])
+ ("\\upsilon" ["υ"])
+ ("\\Upsilon" ["Υ"])
+ ("\\phi" ["φ"])
+ ("\\Phi" ["Φ"])
+ ("\\chi" ["χ"])
+ ("\\Chi" ["Χ"])
+ ("\\psi" ["ψ"])
+ ("\\Psi" ["Ψ"])
+ ("\\omega" ["ω"])
+ ("\\Omega" ["Ω"])
+
+ ;; Common logical symbol
+ ("\\conj" ["∧"])
+ ("\\disj" ["∨"])
+ ("\\imp"  ["⊃"])
+ ("\\top"  ["⊤"])
+ ("\\bot"  ["⊥"])
+
+ ("\\equiv"  ["≣"])
+  
+ ;; Arrows
+ ("->" ["→"])
+ ("<-" ["←"])
+ ("=>" ["⇒"])
+
+ ;;LF
+ ("|-" ["⊢"])
+ ("\\not" ["¬"])
+ ("::" ["∷"])
+ ("FN" ["Λ"])
+)
+
+(defgroup beluga-mode ()
+  "Editing support for the Beluga language."
+  :group 'languages)
+
+(defvar beluga-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map "\C-c\C-c" 'compile)
+    (define-key map "\C-c\C-l" 'beluga-highlight-holes)
+    (define-key map "\C-c\C-e" 'beluga-erase-holes)
+    (define-key map "\C-c\C-x" 'beluga-run-command)
+    (define-key map "\C-c\C-t" 'beluga-get-type)
+    (define-key map "\C-c\C-s" 'beluga-split-hole)
+    (define-key map "\C-c\C-i" 'beluga-intro-hole)
+    (define-key map "\C-c\C-j" 'beluga-hole-jump)
+    (define-key map "\C-c\C-p" 'beluga-hole-info)
+    map))
+
+(defvar beluga-mode-syntax-table
+  (let ((st (make-syntax-table)))
+    (modify-syntax-entry ?% "< 14" st)
+    (modify-syntax-entry ?\{ "(}2 b" st)
+    (modify-syntax-entry ?\} "){3 b" st)
+    (modify-syntax-entry ?\n ">" st)
+    (modify-syntax-entry ?/ "$/" st)
+    ;; For application of dependent arguments "exp A < ctx . term >", we'd want
+    ;; <..> to match, but that breaks ->, <-, and other things.
+    ;; (modify-syntax-entry ?< "(>" st)
+    ;; (modify-syntax-entry ?> ")<" st)
+    ; see https://emacs.stackexchange.com/a/4149 for a possible solution
+    (modify-syntax-entry ?#  "'" st)
+    (modify-syntax-entry ?< "." st)
+    (modify-syntax-entry ?> "." st)
+    (modify-syntax-entry ?- "." st)
+    (modify-syntax-entry ?| "." st)
+    (modify-syntax-entry ?= "." st)
+    (modify-syntax-entry ?\' "_" st)
+    st))
+
+(defun beluga--proc-live-p (process)
+  "Return non-nil if PROCESS is alive.
+A process is considered alive if its status is `run', `open',
+    `listen', `connect' or `stop'."
+  (and (not (eq process nil))
+       (memq (process-status process)
+             '(run open listen connect stop))))
+
+(defun beluga-font-lock-compose-symbol (alist)
+  "Compose a sequence of ascii chars into a symbol.
+Regexp match data 0 points to the chars."
+  ;; Check that the chars should really be composed into a symbol.
+  (let* ((start (match-beginning 0))
+         (end (match-end 0))
+	 (syntaxes (cond
+                    ((eq (char-syntax (char-after start)) ?w) '(?w))
+                    ;; Special case for the . used for qualified names.
+                    ((and (eq (char-after start) ?\.) (= end (1+ start)))
+                     '(?_ ?\\ ?w))
+                    (t '(?_ ?\\))))
+         sym-data)
+    (if (or (memq (char-syntax (or (char-before start) ?\ )) syntaxes)
+	    (memq (char-syntax (or (char-after end) ?\ )) syntaxes)
+	    (memq (get-text-property start 'face)
+		  '(font-lock-doc-face font-lock-string-face
+		    font-lock-comment-face))
+            (and (consp (setq sym-data (cdr (assoc (match-string 0) alist))))
+                 (let ((pred (cadr sym-data)))
+                   (setq sym-data (car sym-data))
+                   (funcall pred start))))
+	;; No composition for you.  Let's actually remove any composition
+	;; we may have added earlier and which is now incorrect.
+	(remove-text-properties start end '(composition))
+      ;; That's a symbol alright, so add the composition.
+      (compose-region start end sym-data)))
+  ;; Return nil because we're not adding any face property.
+  nil)
+
+(defun beluga-font-lock-symbols-keywords ()
+  (when (and (fboundp 'compose-region) beluga-font-lock-symbols)
+    (let ((alist nil))
+      (dolist (x beluga-font-lock-symbols-alist)
+	(when (and (if (fboundp 'char-displayable-p)
+		       (char-displayable-p (if (consp (cdr x)) (cadr x) (cdr x)))
+		     t)
+		   (not (assoc (car x) alist)))	;Not yet in alist.
+	  (push x alist)))
+      (when alist
+	`((,(regexp-opt (mapcar #'car alist) t)
+	   (0 (beluga-font-lock-compose-symbol ',alist)
+              ;; In Emacs-21, if the `override' field is nil, the face
+              ;; expressions is only evaluated if the text has currently
+              ;; no face.  So force evaluation by using `keep'.
+              keep)))))))
+
+(defconst beluga-syntax-id-re
+  "[[:alpha:]_][[:alnum:]_']*"
+  "A regexp for matching a Beluga identifier.")
+
+(defconst beluga-syntax-fundec-re
+  (regexp-opt '("rec" "proof") 'symbols)
+  "A regexp for matching a function declaration.
+Note that this will also match the 'and' keyword!")
+
+(defvar beluga-imenu-generic-expression
+  `(("Schemas"
+     ,(concat "^[ \t]*schema[ \t\n]+\\(" beluga-syntax-id-re "\\)") 1)
+    ("Constructors"
+     ,(concat "^\\(" beluga-syntax-id-re "\\)[ \t\n]*:") 1)
+    ("Type Constructors"
+     ,(concat "^\\(?:inductive[ \t]+\\(" beluga-syntax-id-re
+              "\\)\\|\\(?1:" beluga-syntax-id-re
+              "\\)[ \t\n]*:[^.]*\\<type\\>[ \t\n]*.\\)")
+     1)
+    ("Functions"
+     ,(concat beluga-syntax-fundec-re "[ \t\n]+\\(" beluga-syntax-id-re "\\)") 1)))
+
+(define-obsolete-variable-alias 'beluga-interpreter-path
+  ;; A "path" is a list of file names, as in $PATH, $MANPATH.
+  'beluga-interpreter-name "Sep-2010")
+(defcustom beluga-interpreter-name "beluga"
+  "Name of the interpreter executable."
+  :type 'string)
+
+;;---------------------------- Interactive mode ----------------------------;;
+
+(define-error 'beluga-interactive-error "Beluga interactive error")
+
+(defun beluga-interactive-error (&rest data)
+  (signal 'beluga-interactive-error data))
+
+;; ------ process management ----- ;;
+
+(defvar beluga--proc ()
+  "Contain the process running beli.")
+(make-variable-buffer-local 'beluga--proc)
+
+(defvar beluga--output-wait-time
+  0.025
+  "How long to wait for output from Beluga on each iteration.")
+
+(defvar beluga--output-timeout
+  1.0
+  "How long to wait in total for output before giving up.")
+
+(defvar beluga--output-timer 0.0)
+
+(defun beluga--proc ()
+  (unless (beluga--proc-live-p beluga--proc) (beluga-start))
+  beluga--proc)
+
+(defun beluga-start ()
+  "Start an inferior Beluga Interactive process with the -emacs option.
+The process is put into a buffer called \"*beluga*\"."
+  (interactive)
+  (unless (beluga--proc-live-p beluga--proc)
+    (setq beluga--proc
+          (get-buffer-process
+           (make-comint "beluga"
+		                    beluga-interpreter-name
+                        nil "-I" "-emacs" ))))
+  beluga--proc)
+
+(defun beluga-quit ()
+  "Stop the Beluga interactive process by sending the quit command.
+This is a graceful termination."
+  (interactive)
+  (beluga--rpc "quit"))
+
+(defun beluga-stop ()
+  "Stop the beli process."
+  (interactive)
+  (when (processp 'beluga--proc)
+    (kill-process 'beluga--proc)))
+
+;; ----- Stuff for hole overlays ----- ;;
+
+(defvar beluga--holes-overlays ()
+  "Will contain the list of hole overlays so that they can be resetted.")
+(make-variable-buffer-local 'beluga--holes-overlays)
+
+(defun beluga-sorted-holes ()
+  (cl-labels
+      ((hole-comp (a b)
+                  (let* ((s1 (overlay-start a))
+                         (s2 (overlay-start b)))
+                    (< s1 s2))))
+    (sort beluga--holes-overlays #'hole-comp)))
+
+(defface beluga-holes
+  '((t :background "cyan")) ;; :foreground "white"
+  "Face used to highlight holes in Beluga mode.")
+
+(defun beluga--pos (line bol offset)
+  ;; According to http://caml.inria.fr/mantis/view.php?id=5159,
+  ;; `line' can refer to line numbers in various source files,
+  ;; whereas `bol' and `offset' refer to "character" (byte?) positions within
+  ;; the actual parsed stream.
+  ;; So if there might be #line directives, we need to do:
+  ;; (save-excursion
+  ;;   (goto-char (point-min))
+  ;;   (forward-line (1- line)) ;Lines count from 1 :-(
+  ;;   (+ (point) (- offset bol))))
+  ;; But as long as we know there's no #line directive, we can ignore all that
+  ;; and use the more efficient code below.  When #line directives can appear,
+  ;; we will need to make further changes anyway, such as passing the file-name
+  ;; to select the appropriate buffer.
+  ;; Emacs considers the first character in the file to be at index 1,
+  ;; but the Beluga lexer starts counting at zero, so we need to add
+  ;; one here.
+  (+ (point-min) offset))
+
+(defun beluga--create-overlay (pos)
+  "Create an overlay at the position described by POS (a Loc.to_tuple)."
+  (let* (;; (file-name (nth 0 pos))
+         (start-line (nth 1 pos))
+         (start-bol (nth 2 pos))
+         (start-off (nth 3 pos))
+         (stop-line (nth 4 pos))
+         (stop-bol (nth 5 pos))
+         (stop-off (nth 6 pos))
+         (ol
+          (make-overlay (beluga--pos start-line start-bol start-off)
+                        (beluga--pos stop-line  stop-bol  stop-off))))
+    (overlay-put ol 'face 'beluga-holes)
+    ol))
+
+(defun beluga-erase-holes ()
+  (interactive)
+  (mapc #'delete-overlay beluga--holes-overlays)
+  (setq beluga--holes-overlays nil))
+
+;; ----- Interaction with the interactive mode ----- ;;
+
+;; Sending and receiving strings from the inferior process.
+;; Ultimately, all you really need to use is beluga--rpc to send a
+;; command to the interactive mode and get back a string response.
+
+(defun beluga--wait (proc)
+  (assert (eq (current-buffer) (process-buffer proc)))
+  (setq beluga--output-timer 0.0)
+  (while (progn
+           (goto-char comint-last-input-end)
+           (not (re-search-forward ".*?;" nil t)))
+    (accept-process-output proc beluga--output-wait-time)
+    (setq beluga--output-timer (+ beluga--output-timer beluga--output-wait-time))
+    (when (> beluga--output-timer beluga--output-timeout)
+      (error "Beluga command didn't produce complete output"))))
+
+(defun beluga--chomp (str)
+  "Chomp leading and tailing whitespace from STR."
+  (replace-regexp-in-string (rx (or (: bos (* (any " \t\n")))
+                                    (: (* (any " \t\n")) eos)))
+                            ""
+                            str))
+(defun beluga--trim (str)
+  (let ((str2 (beluga--chomp str)))
+    (substring str2 0 (1- (length str2)))))
+
+(defun beluga--send (cmd)
+  "Send CMD to beli."
+  ; (interactive)
+  (let ((proc (beluga--proc)))
+    (with-current-buffer (process-buffer proc)
+      ;; We could also just use `process-send-string', but then we wouldn't
+      ;; have the input text in the buffer to separate the various prompts.
+      (goto-char (point-max))
+      (insert (concat "%:" cmd))
+      (comint-send-input)
+      (beluga--wait proc))))
+
+(defun beluga--receive ()
+  "Read the last output of beli."
+  (let ((proc (beluga--proc)))
+    (with-current-buffer (process-buffer proc)
+      (beluga--wait proc)
+      (beluga--trim (buffer-substring-no-properties comint-last-input-end (point-max))))))
+
+(defun beluga--rpc (cmd)
+  (beluga--send cmd)
+  (beluga--receive))
+
+(defun beluga--is-response-error (resp)
+  "Determine whether a Beluga RPC response (RESP) is an error."
+  (string= "-" (substring resp 0 1)))
+
+(defun beluga--rpc! (cmd)
+  "Variant of beluga--rpc that signals an error if CMD fails."
+  (let ((resp (beluga--rpc cmd)))
+    (when (beluga--is-response-error resp)
+      (beluga-interactive-error (list (format "%s" (substring resp 2)))))
+    resp))
+
+(defvar beluga--last-load-time
+  '(0 0 0 0)
+  "The last time the file was loaded into the Beluga interpreter.
+This variable is updated by `beluga--maybe-save-load-current-buffer'.")
+(make-variable-buffer-local 'beluga--last-load-time)
+
+(defun beluga--should-reload-p ()
+  "Decide whether the current buffer should be reloaded into beli.
+The `visited-file-modtime' is compared to `beluga--last-load-time'.
+If the former is greater than the latter, then the former is
+returned.  Else, nil is returned."
+  (let ((mtime (visited-file-modtime)))
+    (when (> (float-time mtime) (float-time beluga--last-load-time))
+        mtime)))
+
+;; ----- Beluga Interactive basic functions ----- ;;
+
+;; Each of these functions directly corresponds to a command in src/core/command.ml
+
+;; Since the construction of these functions is totally tedious and
+;; straightforward, we define a macro to do the real work.
+;; This macro takes:
+;;   * the name of the function to define, e.g. beluga--printhole
+;;   * the real name of the command to invoke, e.g. "printhole"
+;;   * the arguments of the function, e.g. '((hole . "%s"))
+;;
+;; Note: the type of each argument is specified as a printf-style
+;; format code. That's because the construction of the command will
+;; construct a string formatting routine using these codes.
+;;
+;; What about constant portions of the string?
+;; If you want to supply a constant portion in the format string,
+;; simply provide a string as-is in the argument list.
+;; e.g. ((hole . "%s") "with" (exp . "%s"))
+;;
+;; Two separate functions are generated by the macro invocation. The
+;; first uses exactly the given function name, but the second appends
+;; "!". This bang-variant will use beluga--rpc! under the hood, so you
+;; get an exception-raising variant of every function for free.
+
+(defun beluga--generate-format-string (args)
+  "Construct the format string from the ARGS."
+  (cons
+   "%s"
+   (mapcar
+    (lambda (x)
+      (if (stringp x)
+          x
+        (cdr x)))
+    args)))
+
+(defun beluga--generate-arg-list (args)
+  "Construct a list of symbols representing the function arguments from ARGS."
+  (mapcar 'car (cl-remove-if 'stringp args)))
+
+(defun beluga--define-command (rpc name realname args)
+  (let ((arglist (beluga--generate-arg-list args))
+        (fmt (beluga--generate-format-string args)))
+    `(defun ,name ,arglist
+       (,rpc
+        (format
+         ;; construct the format string
+         ,(mapconcat 'identity fmt " ")
+         ;; construct the argument list
+         ,realname ,@arglist)))))
+
+(defmacro beluga-define-command (name realname args)
+  `(progn
+     ,(beluga--define-command 'beluga--rpc name realname args)
+     ,(beluga--define-command 'beluga--rpc! (intern (concat (symbol-name name) "!")) realname args)))
+
+(beluga-define-command beluga--basic-chatteron "chatteron" nil)
+(beluga-define-command beluga--basic-chatteroff "chatteroff" nil)
+(beluga-define-command beluga--basic-load "load" ((path . "%s")))
+(beluga-define-command beluga--basic-clearholes "clearholes" nil)
+(beluga-define-command beluga--basic-countholes "countholes" nil)
+(beluga-define-command beluga--basic-lochole "lochole" ((hole . "%s")))
+(beluga-define-command beluga--basic-lochole-n "lochole" ((hole . "%d")))
+(beluga-define-command beluga--basic-printhole "printhole" ((hole . "%s")))
+(beluga-define-command beluga--basic-printhole-n "printhole" ((hole . "%d")))
+(beluga-define-command beluga--basic-types "types" nil)
+(beluga-define-command beluga--basic-constructors-lf "constructors" ((type . "%s")))
+(beluga-define-command beluga--basic-fill "fill" ((hole . "%s") "with" (exp . "%s")))
+(beluga-define-command beluga--basic-split "split" ((hole . "%s") (var . "%s")))
+(beluga-define-command beluga--basic-intro "intro" ((hole . "%s")))
+(beluga-define-command beluga--basic-constructors "constructors-comp" ((type . "%s")))
+(beluga-define-command beluga--basic-signature "fsig" ((fun . "%s")))
+(beluga-define-command beluga--basic-printfun "fdef" ((fun . "%s")))
+(beluga-define-command beluga--basic-query "query" ((expected . "%s") (tries . "%s") (type . "%s")))
+(beluga-define-command beluga--basic-get-type "get-type" ((line . "%d") (col . "%d")))
+(beluga-define-command beluga--basic-reset "reset" nil)
+(beluga-define-command beluga--basic-quit "quit" nil)
+(beluga-define-command beluga--basic-lookuphole "lookuphole" ((hole . "%s")))
+
+;; ----- Higher-level commands ----- ;;
+
+;; These build off the basic commands, and will typically do something
+;; like parse the response or display it in a message.
+
+(defun beli ()
+  "Start beli mode."
+  (interactive)
+  (beluga-start))
+
+(defun beluga-run-command (cmd)
+  "Run CMD in beli."
+  (interactive "MCommand: ")
+  (message "%s" (beluga--rpc cmd)))
+
+(defun beluga--maybe-save ()
+  (if (buffer-modified-p)
+    (if (y-or-n-p "Save current file? ")
+      (save-buffer)
+      ())))
+
+(defun beluga-get-type ()
+  "Get the type at the current cursor position (if it exists)."
+  (interactive)
+  (message "%s" (beluga--basic-get-type (count-lines 1 (point)) (current-column))))
+
+(defun beluga--load-current-buffer (&optional mtime)
+  "Load the current buffer in Beluga Interactive.
+This command signals an error if loading fails.
+The optional MTIME parameter, if given, will be written to `beluga--last-load-time'."
+  (let ((resp (beluga--basic-load! (buffer-file-name))))
+    (when mtime
+      (setq beluga--last-load-time mtime))
+    resp))
+
+(defun beluga--maybe-save-load-current-buffer ()
+  "Load the current buffer if it has either never been loaded, or
+modified since the last time it was loaded.
+This will update `beluga--last-load-time' if a load is performed."
+  ;; prompt the user to save the buffer if it is modified
+  (beluga--maybe-save)
+  ;; retrieve the last time the file was written to disk, checking
+  ;; whether a reload should occur
+  (let ((mtime (beluga--should-reload-p)))
+    (when mtime ;; mtime non-nil means we must reload
+      (beluga--load-current-buffer mtime))))
+
+(defun beluga--lochole-n! (hole-num)
+  (read (beluga--basic-lochole-n! hole-num)))
+
+(defun beluga--countholes! ()
+  "Get the number of holes in the file."
+  (string-to-number (beluga--basic-countholes!)))
+
+(defun beluga--lookup-hole! (hole)
+  "Look up a hole number by its name (HOLE)."
+  (string-to-number (beluga--basic-lookuphole! hole)))
+
+(defun beluga--highlight-holes ()
+  "Create overlays for each of the holes and color them."
+  (beluga-erase-holes)
+  (let ((numholes (beluga--countholes!)))
+    (dotimes (i numholes)
+      (let* ((pos (beluga--lochole-n! i))
+             (ol (beluga--create-overlay pos))
+             (info (beluga--basic-printhole-n! i)))
+        (overlay-put ol 'help-echo info)
+        (push ol beluga--holes-overlays)
+        ))))
+
+(defun beluga--get-hole-overlay! (hole)
+  "Get the overlay associated with HOLE."
+  (nth (beluga--lookup-hole! hole) (beluga-sorted-holes)))
+
+(defun beluga--apply-quail-completions (str)
+  (if (string= current-input-method beluga-input-method-name)
+     (replace-regexp-in-string "=>" "⇒"
+      (replace-regexp-in-string "|-" "⊢" str))
+     str))
+
+(defun beluga--insert-formatted (str start)
+  (goto-char start)
+  (insert (beluga--apply-quail-completions str))
+  (indent-region start (+ start (length str))))
+
+(defun beluga--error-no-such-hole (n)
+  (message "Couldn't find hole %s - make sure the file is loaded" n))
+
+(defconst beluga-named-hole-re
+  "\\_<?\\(\\sw+\\)\\_>")
+
+(defun beluga-named-hole-at-point ()
+  "Retrieve the name of the hole at point, if any.
+If e.g. point is over \"?abracadabra\", then this function returns
+\"abracadabra\". Else, if point is not over a valid hole, then this
+function returns nil."
+  (let ((thing (thing-at-point 'symbol)))
+    (when (and thing (string-match beluga-named-hole-re thing))
+      (match-string 1 thing))))
+
+(defun beluga--prompt-with-hole-at-point (prompt)
+  "Prompt the user to specify a hole, giving the named hole at point
+as the default if any."
+  (let ((name (beluga-named-hole-at-point)))
+    (if name
+        (read-string (format "%s (%s): " prompt name)
+                     nil nil name)
+      (read-string (format "%s: " prompt)))))
+
+(defun beluga--begin-command ()
+  "Perform necessary setup to begin a compound Beluga Interactive command.
+Specifically, the following are performed, if necessary:
+  - Starting the Beluga inferior process.
+  - Saving the current buffer.
+  - Loading the current buffer into Beluga.
+  - Highlighting holes."
+  (beluga-start)
+  (beluga--maybe-save-load-current-buffer)
+  (beluga--highlight-holes))
+
+(defun beluga--prompt-string (prompt)
+  "Prompts the user to input a string."
+  (read-string (format "%s: " prompt)))
+
+;; ----- Top-level commands ----- ;;
+
+(defun beluga-load ()
+  "Load the current file in Beluga Interactive.
+This command will start the interactive mode if necessary and
+prompt for saving."
+  (interactive)
+  (beluga-start)
+  (let ((r (beluga--maybe-save-load-current-buffer)))
+    (if r
+        (message "%s" r)
+      (message "Buffer does not require reload."))))
+
+(defun beluga-highlight-holes ()
+  "Create overlays for each of the holes and color them."
+  (interactive)
+  (beluga--begin-command))
+
+(defun beluga-hole-info (hole)
+  (interactive
+   (list
+    (beluga--prompt-with-hole-at-point "Hole to query")))
+  (beluga--begin-command)
+  (let ((resp (beluga--basic-printhole! hole)))
+    (message resp)))
+
+(defun beluga-split-hole (hole var)
+  "Split on HOLE."
+  (interactive
+   (list
+    (beluga--prompt-with-hole-at-point "Hole to split at")
+    (beluga--prompt-string "Variable to split")))
+  (beluga--begin-command)
+  (let ((resp (beluga--basic-split! hole var))
+        (ovr (beluga--get-hole-overlay! hole)))
+    (if ovr
+        (let ((start (overlay-start ovr))
+              (end (overlay-end ovr)))
+          (delete-overlay ovr)
+          (delete-region start end)
+          (beluga--insert-formatted (format "(%s)" resp) start)
+          (save-buffer)
+          (beluga--load-current-buffer)
+          (beluga--highlight-holes))
+      (beluga--error-no-such-hole hole))))
+
+(defun beluga-intro-hole (hole)
+  "Introduce variables into HOLE"
+  (interactive
+   (list
+    (beluga--prompt-with-hole-at-point "Hole to introduce variables into")))
+  (beluga--begin-command)
+  (let ((resp (beluga--basic-intro! hole))
+        (ovr (beluga--get-hole-overlay! hole)))
+    (if ovr
+        (let ((start (overlay-start ovr))
+              (end (overlay-end ovr)))
+          (delete-overlay ovr)
+          (delete-region start end)
+          (beluga--insert-formatted resp start)
+          (save-buffer)
+          (beluga--load-current-buffer)
+          (beluga--highlight-holes))
+      (beluga--error-no-such-hole hole))))
+
+(defun beluga-hole-jump (hole)
+  (interactive "sHole to jump to: ")
+  (beluga--begin-command)
+  (let ((ovr (beluga--get-hole-overlay! hole)))
+    (if ovr
+        (goto-char (+ 1 (overlay-start ovr)))
+      (beluga--error-no-such-hole hole))))
+(define-obsolete-function-alias 'hole-jump #'beluga-hole-jump "Jul-2018")
+
+;; ----- Beluga indentation and navigation via SMIE ----- ;;
+
+(defconst beluga-syntax-pragma-re
+  "--\\(\\(name\\|query\\|infix\\|prefix\\|assoc\\).*?\\.\\|\\w+\\)"
+  "A regexp for matching a Beluga pragma.
+Long pragmas continue until a `.` is found, e.g. `--name oft D.`.
+Short pragmas consist of only one word, e.g. `--nostrengthen`.
+It's easy to use this regex to check which type of pragma (long or short)
+was matched: simply check whether `match-string' 2 is non-nil.  In that case,
+a long pragma was matched and the result is the name of the long pragma.
+Otherwise, `match-string' 1 will contain the name of the matched short.")
+
+(defconst beluga-slim-arrows
+  '("->" "<-" "→" "←")
+  "A list of the slim arrow strings.")
+
+(defconst beluga-fat-arrows
+  '("=>" "⇒")
+  "A list of the fat arrow strings.")
+
+(defconst beluga-punct-re
+  (regexp-opt `(,@beluga-fat-arrows ,@beluga-slim-arrows "\\" "." "<" ">" "," ";" "..")))
+
+(defconst beluga-syntax-keyword-re
+  (regexp-opt
+   '("FN" "and" "block" "case" "inductive" "LF" "coinductive"
+     "stratified" "else" "ffalse" "fn" "if" "in" "impossible" "let"
+     "mlam" "of" "rec" "proof" "schema" "some" "then" "type" "ctype" "ttrue"
+     "typedef"
+     "module" "struct" "end" "#stratified" "#positive" "fun")
+   'symbols)
+  "A regular expression to match any beluga keyword.")
+
+(defface beluga-font-lock-annotation
+  '((t :inherit italic))
+  "Face used for Beluga's /.../ annotations.")
+
+(defconst beluga-font-lock-keywords
+  `((,beluga-syntax-pragma-re . ,font-lock-warning-face)
+
+    ,beluga-syntax-keyword-re
+
+    ("/\\s-*\\_<\\(total\\)\\_>.*?/"
+     (0 'beluga-font-lock-annotation)
+     (1 'font-lock-keyword-face prepend))
+
+    (,(concat
+       "^\\(" beluga-syntax-id-re "\\)"
+       "\\s-*" ":"
+       "\\([^.]*\\_<type\\_>\\s-*.\\)?")
+     ;; This is a regexp that can span multiple lines, so it may not
+     ;; always highlight properly.  `font-lock-multiline' tries to help.
+     (0 (if (match-end 2) '(face nil font-lock-multiline t)))
+     (1 (if (match-end 2)
+            font-lock-type-face font-lock-variable-name-face)))
+
+    (,(concat "^\\(?:schema\\|inductive\\|coinductive\\|LF\\|stratified\\)" "\\s-+"
+              "\\(" beluga-syntax-id-re "\\)")
+     (1 font-lock-type-face))
+
+    (,(concat beluga-syntax-fundec-re "\\s-+\\(" beluga-syntax-id-re "\\)")
+     (2 font-lock-function-name-face))
+    ))
+
+(defcustom beluga-indent-basic 4
+  "Basic amount of indentation."
+  :type 'integer)
+
+(defun beluga-smie-forward-token ()
+  ; skip all whitespace and comments
+  (forward-comment (point-max))
+  (cond
+   ((looking-at "\\.[ \t]*$")
+      ;; One of the LF-terminating dots.
+    (progn (forward-char 1) ";."))
+   ((looking-at beluga-syntax-pragma-re)
+    ;; move point to the end of the long-pragma name if a long-pragma was matched.
+    ;; otherwise, move it to the end of the short pragma name.
+    (goto-char (or (match-end 2) (match-end 1)))
+    ;; set to non-nil by beluga-syntax-pragma-re if the pragma is a long-form pragma
+    (if (match-string 2)
+        "--longpragma"
+        "--shortpragma"))
+   (t
+    ; otherwise, we return a chunk of text that starts at point and
+    ; ends according to the following `cond` check.
+    (buffer-substring-no-properties
+     (point)
+     (progn
+       (cond
+        ((looking-at beluga-punct-re) (goto-char (match-end 0)))
+        ((not (zerop (skip-syntax-forward "w_'"))))
+        ;; In case of non-ASCII punctuation.
+        ((not (zerop (skip-syntax-forward ".")))))
+       (point))))))
+
+(defun beluga-short-pragma-before-p ()
+  "Decide whether there is a short pragma before point.
+Return the starting position of the short pragma; else, nil."
+  (save-excursion
+    ;; idea: move backward across word-characters, and then check if
+    ;; there are two dashes before point.
+    (skip-syntax-backward "w")
+    (save-match-data
+      (when (looking-back "--" (- (point) 2))
+        (match-beginning 0)))))
+
+(defun beluga-smie-backward-token ()
+  (forward-comment (- (point-max)))
+  (cond
+   ((and (eq ?\. (char-before))
+         (looking-at "[ \t]*$") ;; "[ \t]*\\(?:$\\|[0-9]\\(\\)\\)"
+         (not (looking-back "\\.\\." (- (point) 2))))
+    ;; Either an LF-terminating dot, or a projection-dot.
+    (progn (forward-char -1) ";."))
+   ((setq pos (beluga-short-pragma-before-p))
+    (goto-char pos)
+    "--shortpragma")
+   (t
+    (buffer-substring-no-properties
+     (point)
+     (progn
+       (cond
+        ((looking-back beluga-punct-re (- (point) 2) 'greedy)
+         (goto-char (match-beginning 0)))
+        ((not (zerop (skip-syntax-backward "w_'"))))
+        ;; In case of non-ASCII punctuation.
+        ((not (zerop (skip-syntax-backward ".")))))
+       (point))))))
+
+(defun beluga-smie-grammar (bnf resolvers precs)
+  (smie-prec2->grammar
+   (smie-merge-prec2s
+    (apply #'smie-bnf->prec2 bnf resolvers)
+    (smie-precs->prec2 precs))))
+
+(defconst beluga-smie-grammar
+  ;; The "." used for terminating LF declarations is syntactically completely
+  ;; different from the "." used in the binding forms.  Conflating the two
+  ;; leads here to a lot of precedence conflicts, so we try and guess the two
+  ;; based on a heuristic in the tokenizing code.
+  (beluga-smie-grammar
+   ;; FIXME: without this dummy, "=>" is marked as "open paren" because it
+   ;; can only bind to `atom' on the left.
+   '((atom ("--dummy--"))
+
+     (def (exp "=" exp) (atom ":" exp))
+
+     (decl
+      (atom ":" type)
+      (datatypes)
+      ("schema" sdef)
+      ("let" def)
+      ("--shortpragma")
+      ("--longpragma" atom)
+      (recs))
+
+     (datatypes
+      ("inductive" datatype-def)
+      ("coinductive" datatype-def)
+      ("LF" datatype-def)
+      ("stratified" datatype-def)
+      (datatypes "and" datatypes))
+
+     (simpletype
+      (simpletype "->" simpletype)
+      (simpletype "→" simpletype)
+      (simpletype "←" simpletype)
+      (simpletype "<-" simpletype))
+
+     (recs
+      ("rec" def)
+      ("proof" def)
+      (recs "and" recs))
+
+     (decls
+      (decl)
+      (decls ";" decls)
+      (decls ";." decls))
+
+     ;; FIXME: only allow simple types here, otherwise we get nasty
+     ;; precedence conflicts between "." and ",".  In practice, this seems to
+     ;; be sufficient.
+     (sdecl
+      (atom ":" type))
+
+     (sdecls
+      (sdecl)
+      (sdecls "," sdecls))
+
+     (dotted-type
+      (sdecls "|-" type)
+      (sdecls "⊢" type))
+
+     (type
+      (simpletype)
+      ("\\" atom "." type)         ;dotted-type
+      ("block" sdecls "." type)    ;dotted-type
+      ;; ("{" blabla "}" type)  ; FIXME!
+      ;; FIXME: the projection via "." creates precedence conflicts.
+      ;; (type "." atom)
+      )
+
+     (sdef
+      (atom "=" schema))
+
+     (schema
+      (type)
+      ;; Not sure if it's correct, and create precedence conflicts.
+      ;; ("some" sdecls "block" sdecls "." schema)
+      )
+
+     (datatype-name
+      (atom ":" type))
+
+     (datatype-def
+      (datatype-name "=" datatype-branches))
+
+     (datatype-branches
+      (datatype-branches "|" datatype-branches)
+      (atom ":" type))
+
+     (exp
+      ("if" exp "then" exp "else" exp)
+      (type)
+      ("let" def "in" exp)
+      ("fun" atom "=>" exp)
+      ("fun" atom "⇒" exp)
+      ("fn" atom "=>" exp)
+      ("fn" atom "⇒" exp)
+      ("FN" atom "=>" exp)
+      ("FN" atom "⇒" exp)
+      ("mlam" atom "=>" exp)
+      ("mlam" atom "⇒" exp)
+      ("<" dotted-type ">")
+      ("case" exp "of" cases))
+
+     (exps
+      (exps ";" exps)
+      (exp))
+
+     ;; Separate cases/branch so that "|" is recognized as associative.
+     (cases
+      (branch)
+      (cases "|" cases))
+
+     (branch
+      (atom "=>" exp)
+      (atom "⇒" exp)))
+
+   ; resolvers
+   `(((assoc ";" ";."))
+     ((assoc ,@beluga-slim-arrows))
+     ((assoc ","))
+     ((assoc "and"))
+     ((nonassoc "of") (assoc "|"))      ; Trailing | ambiguity.
+     ;; '((nonassoc "\\") (nonassoc ".")) ; Trailing . ambiguity.
+     ;; '((nonassoc "block") (nonassoc ".")) ; Trailing . ambiguity.
+     )
+
+   ;; The above BNF grammar should cover this already, so this ends up only
+   ;; useful to check that the BNF entails the expected precedences.
+   ; precs
+   `((assoc ";")
+     (assoc ",")
+     (left ":")
+     (assoc ,@beluga-slim-arrows)
+     (nonassoc " -dummy- "))))          ;Bogus anchor at the end.
+
+(defconst beluga-pattern-fat-arrow
+  `(or ,@beluga-fat-arrows)
+  "A pattern for use in pcase that matches any fat arrow string.")
+
+(defun beluga-rule-parent-p (parents)
+  `(smie-rule-parent-p ,@parents))
+
+(defun beluga-smie-indent-rules (method token)
+  (pcase `(,method . ,token)
+    (`(:elem . basic)
+     beluga-indent-basic)
+
+    ; describe the tokens that introduce lists (with no separators)
+    (`(:list-intro . ,(or ":" "fn" "fun" "FN" "mlam"))
+     't)
+
+    ; if the token is a pipe preceded by an '=' or 'of', then we
+    ; indent by adding the basic offset
+    (`(:before . ,(and "|" (guard (smie-rule-prev-p "=" "of" "fun"))))
+     2)
+
+    ; if the token is a pipe, (and the preceding check didn't pass, so
+    ; it isn't the first pipe in a sequence) then we consider it a
+    ; separator
+    (`(method . ,"|")
+     (smie-rule-separator method))
+
+    (`(:after . ,"of")
+     beluga-indent-basic)
+
+    (`(:after . ,"in")
+     (when (smie-rule-hanging-p)
+       (smie-rule-parent)))
+
+    (`(:after . ,(and "=" (guard (smie-rule-parent-p "rec"))))
+     (smie-rule-parent))
+
+    (`(:after . ,(and "=" (guard (smie-rule-parent-p "proof"))))
+     (smie-rule-parent))
+
+    ; if the token is a form that will use => eventually but is
+    ; preceded by a =>, then this is a chain, e.g.
+    ; mlam G => mlam Q => fn x => fn y =>
+    ; (code should be here, not indented 8 characters)
+    (`(:before
+       .
+       ,(and
+         (or "case" "fn" "FN" "mlam" "fun")
+         (guard `(smie-rule-prev-p ,@beluga-fat-arrows))))
+     (smie-rule-parent))
+
+    (`(:after . ".")
+     (smie-rule-parent))
+
+    (`(:after . ,(and ":" (guard (smie-rule-parent-p "{"))))
+     (smie-rule-parent 1))
+
+    (`(:after . ,(or ":" "let" "if"))
+     (smie-rule-parent beluga-indent-basic))
+
+    (`(:before
+       .
+       ,(and "=" (guard `(smie-rule-parent-p ,@beluga-type-declaration-keywords))))
+     (smie-rule-parent))
+    ))
+
+;;---------------------------- Loading of the mode ----------------------------;;
+
+;;;###autoload
+(add-to-list 'auto-mode-alist '("\\.s?bel\\'" . beluga-mode))
+
+(defconst beluga-type-declaration-keywords
+  '("inductive" "coinductive" "LF" "stratified")
+  "The different keywords that introduce a type definition.")
+
+(defconst beluga-type-declaration-keywords-re
+  (regexp-opt beluga-type-declaration-keywords 'symbols)
+  "A regular expression that matches any type definition keyword.")
+
+;;;###autoload
+(define-derived-mode beluga-mode prog-mode "Beluga"
+  "Major mode to edit Beluga source code."
+  (set (make-local-variable 'imenu-generic-expression)
+       beluga-imenu-generic-expression)
+  (set (make-local-variable 'outline-regexp)
+       (concat beluga-syntax-fundec-re "\\|^(inductive\\|coinductive\\|LF\\|stratified)\\_>"))
+  (set (make-local-variable 'require-final-newline) t)
+  (when buffer-file-name
+    (set (make-local-variable 'compile-command)
+         ;; Quite dubious, but it's the intention that counts.
+         (concat beluga-interpreter-name
+                 " "
+                 (shell-quote-argument buffer-file-name))))
+  (set (make-local-variable 'comment-start) "%")
+  (set (make-local-variable 'comment-start-skip) "%[%{]*[ \t]*")
+  (set (make-local-variable 'comment-end-skip) "[ \t]*\\(?:\n\\|}%\\)")
+  (comment-normalize-vars)
+  (set (make-local-variable 'electric-indent-chars)
+       (append '(?|) (if (boundp 'electric-indent-chars)
+                         electric-indent-chars
+                       '(?\n))))
+  ;QUAIL
+  (add-hook 'beluga-mode-hook
+   (lambda () (set-input-method "beluga-unicode")))
+
+  ;Turn off hilighting
+  (setq input-method-highlight-flag nil)
+
+  (smie-setup
+   beluga-smie-grammar
+   'beluga-smie-indent-rules
+   :forward-token #'beluga-smie-forward-token
+   :backward-token #'beluga-smie-backward-token)
+
+  (set (make-local-variable 'parse-sexp-ignore-comments) t)
+
+  (set
+   (make-local-variable 'font-lock-defaults)
+   '(beluga-font-lock-keywords
+     nil
+     nil
+     ()
+     nil
+     (font-lock-syntactic-keywords . nil)))
+
+  (message "beluga-mode loaded"))
+
+(provide 'beluga-mode)
+;;; beluga-mode.el ends here
diff --git a/dot_vimrc b/dot_vimrc
index 79a9faf..4e179a2 100644
--- a/dot_vimrc
+++ b/dot_vimrc
@@ -24,5 +24,5 @@ set textwidth=80
 
 set pastetoggle=<F10>
 
-au BufEnter ~/.local/state/neomutt/* set textwidth=72 | set list lcs=trail:-,nbsp:%
+au BufEnter ~/.local/state/neomutt/* set textwidth=72 | set list lcs=trail:-,nbsp:% | set filetype=mail
 au BufEnter */gophermap set list lcs=trail:-,nbsp:%,tab:»·,space:·
diff --git a/dot_zshrc.tmpl b/dot_zshrc.tmpl
index 62fef86..ed06714 100644
--- a/dot_zshrc.tmpl
+++ b/dot_zshrc.tmpl
@@ -51,28 +51,17 @@ export PAGER=less
 export LESS=-FQXR
 export PDFVIEWER=evince
 export BROWSER=firefox
-export TEXMFHOME=${HOME}/.texmf
 export KRB5CCNAME=DIR:${HOME}/.cache/krb5cc # kerberos credentials cache
 export GOPATH=${HOME}/.go
 
-for common in ${HOME}/.config/sh/*; do
+for common in "${HOME}/.config/sh/"*; do
     [ -f "${common}" ] && . "${common}"
 done
 
-export PATH=/usr/sbin:/sbin:${PATH}
-case `uname` in
-    Linux)
-        ;;
-    Darwin)
-        export PATH=/opt/local/bin:/opt/local/sbin:/usr/sbin:/sbin:$PATH
+if [ "$(uname)" = "Darwin" ]; then
+        export PATH="/opt/local/bin:/opt/local/sbin:${PATH}"
         export MANPATH=/opt/local/share/man:${MANPATH}
-        ;;
-    OpenBSD)
-        export PATH=/usr/games:${PATH}
-        ;;
-    *)
-esac
-export PATH=${HOME}/bin:${PATH}
+fi
 
 # END LOCAL
 
@@ -80,9 +69,7 @@ export PATH=${HOME}/bin:${PATH}
 
 # Ensure that we possess a ~/.zsh/ directory. This is required for the
 # ~/.zsh/history file.
-if [ ! -d $HOME/.zsh/ ]; then
-    mkdir -p $HOME/.zsh/
-fi
+mkdir -p $HOME/.zsh/
 
 # We use powerline10k for our prompt
 for f in $HOME/.zsh/p10k.zsh $HOME/.zsh/powerlevel10k/powerlevel10k.zsh-theme; do