17 files changed, 461 insertions, 57 deletions

diff --git a/src/blog/2022-06-12-shell-ide-sed/shell-ide-sed.md b/src/blog/2022-06-12-shell-ide-sed/shell-ide-sed.md
index 410d2ce..bcb97d0 100644
--- a/src/blog/2022-06-12-shell-ide-sed/shell-ide-sed.md
+++ b/src/blog/2022-06-12-shell-ide-sed/shell-ide-sed.md
@@ -117,7 +117,7 @@ $ cth do_ src/*
 ```
 
 And it works! You can now find
-[this script](https://git.tronto.net/scripts/file/cth%2Ehtml)
+[this script](https://git.tronto.net/scripts/tree/cth)
 among my other [scripts](https://git.tronto.net/scripts).
 
 *Remark: in bash one can simply do `sed -n "/^$1/,/^}/ p" ${@:2}` to match
diff --git a/src/blog/2022-08-14-website/website.md b/src/blog/2022-08-14-website/website.md
index 8019c60..f76c5f2 100644
--- a/src/blog/2022-08-14-website/website.md
+++ b/src/blog/2022-08-14-website/website.md
@@ -23,7 +23,7 @@ files, writing a script that adds a header and a footer to the output of
 [lowdown](https://kristaps.bsd.lv/lowdown/), and using
 [rsync](https://en.wikipedia.org/wiki/Rsync) to deploy the files to my server.
 All of this is available on
-[my git page](https://git.tronto.net/sebastiano.tronto.net/), but I won't
+[my git page](https://git.tronto.net/sebastiano.tronto.net), but I won't
 explain every detail of these build scripts here. In particular, my script
 also builds a [gemini](https://sebastiano.tronto.net/blog/2022-06-04-gemini/)
 version of my website, which I won't discuss here.
@@ -88,9 +88,9 @@ Without this trick the correct URL would have been
 `sebastiano.tronto.net/git.html` or something, which I don't like.
 
 The main working directory also contains the 
-[`top.html`](https://git.tronto.net/sebastiano.tronto.net/file/top%2Ehtml%2Ehtml)
+[`top.html`](https://git.tronto.net/sebastiano.tronto.net/tree/top.html)
 and
-[`bottom.html`](https://git.tronto.net/sebastiano.tronto.net/file/bottom%2Ehtml%2Ehtml)
+[`bottom.html`](https://git.tronto.net/sebastiano.tronto.net/tree/bottom.html)
 files. These files are not uploaded directly to my server - they are not
 even well-formed html files! - but they are used to build all other
 html pages.
diff --git a/src/blog/2022-11-23-git-host/git-host.md b/src/blog/2022-11-23-git-host/git-host.md
index cc9fc27..8087d80 100644
--- a/src/blog/2022-11-23-git-host/git-host.md
+++ b/src/blog/2022-11-23-git-host/git-host.md
@@ -1,5 +1,11 @@
 # Self-hosted git pages with stagit (featuring ed, the standard editor)
 
+*Update 2026-08-30: Since August 2026, I am no longer using stagit to
+host my git pages. Instead, I use [cgit](https://git.zx2c4.com/cgit/about).
+I have updated all the links in this page to point to a frozen copy of
+my stagit-based git page before the switch. If you want to visit my new
+git page, go to [git.tronto.net](https://git.tronto.net).*
+
 This is a follow-up to my earlier blog entry
 [How I update my website](../2022-08-14-website).
 
@@ -14,9 +20,9 @@ via web pages, on your personal server? In this post I am going to show
 you how I do it, in the usual minimalist and
 not-using-what-I-do-not-understand style.
 
-You can see the final result on my [git pages](https://git.tronto.net).
+You can see the final result on my [git pages](https://stagit.tronto.net).
 The scripts and other files I use to set this up are accessible
-[here](https://git.tronto.net/git-hooks).
+[here](https://stagit.tronto.net/git-hooks).
 
 ## Hosting git repositories on your own server
 
@@ -54,7 +60,7 @@ a bunch of html files that you can simply move to your www hosting directory.
 After generating the pages you can personalize them by copying your logo,
 [favicon](https://en.wikipedia.org/wiki/Favicon) or CSS style sheet. You can
 use `stagit-index` to generate
-[an index page for your repositories](https://git.tronto.net/). Since everything
+[an index page for your repositories](https://stagit.tronto.net/). Since everything
 consists of html files, you can simply edit them to personalize your git pages
 even further - and below you'll see some examples.
 
@@ -155,8 +161,8 @@ add or change:
 * I would like to have a download button so that people who don't use git
   can still download my files. This makes sense especially for those
   repos that are mostly documents, such as my
-  [lecture notes](https://git.tronto.net/mathsoftware) or my
-  [FMC tutorial](https://git.tronto.net/fmctutorial).
+  [lecture notes](https://stagit.tronto.net/mathsoftware) or my
+  [FMC tutorial](https://stagit.tronto.net/fmctutorial).
 * I would like to convert README.md files to html.
 
 If I were calling stagit by hand after each `git push`, I
@@ -280,7 +286,7 @@ stagit-index /home/git/*.git | sed 's|/log\.html||g' > "$basedir/index.html"
 And that's it. Well, I also copy the style files and add a bottom bar,
 and change the title from a `<span class="desc">` to an `<h1>` element,
 again using `ed`. If you want to see the details you can check them out
-[here](https://git.tronto.net/git-hooks/file/post-receive-stagit.html).
+[here](https://stagit.tronto.net/git-hooks/file/post-receive-stagit.html).
 
 ## Conclusions
 
diff --git a/src/blog/2022-12-30-blog-ready/blog-ready.md b/src/blog/2022-12-30-blog-ready/blog-ready.md
index 144e5e2..a6f0ff0 100644
--- a/src/blog/2022-12-30-blog-ready/blog-ready.md
+++ b/src/blog/2022-12-30-blog-ready/blog-ready.md
@@ -13,10 +13,9 @@ messy at some point! It would be nice to divide these posts by year...
 ## Adding year sections to my blog index
 
 Very easy: in my
-[build.sh](https://git.tronto.net/sebastiano.tronto.net/file/build.sh.html)
+[build.sh](https://git.tronto.net/sebastiano.tronto.net/tree/build.sh)
 script that I run to
-[build my website](../2022-08-14-website), there is a
-[`makeblog()`](https://git.tronto.net/sebastiano.tronto.net/file/build.sh.html#l52)
+[build my website](../2022-08-14-website), there is a `makeblog()`
 function that takes care of building the index page and RSS feed for my blog.
 
 It is enough to add the following lines inside its main loop:
diff --git a/src/blog/2023-07-11-feed/feed.md b/src/blog/2023-07-11-feed/feed.md
index feb5cd6..9c56bcb 100644
--- a/src/blog/2023-07-11-feed/feed.md
+++ b/src/blog/2023-07-11-feed/feed.md
@@ -62,7 +62,7 @@ reader UI.
 In the first version I made, my feeds were separated in folders,
 one per file, and one could select multiple feeds or even entire
 folders via dmenu using
-[dmenu-filepicker](https://git.tronto.net/scripts/file/dmenu-filepicker.html)
+[dmenu-filepicker](https://git.tronto.net/scripts/tree/dmenu-filepicker)
 for file selection.
 Once the session was terminated, all shown feeds were marked as
 "read" by writing the timestamp of the last read item on a cache
diff --git a/src/blog/2024-04-30-taming-cpp-motivation/taming-cpp-motivation.md b/src/blog/2024-04-30-taming-cpp-motivation/taming-cpp-motivation.md
index 3181eb0..532a0dd 100644
--- a/src/blog/2024-04-30-taming-cpp-motivation/taming-cpp-motivation.md
+++ b/src/blog/2024-04-30-taming-cpp-motivation/taming-cpp-motivation.md
@@ -40,7 +40,7 @@ You can find the code I wrote in
 
 To sort a list of a hundred million integers, in C we can use `qsort()`
 from `stdlib.h` (see
-[sort.c](https://git.tronto.net/taming-cpp/file/sort-benchmark/integers/sort.c.html)):
+[sort.c](https://git.tronto.net/taming-cpp/tree/sort-benchmark/integers/sort.c)):
 
 ```
 qsort(a, ARRAYSIZE, sizeof(int), compar);
@@ -55,7 +55,7 @@ int compar(const void *x, const void *y) {
 ```
 
 In C++ we can use `sort()` from `algorithm` (see
-[sort.cpp](https://git.tronto.net/taming-cpp/file/sort-benchmark/integers/sort.cpp.html)):
+[sort.cpp](https://git.tronto.net/taming-cpp/tree/sort-benchmark/integers/sort.cpp)):
 
 ```
 std::sort(a, a+ARRAYSIZE,
@@ -69,7 +69,7 @@ instead of a comparison function.
 Modern C++ also offers parallelized
 version of common algorithms as part of the standard library, so if
 we want to completely humiliate poor C we can use this (see
-[sort_parallel.cpp](https://git.tronto.net/taming-cpp/file/sort-benchmark/integers/sort_parallel.cpp.html)):
+[sort_parallel.cpp](https://git.tronto.net/taming-cpp/tree/sort-benchmark/integers/sort_parallel.cpp)):
 
 ```
 std::sort(std::execution::par, a, a+ARRAYSIZE,
@@ -94,9 +94,9 @@ Even without parallelization, C++ is twice as fast as C!
 You might think that C++ is somehow optimizing for integer
 sorting. But this is not the case, as demonstrated by a similar experiment
 with *pairs* of integers (see
-[sort.c](https://git.tronto.net/taming-cpp/file/sort-benchmark/pairs/sort.c.html),
-[sort.cpp](https://git.tronto.net/taming-cpp/file/sort-benchmark/pairs/sort.cpp.html) and
-[sort_parallel.cpp](https://git.tronto.net/taming-cpp/file/sort-benchmark/pairs/sort_parallel.cpp.html)
+[sort.c](https://git.tronto.net/taming-cpp/tree/sort-benchmark/pairs/sort.c),
+[sort.cpp](https://git.tronto.net/taming-cpp/tree/sort-benchmark/pairs/sort.cpp) and
+[sort_parallel.cpp](https://git.tronto.net/taming-cpp/tree/sort-benchmark/pairs/sort_parallel.cpp)
 - I used a non-standard mixed lexicographic order to be reasonably sure the
 compiler does not come up with any ad-hoc optimization):
 
diff --git a/src/blog/2024-12-03-2fa/2fa.md b/src/blog/2024-12-03-2fa/2fa.md
index 66f3661..3a84682 100644
--- a/src/blog/2024-12-03-2fa/2fa.md
+++ b/src/blog/2024-12-03-2fa/2fa.md
@@ -64,9 +64,9 @@ $ athtool -b --totp "SECRET_KEY"
 And that's it. However, you should not write you secret key in plain text
 like this: instead you should keep it encrypted and decrypt it just
 when you need it to generate a code. I do this by using my simple
-[2fa](https://git.tronto.net/scripts/file/2fa.html)
+[2fa](https://git.tronto.net/scripts/tree/2fa)
 script, which is based on my
-[secret](https://git.tronto.net/scripts/file/secret.html)
+[secret](https://git.tronto.net/scripts/tree/secret)
 tool that encrypts and decrypts stuff using openssl and a master
 password - which is obviously
 [correcthorsebatterystaple](https://xkcd.com/936/).
diff --git a/src/blog/2024-12-26-taming-cpp-raii/taming-cpp-raii.md b/src/blog/2024-12-26-taming-cpp-raii/taming-cpp-raii.md
index 6450521..a7c1bae 100644
--- a/src/blog/2024-12-26-taming-cpp-raii/taming-cpp-raii.md
+++ b/src/blog/2024-12-26-taming-cpp-raii/taming-cpp-raii.md
@@ -61,7 +61,7 @@ But there is a more interesting way to make this program fail by only
 changing the definition of `BadType`. In fact, you can make this program
 do pretty much everything you want by changing `BadType`'s *constructor*
 to suit your needs (see
-[surprising-error.cpp](https://git.tronto.net/taming-cpp/file/raii/surprising-error.cpp.html)):
+[surprising-error.cpp](https://git.tronto.net/taming-cpp/tree/raii/surprising-error.cpp)):
 
 ```
 class BadType {
@@ -83,7 +83,7 @@ And it does not stop here either: whenever a variable
 of a class type goes out of scope, the corresponding
 [destructor](https://en.cppreference.com/w/cpp/language/destructor)
 is called - see
-[constructor-hello-world.cpp](https://git.tronto.net/taming-cpp/file/raii/constructor-hello-world.cpp.html):
+[constructor-hello-world.cpp](https://git.tronto.net/taming-cpp/tree/raii/constructor-hello-world.cpp):
 
 ```
 #include <iostream>
@@ -254,7 +254,7 @@ from a function is a classic example, but they also come up when using
 [smart pointers](https://en.cppreference.com/book/intro/smart_pointers).
 
 I made a
-[comprehensive example](https://git.tronto.net/taming-cpp/file/raii/all-constructors.cpp.html)
+[comprehensive example](https://git.tronto.net/taming-cpp/tree/raii/all-constructors.cpp)
 of how all of these operations work, so you can see when exactly each
 of them is called. Do check it out if you are interested!
 
diff --git a/src/blog/2025-01-21-taming-cpp-templates/taming-cpp-templates.md b/src/blog/2025-01-21-taming-cpp-templates/taming-cpp-templates.md
index bce440f..903a1ff 100644
--- a/src/blog/2025-01-21-taming-cpp-templates/taming-cpp-templates.md
+++ b/src/blog/2025-01-21-taming-cpp-templates/taming-cpp-templates.md
@@ -44,7 +44,7 @@ You can find the code examples for this post in the
 [companion repository for this series](https://git.tronto.net/taming-cpp),
 and if you want you can also have a look at the final version
 of my tiny library
-[on my git page](https://git.tronto.net/zmodn/file/README.md.html). For
+[on my git page](https://git.tronto.net/zmodn). For
 this post I am going to use Clang as a compiler, because I find its
 error messages more readable most of the times.
 
@@ -69,7 +69,7 @@ cannot, for example, assign an `std::vector<int>` object to an
 As an example, let's take a simple standard library class such as
 [`std::pair`](https://en.cppreference.com/w/cpp/utility/pair).
 It could be implemented as follows (see
-[pair.cpp](https://git.tronto.net/taming-cpp/file/templates/pair.cpp.html)):
+[pair.cpp](https://git.tronto.net/taming-cpp/tree/templates/pair.cpp)):
 
 ```
 template<typename S, typename T>
@@ -151,7 +151,7 @@ which in case you don't know are just a simplified syntax for pointers.)
 Let's take this simple example to show an important property of templates.
 Let's say that, perhaps by mistake, we implemented the swap function
 using different template types for `a` and `b` (see
-[swap.cpp](https://git.tronto.net/taming-cpp/file/templates/swap.cpp.html)):
+[swap.cpp](https://git.tronto.net/taming-cpp/tree/templates/swap.cpp)):
 
 ```
 template<typename S, typename T>
@@ -204,7 +204,7 @@ to make these error messages more meaningful - we'll see some examples below.
 Objects, not just types, can be template parameters. A classic example
 is [`std::array`](https://en.cppreference.com/w/cpp/container/array),
 a fixed-size container where the capacity is fixed at compile time (see
-[std_array.cpp](https://git.tronto.net/taming-cpp/file/templates/std_array.cpp.html)
+[std_array.cpp](https://git.tronto.net/taming-cpp/tree/templates/std_array.cpp)
 for an example).
 
 Non-type parameters can be constants of any *structural type* - see
@@ -213,13 +213,13 @@ for a precise definition. Remember that you can only specialize them
 with compile-time (i.e. `constexpr`) constants!
 
 With non-type parameter you can do pretty wild stuff, see for example
-[factorial.cpp](https://git.tronto.net/taming-cpp/file/templates/factorial.cpp.html)
+[factorial.cpp](https://git.tronto.net/taming-cpp/tree/templates/factorial.cpp)
 - although this specific example is not very useful, since it can easily
 be replaced by a constexpr function.
 
 Fun fact: if you use `auto`, you don't even have to specify a type for
 a non-type parameter. For example, the following code works just fine (see
-[println.cpp](https://git.tronto.net/taming-cpp/file/templates/println.cpp.html)):
+[println.cpp](https://git.tronto.net/taming-cpp/tree/templates/println.cpp)):
 
 ```
 #include <iostream>
@@ -278,7 +278,7 @@ template for
 where `N` is a fixed at compile-time.
 
 We may start with something like this (see
-[zmodn-1.cpp](https://git.tronto.net/taming-cpp/file/templates/zmodn-1.cpp.html)):
+[zmodn-1.cpp](https://git.tronto.net/taming-cpp/tree/templates/zmodn-1.cpp)):
 
 ```
 #include <iostream>
@@ -355,7 +355,7 @@ are a way to prevent nasty run-time errors and / or make compiler errors
 more meaningful when using templates; they were added in C++20.
 
 In our case, introducing our constraint is quite simple (see
-[zmodn-2.cpp](https://git.tronto.net/taming-cpp/file/templates/zmodn-2.cpp.html)):
+[zmodn-2.cpp](https://git.tronto.net/taming-cpp/tree/templates/zmodn-2.cpp)):
 
 ```
 template<int N>
@@ -392,7 +392,7 @@ type of N.
 
 In order to do so, I can use a non-type parameter declared `auto` and
 [`decltype()`](https://en.cppreference.com/w/cpp/language/decltype) (see
-[zmodn-3.cpp](https://git.tronto.net/taming-cpp/file/templates/zmodn-3.cpp.html)):
+[zmodn-3.cpp](https://git.tronto.net/taming-cpp/tree/templates/zmodn-3.cpp)):
 
 ```
 template<auto N>
@@ -409,7 +409,7 @@ public:
 
 And of course I should also templatize the `extended_gcd()` function -
 you can see the full code in
-[zmodn-3.cpp](https://git.tronto.net/taming-cpp/file/templates/zmodn-3.cpp.html).
+[zmodn-3.cpp](https://git.tronto.net/taming-cpp/tree/templates/zmodn-3.cpp).
 
 Now we can use any type as a "base" for our modular integer! Well, almost.
 I mentioned above that the type we use must be *structural*, but that is
@@ -417,7 +417,7 @@ relatively easy to satisfy. A bigger problem is that our type must
 allow for compile-time constants - so we need, at least, a `constexpr`
 constructor. I could not find a suitable library online, so I ended
 up writing my own - see
-[bigint.h](https://git.tronto.net/taming-cpp/file/templates/bigint.h.html).
+[bigint.h](https://git.tronto.net/taming-cpp/tree/templates/bigint.h).
 
 The code is simple and not very efficient, but this library is not meant
 to be efficient. I am just using it for educational purposes.
@@ -477,7 +477,7 @@ Along with constraints, C++20 also introduced the possibility to define
 and name a custom set of requirements. This can be done with *concepts*.
 In our example, we can require that our type supports all the operations
 we need (see
-[zmodn-4.cpp](https://git.tronto.net/taming-cpp/file/templates/zmodn-4.cpp.html)):
+[zmodn-4.cpp](https://git.tronto.net/taming-cpp/tree/templates/zmodn-4.cpp)):
 
 ```
 template<typename T>
diff --git a/src/blog/2025-02-27-elliptic-curves-javascript/ecm.md b/src/blog/2025-02-27-elliptic-curves-javascript/ecm.md
index 56b876c..27e5021 100644
--- a/src/blog/2025-02-27-elliptic-curves-javascript/ecm.md
+++ b/src/blog/2025-02-27-elliptic-curves-javascript/ecm.md
@@ -40,7 +40,7 @@ Recently I have been learning C++, and I wanted to experiment with some
 of its more advanced features. So I decided to rewrite the whole thing.
 
 I had a clear idea of where I wanted to start: a small
-[library for modular arithmetic](https://git.tronto.net/zmodn/file/README.md.html),
+[library for modular arithmetic](https://git.tronto.net/zmodn),
 with compile-time fixed
 [modulus](https://en.wikipedia.org/wiki/Modular_arithmetic) via templates
 and heavy use of
@@ -57,7 +57,7 @@ algorithm with very large numbers. Unfortunately, I did not take into
 account that with my setup I needed a big integer class that supported
 *compile-time constants* - for example in the form of `constexpr`
 constructors. I could not find any, so I decided to write
-[my own big integer class](https://git.tronto.net/zmodn/file/bigint.h.html).
+[my own big integer class](https://git.tronto.net/zmodn/tree/bigint.h).
 This was less successful: implementing an *efficient* big integer library
 was not as straightforward as the modular integers library. I decided
 not to care about efficiency for the time being, but that would come
@@ -258,7 +258,7 @@ pieces of text and pictures in the slides - shoutout to
 my friend [Jared](https://guissmo.com) for telling me about
 it. Apart from this I don't have anything interesting to comment
 about the CSS part of the slides. You can check the full code
-[here](https://git.tronto.net/ecm/file/index.html.html) if you want;
+[here](https://git.tronto.net/ecm/tree/index.html) if you want;
 everything is in a single HTML file.
 
 The result looks fine, but it does not work perfectly will every screen
diff --git a/src/blog/2025-06-06-webdev/webdev.md b/src/blog/2025-06-06-webdev/webdev.md
index 50b14d9..b712a85 100644
--- a/src/blog/2025-06-06-webdev/webdev.md
+++ b/src/blog/2025-06-06-webdev/webdev.md
@@ -19,7 +19,7 @@
 ## Introduction
 
 I have recently worked on making a web application out of
-[my latest Rubik's cube optimal solver](https://git.tronto.net/nissy-core/file/README.md.html).
+[my latest Rubik's cube optimal solver](https://git.tronto.net/nissy-core).
 This involved building a rather complex C code base (with
 multithreading, SIMD, callback functions and whatnot) to
 [WebAssembly](https://en.wikipedia.org/wiki/WebAssembly) via
@@ -27,7 +27,7 @@ multithreading, SIMD, callback functions and whatnot) to
 JavaScript and HTML for the frontend.
 
 This whole process was complex, tiring and at times frustrating -
-but eventually [it was a success](https://tronto.net:48)! Not only
+but eventually [it was a success](https://h48.tronto.net)! Not only
 I accomplished my goal, but I have learnt a lot along the way. After
 finishing the work, I decided to write down all that I have learnt and
 share it with the world with this post.
@@ -77,7 +77,7 @@ With this out of the way, let's get started!
 
 The examples used in this tutorial are all contained in a git repository,
 which you can find either on
-[my git page](https://git.tronto.net/emscripten-tutorial/file/README.md.html) or
+[my git page](https://git.tronto.net/emscripten-tutorial) or
 [on github](https://github.com/sebastianotronto/emscripten-tutorial).
 
 In order to follow them you are going to need:
@@ -161,7 +161,7 @@ but in case you are interested you can check out
 You can find the code for this example, as well as scripts to
 build it and run the web server, in the directory `00_hello_world`
 of the git repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 
 Anyway, now we can build our C code to run in a web page.  But this is
@@ -324,7 +324,7 @@ The answer is 42
 
 The code for this example can be found in the `01_library` folder in
 the git repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 
 ## Intermezzo II: JavaScript and the DOM
@@ -593,7 +593,7 @@ is included directly in `script.mjs`.
 
 You can find the full the code for this example the folder
 `02_library_modularized` in the git repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 
 ## Multithreading
@@ -740,7 +740,7 @@ the server you are using; with darkhttpd you can use the `--header` option.
 With your server correctly set up, you can enjoy a multithreaded program
 running in your browser!  As always, you can check out this example from
 the `03_threads` folder of the git repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 
 ## Intermezzo III: Web Workers and Spectre
@@ -860,7 +860,7 @@ whose `data` property contains the object that was sent with `postMessage()`.
 
 You can check out this example in the directory `04_no_block` in the
 repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 Try also large numbers, in the range of millions or tens of millions, and
 compare it with the previous example - but not don't go too large, we
@@ -948,7 +948,7 @@ Other than that, you just need to add a couple of compiler flags:
   out module at runtime with `addFunction()`.
 
 And as you can check by running the example `05_callback` from the repo
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)),
 everything works as expected, both in Node.js and in a web page.  To make
 the examples more interesting, the web page one is not only not logging the
@@ -1120,7 +1120,7 @@ And with all this, we are ready to run our optimized version of the
 `primes_in_range()` algorithm, all from within our browser! As always,
 you can check out the complete code in the folder `06_storage` of
 the repository
-([git.tronto.net](https://git.tronto.net/emscripten-tutorial/file/README.md.html),
+([git.tronto.net](https://git.tronto.net/emscripten-tutorial),
 [github](https://github.com/sebastianotronto/emscripten-tutorial)).
 
 If generating this data on the user's side seems redundant, you can
diff --git a/src/blog/2025-06-26-borrow-checker/borrow-checker.md b/src/blog/2025-06-26-borrow-checker/borrow-checker.md
index b22d741..10c4ac5 100644
--- a/src/blog/2025-06-26-borrow-checker/borrow-checker.md
+++ b/src/blog/2025-06-26-borrow-checker/borrow-checker.md
@@ -2,12 +2,11 @@
 
 As I mentioned in my [last post](../2025-06-13-cargo-culture-shock),
 in the last couple of weeks I have been learning Rust. I have written
-[a small library](https://git.tronto.net/zmodn-rs/file/README.md.html) for
+[a small library](https://git.tronto.net/zmodn-rs) for
 [integers modulo N](https://en.wikipedia.org/wiki/Modular_arithmetic)
 (the original C++ version was mentioned in
 [this post](../2025-01-21-taming-cpp-templates), rewritten
-[my implementation](https://git.tronto.net/ecm/file/README.md.html)
-of the
+[my implementation](https://git.tronto.net/ecm) of the
 [ECM algorithm](https://en.wikipedia.org/wiki/Lenstra_elliptic-curve_factorization)
 (mentioned in [this other post](../2025-02-27-elliptic-curves-javascript))
 and I am now playing around with some past
diff --git a/src/blog/2025-11-29-aoc-download/aoc-download.md b/src/blog/2025-11-29-aoc-download/aoc-download.md
index 29e56fc..bbde45e 100644
--- a/src/blog/2025-11-29-aoc-download/aoc-download.md
+++ b/src/blog/2025-11-29-aoc-download/aoc-download.md
@@ -79,7 +79,7 @@ And you are good to go!
 Typing out the full command above may look cooler than downloading the file
 by right-clicking "Save page as", but it is just as annoying. So obviously I
 saved that command to
-[a script](https://git.tronto.net/scripts/file/aoc.html)
+[a script](https://git.tronto.net/scripts/tree/aoc)
 that also detects the correct file to download based on the current date
 (or on two optional parameters for the year and the day). My script also
 opens up an editor and [Lynx](https://en.wikipedia.org/wiki/Lynx_(web_browser))
diff --git a/src/blog/2026-03-27-programming-20-years/20-years-of-programming.md b/src/blog/2026-03-27-programming-20-years/20-years-of-programming.md
index 8e5b1a2..1daa441 100644
--- a/src/blog/2026-03-27-programming-20-years/20-years-of-programming.md
+++ b/src/blog/2026-03-27-programming-20-years/20-years-of-programming.md
@@ -60,7 +60,7 @@ it creates a few more.
 
 I managed to recover some of the
 programs I wrote between 2006 and 2010 in [a git
-repository](https://git.tronto.net/ancient-projects/file/README.md.html).
+repository](https://git.tronto.net/ancient-projects).
 The most successful one is JBriscola, a single-player game of
 [briscola](https://en.wikipedia.org/wiki/Briscola) with a decent AI. It is
 actually quite fun to play, and a few of my friends played it regularly
@@ -153,8 +153,7 @@ a PhD.  But at the beginning of my PhD, in 2019, I wrote
 some code for work: my supervisor and a colleague of mine had
 devised an algorithm to compute the degrees of certain [field
 extensions](https://en.wikipedia.org/wiki/Field_extension),
-and I [implemented
-it](https://git.tronto.net/kummer-degrees/file/README.md.html).
+and I [implemented it](https://git.tronto.net/kummer-degrees).
 
 I don't know if this is what got me back into coding for fun, or if it
 was just a matter of time, but by the end of 2019 I was already thinking
diff --git a/src/blog/2026-08-15-dotfiles/dotfiles.md b/src/blog/2026-08-15-dotfiles/dotfiles.md
new file mode 100644
index 0000000..ce10ef0
--- /dev/null
+++ b/src/blog/2026-08-15-dotfiles/dotfiles.md
@@ -0,0 +1,88 @@
+# Dotfiles backup and bootstrap
+
+It took me more than 18 years of using Linux, but I have finally bought
+a used [Thinkpad](https://en.wikipedia.org/wiki/ThinkPad), thus becoming
+a *real* Linux user. To be specific, I got a Thinkpad L13 from ~2020 with
+an Intel i5 CPU and 8Gb of RAM.
+
+After I bought the laptop, it was time to set it up to my likings. I usually
+do this by installing a Linux distro and then manually copying my
+configuration files (a.k.a. *dotfiles*) from some messy backup folder. Since
+I do this quite rarely, and since when I do I also tend to pick a different distro
+just to try it out, I have never bothered automating this process...
+
+...But not anymore! This time I decided to set things up properly.
+
+## OS choice: Alpine Linux
+
+For the operating system, I chose [Alpine Linux](https://alpinelinux.org/).
+It is an extremely simple Linux distribution that relies on minimalistic
+core tools - for example, it uses [busybox](https://busybox.net/) instead of
+[GNU coreutils](https://www.gnu.org/software/coreutils/) and
+[OpenRC](https://en.wikipedia.org/wiki/OpenRC) instead of
+[SystemD](https://en.wikipedia.org/wiki/SystemD). Its package manager is incredibly
+fast (and it can be used [declaratively](../2025-08-16-alpine-declarative)) and
+it's [wiki](https://wiki.alpinelinux.org/wiki/Main_Page) is well-maintained.
+I am liking it a lot, but your mileage may vary - especially because it uses
+[musl](https://musl.libc.org/) as the system C library, breaking compatibility
+with some pre-built applications and, notably, with video streaming platforms
+that rely on [DRM](https://en.wikipedia.org/wiki/Digital_rights_management).
+
+Other options I considered were [Void Linux](https://voidlinux.org),
+that I have happily used since 2020, [OpenBSD](https://www.openbsd.org),
+that I am using on my server and on my old [netbook](../2022-09-10-netbooks),
+[Debian](https://www.debian.org), that I am using on my [gaming
+desktop](../2023-10-15-build-time) and [Slackware](http://www.slackware.com),
+the old time favorite that I used back in 2009-2013. I am not going to explain
+the reasons why I settled on Alpine in the end; it is mostly a matter of
+personal preference anyway.
+
+## Configuration files as a git repository
+
+As for my configuration files, they are now managed via a [git
+repository](https://git.tronto.net/config), as explained in [this blog post
+by Drew De Vault](https://drewdevault.com/blog/dotfiles). In short:
+
+* My home directory is a git repository.
+* All files are ignored by default (my `.gitignore` contains a single line: `*`).
+* Configuration files that I wish to track are manually added with
+  `git add -f my_file`.
+
+This way, the path of each file is preserved in the structure of the
+repository, and cloning it into a new system's `$HOME` makes everything
+fall into place.
+
+There is a small caveat with this setup: every file and directory that is
+directly or indirectly contained in my home, even if `gitignore`'d, is now
+part of this git repository. This includes other git repositories, and this
+could break certain development tools - for example, I had issues with
+[ty](https://docs.astral.sh/ty) ignoring all files due to them being
+`gitignore`'d by my configuration file repository.
+
+While I was at it, I have also moved my [scripts](https://git.tronto.net/scripts)
+into this repository, since they are part of my desktop setup anyway.
+
+## Bootstrapping
+
+Copying configuration files into the right place is not the only thing
+I need to do when I set up a new laptop. I also need to install packages,
+build some software from source (for example, [dwm](https://dwm.suckless.org)),
+edit some configuration files that are outside of `$HOME` (for example,
+in `/etc`), and so on.
+
+I tried to automate these steps as much as I could turned them into [a
+script](https://git.tronto.net/config/tree/scripts/setup-config-alpine). I
+won't explain everything it does here, you can just read through it if you want -
+it is pretty self-explanatory. This script also takes care of cloning the dotfiles
+repository I mentioned above, so when I set up a new system I just need to download
+a copy of this script from my server and run it.
+
+The script ends by printing some instruction on the remaining manual steps,
+such as uploading my SSH keys into some machines that I regularly
+access remotely and copying copying some secrets into `.ssh`.
+
+## Conclusion
+
+This setup may be a bit overengineered, but it gives me a consistent way to
+quickly set up a new computer, and it also serves as documentation on my local
+configuration.
diff --git a/src/blog/2026-09-05-cgit/cgit.md b/src/blog/2026-09-05-cgit/cgit.md
new file mode 100644
index 0000000..29d92ba
--- /dev/null
+++ b/src/blog/2026-09-05-cgit/cgit.md
@@ -0,0 +1,141 @@
+# From stagit to cgit
+
+When I first set up this website back in 2022, I also started self-hosting
+my git repositories. To make them accessible via web I used
+[stagit](https://codemadness.org/stagit.html), and I wrote about this
+in [an old blog post](..//2022-11-23-git-host/). In short, I used a custom
+post-receive [git
+hook](https://git-scm.com/book/en/v2/Customizing-Git-Git-Hooks) that used
+stagit to generate the HTML pages for [my git
+website](https://stagit.tronto.net).
+
+This script ran every time I pushed some changes to a repository.
+After calling stagit, the script would also modify the generated
+pages to add a custom Download button at the top, which was not
+efficient. For my largest repositories, this took around
+a couple of minutes for every `git push`. Moreover, having all the file
+contents both in the git folder and in the HTML pages wasted some
+space on my small VM.
+
+So I looked for alternatives, and I found
+[cgit](https://git.zx2c4.com/cgit/about/), which works quite differently
+from stagit. I gave it a try, and I am quite happy with the result! If
+you want to check it out, go to [git.tronto.net](https://git.tronto.net).
+A frozen version of the old stagit-generated pages is still available at
+[stagit.tronto.net](https://stagit.tronto.net).
+
+## Static pages versus CGI
+
+Instead of generating pages to be served by a
+[web server](https://en.wikipedia.org/wiki/Web_server), cgit is
+based on [CGI](https://en.wikipedia.org/wiki/Common_Gateway_Interface).
+To put it simply, cgit is a program that continuously runs on a server,
+generating on the fly each page a visitor requests.
+
+There is an obvious trade-off between disk space and CPU usage here:
+on the one hand we don't need to store all the HTML pages that are
+essentially a duplicate of what can already be found in the git
+repository's folder; on the other hand, computing the page on the
+go takes some work for the server's CPU. However, cgit can also
+cache the most recently viewed pages, so it does not have to re-compute
+the most requested ones all that often.
+
+Of course, another cost is the more complex setup, as we are now dealing with
+a full-blown web application instead of plain and simple static HTML files.
+We'll get into some of the problems that this causes in the next section.
+
+## OpenBSD and cgit
+
+As you may know, the [VM](https://en.wikipedia.org/wiki/Virtual_machine)
+that  hosts this website has historically been running on
+[OpenBSD](https://openbsd.org) (spoiler: this is no longer the case).
+When it comes to hosting cgit, or any CGI application, this comes with
+some pros and some cons.
+
+First off, the pros: OpenBSD's base system already has a web server
+([httpd](https://man.openbsd.org/httpd.8)) and a FastCGI server
+([slowcgi](https://man.openbsd.org/slowcgi.8)) that are capable of
+running cgit. So no external program is strictly needed other than
+cgit itself - see [this short
+tutorial](https://codemadness.org/openbsd-httpd-and-cgit.html) for
+details.
+
+But there are some points of friction that arise from one of httpd's
+most-loved security features: the fact that it works in a
+[chroot](https://en.wikipedia.org/wiki/Chroot) environment, by default
+rooted at `/var/www`. This means that httpd cannot see any file outside
+of `/var/www`. So any file that cgit needs, including all the git
+repositories that one wants to show, must be inside `/var/www`.
+
+And while it is not much effort to put them there, I have been
+managing my repositories via a dedicated `git` user, keeping them in
+`/home/git`. So I would have to either change this user's home directory
+to something in `/var/www`, or change the relative path of each repository.
+Either way, it wouldn't be as nice as my current setup.
+
+But the repositories are not all cgit may want to know about. For example,
+one can *filter* README files through a Markdown parser, such as
+[lowdown](https://kristaps.bsd.lv/lowdown/), to display more nicely on the
+web - see [this README](https://git.tronto.net/nissy-core/about/) for an
+example. The parser, too, must live within httpd's chroot. Same for any
+[dynamic library](https://en.wikipedia.org/wiki/Dynamic_library) it
+depends on. To make this work, I ended up creating `usr/bin` and `usr/lib`
+folders inside `/var/www` and manually copied some executables and libraries
+there - not the cleanest solution.
+
+Alternatively, one may configure httpd to chroot at `/`, making things
+more practical but loosing the security benefits. But at this point,
+I decided I wanted to try out a different stack - new VPS provider, new
+OS, new web server. This is something I had been thinking about for
+about a year at this point, and I'll talk about the reasons in [my
+next post](../2026-09-13-host-migration).
+
+But if you plan to host cgit on OpenBSD, do not be discouraged!
+Everything can be set up with just a little manual work.
+
+## My cgit configuration
+
+My new cgit instance is hosted on an [Alpine Linux](https://alpinelinux.org)
+VM and it is running via [Lighttpd](https://www.lighttpd.net).
+For the basic setup, I followed [this wiki
+page](https://wiki.alpinelinux.org/wiki/Cgit) (note that lighttpd has a
+`mod_cgi` module that replaces fcgiwrap entirely). Not much
+to say here, just a little fiddling with lighttpd's configuration.
+
+As for customization, my configuration files are available in my
+[cgit-config](https://git.tronto.net/cgit-config) repository. The
+main configuration file,
+[cgitrc](https://git.tronto.net/cgit-config/tree/cgitrc), is
+well-commented, and won't require further explanation.
+
+There are a bunch of other files too, such as the custom
+[about-filter.sh](https://git.tronto.net/cgit-config/tree/custom/about-filter.sh)
+which, is used to display README files more nicely. As for the custom
+[css](https://git.tronto.net/cgit-config/tree/custom/cgit.css), the
+main feature is making the website a little more comfortable to
+browse on mobile; I shamelessly copied this part from [another cgit
+user](https://git.matejamaric.com/responsive-cgit-css).
+
+## Pros and con(cern)s
+
+So far, cgit seems to run pretty fast on my new VM with a single CPU
+core and 1GB of RAM. It also looks pretty cool, even though I liked
+stagit's simplicity.
+
+Unfortunately, the nice download button that I added to each of my
+repositories is now gone. cgit allows downloading tarballs of a repo,
+but only from tags, not for the current state of the master branch.
+Overall, stagit's simplicity also allowed for great deal of customizability.
+
+I am also a bit concerned about AI
+[crawlers](https://en.wikipedia.org/wiki/Web_crawler). I have heard horror
+stories of people having to make their repositories private because of
+bots scanning their pages to feed the slop machine overloading their servers.
+However, I hope cgit being quite small compared to a
+[forge](https://en.wikipedia.org/wiki/Forge_(software)) such as
+[GitLab](https://en.wikipedia.org/wiki/GitLab) or
+[Gitea](https://en.wikipedia.org/wiki/Gitea) will help my server
+sustain the extra effort - if any bot is interested in my code at all.
+
+In conclusion, stagit served me well for a while, and I think
+cgit is better suited to my needs now.
diff --git a/src/blog/2026-09-13-host-migration/host-migration.md b/src/blog/2026-09-13-host-migration/host-migration.md
new file mode 100644
index 0000000..72a26ef
--- /dev/null
+++ b/src/blog/2026-09-13-host-migration/host-migration.md
@@ -0,0 +1,172 @@
+# Host migration
+
+Since this website went online in 2022, It has lived
+in a virtual machine on server 14 at [OpenBSD
+Amsterdam](https://openbsd.amsterdam). This is a small, independent
+VPS provider that donates large part of their profit to the
+[OpenBSD foundation](https://www.openbsdfoundation.org). They
+are pretty cool, and their service worked quite well for me.
+
+Nonetheless, I have recently migrated to another provider, and I
+am not going to renew my OpenBSD Amsterdam subscription next year.
+There are a few reasons for this.
+
+## Why switch?
+
+First of all, I want to make clear that I did not have any issue
+with OpenBSD Amsterdam. In fact, I think it was the right choice for
+me 4 years ago, and I can strongly recommend it.
+
+OpenBSD as well was a great OS choice, at the beginning.
+The convenience of having many of the services I needed - such as
+[httpd](https://man.openbsd.org/httpd),
+[rsync](https://man.openbsd.org/openrsync),
+[ssh](https://man.openbsd.org/ssh) - included in the base system and
+well-documented was big. But OpenBSD is also an
+[opinionated](https://www.merriam-webster.com/dictionary/opinionated)
+piece of software,
+and some of its "opinions" started feeling a bit restrictive.
+
+For example, OpenBSD nudges you into using separate
+[partitions](https://en.wikipedia.org/wiki/Disk_partitioning) for
+different system folders, for security reasons. This is how the 50GB
+of my OpenBSD Amsterdam VM are currently allocated:
+
+```
+[pizoc ~] $ df -h
+Filesystem     Size    Used   Avail Capacity  Mounted on
+/dev/sd0a      986M    111M    825M    12%    /
+/dev/sd0k     17.4G    3.9G   12.6G    24%    /home
+/dev/sd0d      3.2G    8.0K    3.0G     1%    /tmp
+/dev/sd0f      5.2G    1.7G    3.3G    34%    /usr
+/dev/sd0g      986M    545M    392M    59%    /usr/X11R6
+/dev/sd0h      6.7G    184M    6.2G     3%    /usr/local
+/dev/sd0j      5.8G    2.0K    5.5G     1%    /usr/obj
+/dev/sd0i      1.9G    2.0K    1.8G     1%    /usr/src
+/dev/sd0e      5.0G    4.4G    423M    92%    /var
+```
+
+My websites are in `/var/www`, and as you can see that partition
+is almost full. I also use `/home` extensively - my git repositories
+are in `/home/git` and a shared
+[syncthing](https://syncthing.net) folder is in `/home/sebastiano`.
+I have plenty of space still available in `/home`, but I can't
+esily use it for hosting websites, because of httpd's chroot. See
+[my previous post](../2026-09-05-cgit) for details on what this means.
+
+Another downside of httpd is that it is not as feature-complete
+as other web server. This can be considered an advantage, but
+occasionally it requires some extra setup for certain use cases.
+For example, [until
+recently](https://undeadly.org/cgi?action=article;sid=20260725103657)
+it did not support custom HTTP headers, so I had to combine it
+with relayd when I wanted to experiment with a [web
+application](https://h48.tronto.net) I was working on - see also
+[my post on WebAssembly](../2025-06-06-webdev/) for context.
+Once again, this was not a showstopper, but
+it was unnecessary additional friction.
+
+Lastly, my provider was a bit more expensive than I would have
+liked: 71€ per year for a VM with 1GB of RAM and 50GB of
+storage. For comparison, I am now paying 22€ per year for
+a VM with the same RAM and 30GB of storage. To be fair,
+OpenBSD Amsterdam is a small, independent provider, and they
+donate a most of their revenuw to the OpenBSD foundation; I was
+happy to support them. But I am also happy to save 49€
+per year.
+
+## The new stack
+
+My new provider is [netcup](https://www.netcup.com/en), an established
+German company. I don't personally know anyone hosting there,
+but their prices are good and the reviews are positive. Their [smallest
+VPS](https://www.netcup.com/en/server/vps-lite) is only 1.87€ per
+month, and it is enough for my needs.
+
+They support any operating system that can boot from a
+[Qcow](https://en.wikipedia.org/wiki/Qcow) image, as you can upload your
+own; so technically I could have stayed with OpenBSD. But I wanted
+to change the OS for the reasons I gave in the previous section, so I
+went with [Alpine Linux](https://alpinelinux.org), a lightweight
+Linux distribution that I have been pleasantly using on my laptop for a
+while now.
+
+As for the web server, I did not give it much thought.
+[Lighttpd](https://www.lighttpd.net) seems fairly lightweight and it
+does what I need it to do, so I went with that.
+
+## Migration hiccups
+
+I initially planned to migrate my [git server](../2026-09-05-cgit)
+and this website one at the time, but soon I realized that it would have
+been less work and less risk to do everything at once. So I set aside
+a full Sunday afternoon to move everything over.
+
+Unfortunately, I had some issues. The biggest one, that took me over
+three hours to work around, was related to setting up my SSL
+certificates - the "S" in [HTTPS](https://en.wikipedia.org/wiki/HTTPS).
+I wanted to use the same software I was using on OpenBSD,
+[acme-client](https://man.openbsd.org/acme-client.1), but something
+went wrong. I kept getting an HTTP 409 error with the following
+explanation:
+
+```
+acme-client: transfer buffer: [{
+"type": "urn:ietf:params:acme:error:conflict",
+"detail": "Unable to update challenge :: failed to mark authz as processing: Authorization is already being validated. This may indicate your client attempted the same challenge multiple times, possibly due to a client bug.",
+"status": 409
+}] (296 bytes)
+acme-client: bad exit: netproc(31648): 1
+```
+
+Searching online, I found out that I was [not the only
+one](https://www.reddit.com/r/openbsd/comments/1vz4mcg/acmeclient_bad_http_409)
+with this problem, so I decided to use [certbot](https://certbot.eff.org)
+as a temporary workaround. But I still want to go back to
+acme-client at some point.
+
+The other issue was AI. And I am not talking about OpenAI's and
+Anthropic's bots accessing my git pages every 0.9 seconds (that
+is not an exaggeration, I `tail -f`'d the log file). I am
+talking about actually trying to use these chatbots for their
+intended purpose. Namely, instead of reading the manual pages
+for lighttpd and writing a configuration file from scratch,
+I asked AI (either [duck.ai](https://duck.ai)) or
+[Kagi Assistant](https://kagi.com/assistant/), I forgot which one)
+to translate my httpd configuration file to a lighttpd one. Then
+I could look up the documentation for just the settings I was
+using, saving some time. Or so I thought.
+
+First of all, the initial response had more stuff than
+I wanted. The bot just allucinated features that were not included
+in the original configuration. But that's alright, it's just how
+the slop machine works.
+
+But then there were also errors, in particular with setting
+up the redirects from my `http://*.tronto.net` domains to their
+`https://` counterparts. I went through various iterations of
+"this does not work, it does X instead of Y, please fix" and
+"You are absolutely right! Here is the fixed version",
+but somehow the bots could
+never come up with a working configuration. I ended up fixing
+it by hand like a caveman, as I should have done from the
+beginning. What a waste of time.
+
+But by the end of the afternoon, almost everything was working
+as intended.
+
+## My experience so far
+
+So far everything is working smoothly. Once in a while I notice
+a minor mistake I made during the setup and I fix it - for example,
+I have just noticed this morning that lighttpd's access log was
+eating most of my storage, so I disabled it. But everything is now
+up and running, and this page you are reading is served by my new
+stack - unless you are reading it years after I published this
+post and I have changed my setup again in the meantime.
+
+The only real difference I noticed is that when I use `rsync`
+to update my website, the whole process is much, much faster
+- like 10x faster. I don't know if this is because the new
+server has a much faster hard drive or because OpenBSD's `rsync`
+was much slower. In any case, it is a nice surprise!