Merge pull request 'soup is really the main branch anyway' (#1) from soup into main

Reviewed-on: https://git.house-of-lucas.net/al/pages/pulls/1

.gitignore

@@ -0,0 +1,6 @@
+**/serve/
+**/soupault.toml
+css/code.css
+pgvv/
+all_chars.txt
+**/fonts/**/*-Subset.*

README.md

@@ -1,3 +1 @@
-# plexpage
+Scripts for building my static web pages.
-
-All of my websites, self-served from a single host.

acl.cool/site/OVERVIEW_GP1.html

@@ -1,5 +1,4 @@
-<h1 id="programming-language-general-purpose-1">Overview of the GP1 Programming Language</h1>
+<h1 id="programming-language-general-purpose-1">Overview of the <br>GP1 Programming Language</h1>
-<h2 id="description">Description</h2>
 <p>GP1 is a statically typed, multi-paradigm programming language with
 an emphasis on brevity and explicitness. It provides both value and
 reference types, as well as higher-order functions and first-class
@@ -150,7 +149,7 @@ value can be used as a literal in this fasion.</p>
 <p><code>string</code> is a unicode string. String literals are
 double-quoted, e.g. <code>"Hello, World."</code>.</p>
 <h3 id="arrays">Arrays</h3>
-<p>GP supports typical array operations.</p>
+<p>GP1 supports typical array operations.</p>
 <pre class="gp1"><code>var tuples : (int, int)[]; // declare array of tuples
 var strings : string[];    // declare array of strings
 

acl.cool/site/assets/fonts

@@ -0,0 +1 @@
+../../../fonts

acl.cool/site/css

@@ -0,0 +1 @@
+../../css

acl.cool/site/css-sample.dj

@@ -0,0 +1,50 @@
+# Evaluate This Style.
+
+Abraham Lincoln delivered the Gettysburg Address in 1863 at the dedication of Soldiers' National Cemetery.
+
+> Four score and seven years ago our fathers brought forth on this continent, a new nation, conceived in Liberty, and dedicated to the proposition that all men are created equal.
+>
+> Now we are engaged in a great civil war, testing whether that nation, or any nation so conceived and so dedicated, can long endure. We are met on a great battle-field of that war. We have come to dedicate a portion of that field, as a final resting place for those who here gave their lives that that nation might live. It is altogether fitting and proper that we should do this.
+>
+> But, in a larger sense, we can not dedicate --- we can not consecrate --- we can not hallow --- this ground. The brave men, living and dead, who struggled here, have consecrated it, far above our poor power to add or detract. The world will little note, nor long remember what we say here, but it can never forget what they did here. It is for us the living, rather, to be dedicated here to the unfinished work which they who fought here have thus far so nobly advanced. It is rather for us to be here dedicated to the great task remaining before us --- that from these honored dead we take increased devotion to that cause for which they gave the last full measure of devotion --- that we here highly resolve that these dead shall not have died in vain --- that this nation, under God, shall have a new birth of freedom --- and that government of the people, by the people, for the people, shall not perish from the earth.
+
+## Djot Syntax
+
+We can set block quotes like the above by prefixing each line (including blank ones) with `> `. This is _essentially_ a port from [commonmark](https://commonmark.org/), though as usual, [djot](https://djot.net/) makes minor changes for simplicity and consistency.
+
+> .o'i mu xagji sofybakni cu zvati le purdi
+
+*Caution.* Five hungry Soviet cows are in the garden.
+
+```lean4
+def map' {α β : Type} (f : α → β) : List α → List β
+  | [] => []
+  | x :: xs => f x :: map' f xs
+
+theorem fuse {α β γ} : ∀ (xs : List α) (f : α → β) (g : β → γ),
+  (map' g ∘ map' f) xs = map' (g ∘ f) xs := by
+  intro xs f g
+  induction xs
+  . simp [map']
+  . rename_i _ _ IH
+    simp [map', ←IH, Function.comp]
+```
+
+A simple proof of fusion for `List.map` in Lean 4. This and similar theorems are why pure languages like Lean and Haskell can transform e.g. `map f xs |> map g xs` into `map (fun x -> g (f x)) xs`, i.e. `map g . map f` into `map (g . f)`, reducing the number of times a structure must be iterated and thus improving spatial locality.
+
+The above block is set with ```` ``` ```` above and below the code. Interestingly, trying to type that little backtick sequence there is a little unintuitive in markdown/djot. If the code you're trying to set has n consecutive backticks in it, you have to surround it with n+1 backticks and pad those delimiters inside with a space. 1234567890 is a pretty small number, really.
+
+***
+
+There are ten books in Iain M. Banks' _Culture_ series, possibly the greatest cohesive science-fiction series of all time. Banks' prose and poetry leaves little to be desired.
+
+1. Consider Phlebas
+2. The Player of Games
+3. The State of the Art
+4. Use of Weapons
+5. Excession
+6. Inversions
+7. Look to Windward
+8. Matter
+9. Surface Detail
+10. The Hydrogen Sonata

acl.cool/site/draft/assam.dj

@@ -0,0 +1,17 @@
+# Algorithm ℳ
+
+During the implementation of my library "Aasam", based on the paper "Precedences in specifications and implementations of programming languages" by Annika Aasa, was the first time I fully read and understood an academic CS paper. It's a nice algorithm, and worth revisiting.
+
+If you want to look at the implementation ahead-of-time, [Hackage](https://hackage.haskell.org/package/aasam) has got you covered. Frankly though, just keep reading; it was also the first time I wrote a Haskell program, and the code not terribly penetrable.
+
+## Distfix Grammars
+
+_Distfix grammars and notation are more commonly referred to as "mixfix", but the paper calls them "distfix" and that's what I'm sticking with._
+
+The idea of distfix grammars is to provide a formalism for manipulating user-defined operators. The formalism is weaker than that of context-free grammars--- CFGs can describe far more languages then DFGs--- but it is because of this weakness that we can reason about DFGs with relative ease.
+
+Let's look at a definition.
+
+*STUFF HERE*
+
+As we can see, ...

acl.cool/site/draft/derive-appfun.dj

@@ -0,0 +1,52 @@
+# Functors and Applicatives for Free[^falsehood]
+
+It's usually possible to derive implementations of general structures from those of more specific ones, e.g. `Applicative` from `Monad` and `Functor` from `Applicative`. Here's how to do it and and why it's probably best avoided.
+
+```ocaml
+module type Functor = sig
+  type 'a t
+  val map : ('a -> 'b) -> 'a t -> 'b t
+end
+
+module type Applicative = sig
+  type 'a t
+  val pure : 'a -> 'a t
+  val apply : ('a -> 'b) t -> 'a t -> 'b t
+end
+
+module type Monad = sig
+  type 'a t
+  val return : 'a -> 'a t
+  val bind : ('a -> 'b t) -> 'a t -> 'b t
+end
+
+module ApplicativeOfMonad (M : Monad) :
+  Applicative with type 'a t = 'a M.t = struct
+  type 'a t = 'a M.t
+  let pure = M.return
+  let apply f x = M.(bind (fun y -> bind (fun g -> return (g y)) f) x)
+end
+
+module FunctorOfApplicative (A : Applicative) :
+  Functor with type 'a t = 'a A.t = struct
+  type 'a t = 'a A.t
+  let map f x = A.(apply (pure f) x)
+end
+
+module FunctorOfMonad (M : Monad) :
+  Functor with type 'a t = 'a M.t = struct
+  include FunctorOfApplicative(ApplicativeOfMonad(M))
+end
+```
+
+It turns out that there are multiple ways to implement the derivation functors--- also multiple ways to implement a particular monad--- and they don't all behave the same, which means it's hard to predict whether the more-general, derived implementations are the "natural" ones that you expected to get without _ad hoc_ testing, which obviously rather defeats the point of "free". On the other hand, the derivations here can be performed pretty mechanically, with little insight, by following the types in much the same way one might mechanically prove an easy proposition.
+
+***
+
+The modules above that seem to have parameters, do; these modules are called "functors". A functor in OCaml parlance is distinct from anything called a "functor" elsewhere, being essentially a function from modules to modules. For practical reasons, modules and value-level programs are stratified from one another in OCaml[^1ml], so a functor does not literally have a function type, but the mental model is still basically correct.
+
+A subtlety of the OCaml module system is that if a module is defined with a particular `module type` a.k.a. signature attached, e.g. `module M : S = struct...`, all the types that are abstract in the signature `S` will _also_ be abstract in the module itself. This means that the compiler can't see or be convinced that for some `F (M)` with `type t = M.t` in `F`, `M.t` and `(F (M)).t` are equal. This is because both types are abstract, meaning the underlying type is not available. To fix this, we can explicitly expose the equality by using the `with type` construct. In the above, `Functor with type 'a t = 'a M.t`--- for example--- exposes the equality of the two types, so that functions defined as expecting arguments of `'a t` can accept `'a M.t`, and _vice versa_.
+
+[^falsehood]: Unsurprisingly, that's a lie. You have to buy a `Monad` first.
+
+[^1ml]: See [1ML](https://people.mpi-sws.org/~rossberg/1ml/1ml-jfp-draft.pdf) for an OCaml-like language without this stratification.

acl.cool/site/draft/misc.dj

@@ -0,0 +1 @@
+- Good Eats, Chocolate Lava Cake and Chocolate Mousse episode: great style; plenty of references

acl.cool/site/draft/nomad.dj

@@ -0,0 +1,111 @@
+# A Monad in OCaml
+
+It's an old tradition that any programmer who thinks they know something useful about monads eventually succumbs to the temptation to go off and write a blog post about their revelations . . .
+
+_Anyway_ . . .
+
+Lets take a look at a `Monad` definition in OCaml and walk through the clues that suggest a monad's implementation.
+
+In OCaml, abstract structures such as monads are typically best represented using [modules](https://www.pathsensitive.com/2023/03/modules-matter-most-for-masses.html). A module is essentially a record, containing types and terms, along with a manifest or interface that allows a programmer to selectively expose information about that module to the outside world and, dually, to selectively depend on particular characteristics of other modules. Modules provide programmers the machinery of composition and reuse and are the primary mechanism by which OCaml code is structured, neatly capturing the notion of a program abstraction boundary.
+
+```ocaml
+module type Monad = sig
+  type 'a t
+  val return : 'a -> 'a t
+  val bind : ('a -> 'b t) -> 'a t -> 'b t
+end
+```
+
+Above is a module _signature_. Signatures themselves can be thought of as relating to modules in much the same way that types relate to values (hence `module type` in the syntax): each one defines the set of all possible modules that comply with the structure it describes. In this case, we give the name "`Monad`" to the set of modules exposing _at least_ a type constructor `'a t`[^alpha], a function `return : 'a -> 'a t`, and a function `bind : ('a -> 'b t) -> 'a t -> 'b t`. Abstractly, these three items together are what constitute a monad.
+
+It's helpful to think about what each item means in general before examining them in more concrete terms. `t` is a function from types to types, also known as a type constructor, or a "generic type"[^not-quite] in some languages. `list` and `option` both are examples of type constructors. The presence of `t` in our `Monad` signature--- specifically the fact that it's parametric, i.e. `'a t` rather than just `t`--- represents the idea that a monad is essentially a _context_ around underlying computations of an abstract type. For some particular `'a` and some particular module that fits the `Monad` signature above, `'a` is the type of the underlying computation; that is, `t` is the generic context itself, and `'a t` is an instance of that generic context which is specific to the inner type `'a`; `'a t` is the type of alphas in the `t` sort of context.
+
+Hopefully, something in that bundle of phrasings made at least a little bit of sense--- what exactly is meant by "context" is the key to this whole endeavor, but I'm going to avoid addressing it directly until we're a little further along. For now, let's consider `return`.
+
+If `t` is the generic context, then `return` is the function that makes it specific or "specializes" it to the type `'a` of some particular value `x : 'a`. This function takes an object[^object] of the base type `'a` and puts it into the context of `t`. The specialized context of the resulting `'a t` value will be in some sense basic, empty, default, null; it is the starting-point context that exists just to have `x` in it, so that computations involving `x` can take place in that sort of context later on.
+
+```ocaml
+module ListMonad = struct
+  type 'a t = 'a list
+  let return : 'a -> 'a t = fun x -> [x]
+  . . .
+end
+```
+
+Since `t` here is `list`, `return` is the function that takes an argument and sticks it into a list, i.e. `fun x -> [x]`. As you might guess, `list` forms a monad when equipped with suitable definitions of `return` and `bind` (the latter of which is omitted for now). The meaning of `list` as a monad--- that is, the context that `list` and its natural accompanying definitions of `bind` and `return` represent--- is interesting, broadly useful, and sufficiently non-obvious as to demand some intuition, so I'll use it as a running example.
+
+In its most natural interpretation, `list` represents--- or simulates[^physical]--- the property of [nondeterminism](https://en.wikipedia.org/wiki/Nondeterministic_Turing_machine), which is characteristic of a computational model in which all possible paths are taken _simultaneously_. A value of type `'a list` thus represents all possible results of a particular computation of type `'a`, with each result being a list element. Considered in this light, `[x]` is a value where only one path is taken, i.e. where no branches in execution are encountered. Examining the code above, notice how the implementation of `return` inherently gives rise to the "no branches" notion of the empty context, which is embedded in it by definition. That notion, that the null context means there are no branches, is specific to nondeterminism, and `return` is what encodes it into the formal structure of the `ListMonad` module.
+
+Finally, we move on to `bind`. `bind` is the driving force of monads; it performs the heavy lifting that makes them a useful tool for structuring algorithms. An implementation of `bind` is what captures the meaning of a particular sort of context and contextual data by encoding it into a `Monad` instance. Thus, it is `bind` _abstractly_, as it appears in the definition of the `Monad` signature, that captures what is meant by "context" in general. A context should thusly be thought of as some computation that is driven by--- and gives additional structure to--- the underlying computation in `'a`. In other words, every time a program manipulates an `'a t`, some additional, implicit computation is carried out alongside, or possibly modifying, that direct interaction with the context or data therein. This implicit computation is embedded in the implementation of `bind`, and, thus, it is the `bind` function for a type constructor that fundamentally determines what is the context in question, what that context _means_ informally, and how it behaves.
+
+```ocaml
+module ListMonad = struct
+  type 'a t = 'a list
+  let return x = [x]
+  let rec bind (f : 'a -> 'b list) (xs : 'a list) : 'b list =
+    match xs with
+    | [] -> []
+    | x :: xs' -> f x @ bind f xs'
+end
+```
+
+Above is the completed definition of `ListMonad`, including `bind`. A good way to think about what any implementation of bind is doing at a high level is that it
+
+1. extracts the value of the underlying type `'a` from `xs`,
+1. transforms it _via_ `f`, producing some `'b` value with its own associated context, and
+1. uses that new context, along with the original context of `xs`, to determine the final context of the returned `'b t`.
+
+The "value of the underlying type" may be literally a single value of type `'a`, but it needn't be. In `ListMonad.bind`, above, we are actually extracting a whole list's worth of alphas, applying `f` to them as we recurse over the list structure--- these constitute the "underlying value" of the `'a list` `xs`. To understand how this plays out concretely, let's walk through the definition `ListMonad.bind`.
+
+If `xs` is empty, `bind` returns the empty list; this is the usual base case for recursion on lists. If `xs` is not empty, we have an inductive case; it is safe to
+
+1. take the first element `x` and the remaining elements `xs'`,
+1. apply `f` to `x` to obtain a new `'b list`,
+1. append the result of `f x` to the recursive call `bind f xs'`.
+
+We know that the `bind` function returns a `'b list`, so we're appending the `'b list` `f x` to  the `'b list` `bind f xs'`, thus obtaining a new `'b list` that we return the caller.
+
+Pay careful attention to the parallels here with the high-level steps outlined previously. It may seem at first that we don't use the original context, but we do! We recurse over the context, i.e. the list structure of the `'a list` `xs`; it determines the call graph of `bind` and is integral to the final result of the function.
+
+```ocaml
+let sqrt (x : float) =
+  if x < 0 then invalid_arg "negatives have no sqrt" else
+  if x = 0 then [0] else
+  let pos_root = Float.sqrt x in [pos_root; ~-.pos_root]
+
+let various_floats = [1.0; 4.0; 9.0]
+
+let together : float ListMonad.t = ListMonad.bind sqrt various_floats
+```
+
+Here's an example of the monad in action. `together` is `[1.0; -1.0] @ [2.0; -2.0] @ [3.0; -3.0]`, which of course is `[1.0; -1.0; 2.0' -2.0; 3.0; -3.0]`. In this case, we used the taking-all-branches nature of the list monad to compute all the square roots of the numbers in the provided list. If taking the square-root is considered to be an ambiguous operation[^i-know], then *yada yada*. This monad is often used to run operations that have some ambiguous result, to capture the idea that multiple possible return values are valid, e.g. "the square root of four" can be considered ambiguous, since both 2^2^ and (-2)^2^ are 4. Another example of this can be found in parsing with ambiguous grammars. Parser combinator libraries often make it easy to define ambiguous-on-the-face parsers and resolve the ambiguity through some convention, but perhaps 
+
+looks like multiple return with only one in the chain, but the sequencing is what gives us nondeterminism; multiple return doesn't chain the same. To do this without a monad we'd need to do
+
+```ocaml
+bad shit
+```
+
+The list monad allows us to write non-deterministic code in much the same style as we would write fundamentally simpler deterministic code, albeit with substantial boilerplate. We can reduce this boilerplate by making use of OCaml's `let*` [binding operators](https://ocaml.org/manual/5.3/bindingops.html#ss:letops-rationale)[^haskocaml].
+
+```ocaml
+insert code using binding operators
+```
+
+***
+
+[^physical]: Of course, we say that `list` _simulates_ nondeterminism for the same reason that we say physical computers simulate Turing machines: both are constrained by the resource limitations of physical reality and thus less capable than the theoretical devices they seem to emulate.
+
+[^alpha]: Pronounced "alpha tee".
+
+[^object]: "Object" in the general sense; nothing to do with object-orientation or kin.
+
+TODO: be explicit about how monads exist independently and we are _capturing_ them in the particular language of ocaml. `list` forms a monad whether we actually implement that monad, or not
+
+[^action-std]: This gives rise to a standard term. See [Monads as Computations](https://wiki.haskell.org/Monads_as_computation).
+
+[^not-quite]: These are not exactly the same, but the similarity is more important than the difference.
+
+[^haskocaml]: Haskell and Lean lack binding operators and instead use [Typeclasses](https://www.haskell.org/tutorial/classes.html) and an infix operator `>>=` for this boilerplate reduction. OCaml, in turn, lacks typeclasses (or the more likely equivalent feature, [modular implicits](https://www.cl.cam.ac.uk/~jdy22/papers/modular-implicits.pdf)).
+
+[^i-know]: Whether taking the square root of a number _is_ considered to be ambiguous tends to be regional. In some regions, only to the positive root is referred to, by convention.

acl.cool/site/index.html

@@ -0,0 +1,5 @@
+<h1><a href="/resume.pdf" style="text-decoration: none; color: var(--darkest-color)">acl</a>.cool</h1>
+
+<div id="writings" style="color: var(--lighter-color); line-height: var(--ui-spacing);"></span>
+
+<p><strong>Welcome! Below are links to things I've made or just enjoy.</strong></p>

acl.cool/site/resume.typ.txt

@@ -0,0 +1,112 @@
+#let fontsize = 10.2pt
+#let typeface_text = "Fira Sans"
+#let typeface_math = "STIX Two Math"
+
+#set text(font: typeface_text, size: fontsize)
+#show math.equation: set text(font: typeface_math, size: fontsize)
+
+#let inlineFrac(a, b) = [$#super([#a]) #h(-1pt) slash #h(-1pt) #sub([#b])$]
+
+#set smartquote(enabled: false)
+
+#show heading: q => {
+  if q.depth != 1 {
+    v(fontsize / 5)
+  }
+  text(q, weight: "bold")
+  if q.depth == 2 {
+    v(-0.7em)
+    line(length: 100%, stroke: (thickness: 0.7pt))
+    v(0.5em)
+  }
+}
+
+#let head = {
+  align(center)[
+    = Alexander Lucas
+    #set text(font: "Fira Code")
+    #text([alexander.clay.lucas\@gmail.com], size: fontsize * 0.9)
+    #linebreak()
+    #text([(+1) 347-644-9265], size: fontsize * 0.8)
+  ]
+}
+
+#set page(margin: (x: 0.9in, y: 0.35in))
+
+#head
+
+== Summary
+I am a computer science enthusiast with an inclination for harnessing computer science
+theory to tackle practical challenges as cleanly as possible. I believe strongly in the
+importance of codebase health and quality, maintaining those values over time as programs and projects evolve.
+
+== Skills
+#let skills = [
+  *Languages*: Javascript/Typescript, Java, Python, Rust, Haskell, OCaml, F\#, Ruby, C\#, C, C++, Lean 4, HTML/CSS, LaTeX, Typst
+  #linebreak()
+  *Platforms*: Ten years using GNU/Linux including Debian and Redhat, QEMU, Google Cloud
+  #linebreak()
+  *Technologies*: Buildroot, WebGL, Numpy/Pytorch/Sklearn, Matplotlib, Git, Gitlab/Github, PostgreSQL, Node, Slurm
+  #linebreak()
+  *Soft Skills*: Technical Writing, Software Documentation, Presentation
+]
+
+#skills
+
+#let interline() = {
+  box(width: 1fr, inset: fontsize / 4, line(length: 100%, stroke: (thickness: fontsize / 10, dash: "loosely-dotted")))
+}
+
+== Experience
+#let experience = [
+  *Embedded Software Engineer, Jr.* #interline() #text(weight: "semibold")[Trusted Microelectronics, KBR, 01/2025-05/2025 (End of Funds)]
+  - Continuing to work with the same great team, tools and software as during my internship.
+  - Developing QEMU virtual hardware devices for building/testing platform-specific applications.
+
+  *Linux Driver Development Intern* #interline() #text(weight: "semibold")[Trusted Microelectronics, KBR, 05/2024-08/2024]
+  - Learned Linux kernel subsystems and developed device drivers for custom "system on a chip" hardware, including GPIO/pin controllers and an AES encryption accelerator module.
+  - Worked with team members to develop testing and assurance methodologies including coverage profiling and input fuzzing for Linux drivers while porting Linux to our boards.
+  - Automated common tasks, writing scripts to handle OS installations and code restructuring.
+  - Presented project status and details to large, cross-functional and interdisciplinary groups.
+
+  *Teaching Assistant* #interline() #text(weight: "semibold")[James Madison University, 08/2022-12/2023]
+  - Took questions and led review sessions in proofs, programming, tooling, debugging code.
+  - Maintained a calm and encouraging environment while helping students with difficult problem sets against a deadline.
+]
+
+#experience
+
+== Education
+#let degrees = [
+  *B.S. Computer Science* (3.8 GPA) #interline() #text(weight: "semibold")[James Madison University, 12/2023]
+]
+#degrees
+#let courses = [
+  - Programming Languages, Compiler Construction
+  - Independent Study in Constructive Logic, Symbolic Logic
+  - Applied Algorithms, Data Structures
+  - Parallel and Distributed Systems, 3D Graphics
+]
+#courses
+*Study Abroad, London, UK* #interline() #text(weight: "semibold")[JMU at Florida State Study Center, Summer 2023]
+#let cw = [
+  - Rigidity Theory
+  - Independent Study in Computational Geometry
+]
+#cw
+
+*Academic Awards*
+#let awards = [
+  - "President's List" #interline() #text(weight: "semibold")[JMU, 2023]
+  - "Alonzo Church Award for Theory" #interline() #text(weight: "semibold")[JMU CS Department, 2024]
+]
+#awards
+
+== Personal Projects
+#let projects = [
+  *Aasam* (on #underline([#link("https://hackage.haskell.org/package/aasam")[Hackage]])) is a Haskell implementation of the CFG-generation algorithm $#math.cal([M])$ from Annika Aasa's paper "Precedences in specifications and implementations of programming languages".
+  #linebreak()
+  *Randall* (on #underline([#link("https://gitlab.com/mobotsar/randall")[Gitlab]])) is a Discord bot for executing dice-notation, making it easy to play TTRPGs remotely. It uses a recursive descent parser and tree-walk interpreter on the backend and the .NET Discord library up front.
+]
+
+#projects

acl.cool/site/writings/amaretti.dj

@@ -0,0 +1,42 @@
+# Amaretti (Chewy Almond Cookies)
+
+These are genuinely excellent and surprisingly undemanding to make, particularly if you don't beat the egg whites by hand. From start to finish, the process should take less than an hour.
+
+Keep in mind that the ideal crispy-outside chewy-inside texture forms over time while the cookies are cool. They _taste_ right immediately after coming out of the oven, but for the best texture, let them cool completely and rest in a sealed container for several hours before consuming.
+
+Total caloric content of this recipe is 2840 kilocalories, or 109.6 kcal per cookie for twenty-five cookies.
+
+## Ingredients
+
+- 1/2 cup white granulated sugar
+- 1/2 cup demerara sugar (Florida Crystals or similar)
+- 280 grams blanched almond flour
+- 1/2 teaspoon kosher salt
+- 3 extra large eggs
+- 1/2 teaspoon vanilla extract
+- 1 ounce (weight) Lazzaroni Amaretto
+- 1 cup powdered sugar
+- 25 whole, roasted almonds
+
+## Equipment
+
+- A medium mixing bowl (for dry ingredients)
+- A small mixing bowl (for beating egg whites)
+- A whisk or mixer
+- A standard set of measuring spoons
+- A kitchen scale
+- A medium cookie sheet
+- A silicone sheet-pan liner
+
+## Process
+
+1. Preheat the oven to 325°F.
+2. Mix the flour and sugars into a medium bowl.
+3. Separate three egg whites into another bowl and discard the yolks.
+4. Beat the egg whites until peaks are stiff.
+5. Add the vanilla extract and amaretto to the bowl of dry ingredients.
+6. Add the beaten egg whites to the dries and fold gently until a paste forms.
+7. Form small balls of the dough and coat them completely in powdered sugar.
+8. Gently press the dough balls onto a sheet-pan with a silicone mat, flattening them slightly.
+9. Press an almond into the top of each cookie so that the dough will hold it when baked.
+10. Place the pan (with cookies) in the oven for 25 minutes then remove it and let them cool.

acl.cool/site/writings/chili.dj

@@ -0,0 +1,29 @@
+# Unassailable Slow-Cooker Chili
+
+This is a simple recipe of beans, tomato, and ground beef, refined across generations into the local maximum you see before you.
+
+## Ingredients
+
+- A bit more than 1 lb of ground beef
+- 2 14.5 oz cans of diced tomatoes
+- 2 1.25 oz packets of chili powder spice mix (such as McCormick, etc)
+- 4 cans of beans (typically one each of pinto, black, great-northern, and light kidney)
+- 1 large bottle of tomato juice
+- 1 medium or large onion
+- Black pepper to taste
+
+## Equipment
+
+- A knife to cut the onion
+- A skillet to cook the beef
+- A large slow-cooker
+- A heat-resistant spoon
+
+## Process
+
+1. Cook the ground beef until most of the fat has rendered, then drain most of the grease away.
+2. Chop onion and add to skillet with beef, cooking just until color develops.
+3. Add the beef and onion to the pot with tomatoes, beans, and spice mix.
+5. Pour in tomato juice until it reaches a consistency too thick for soup but still more suitable for consumption with a spoon than with any other dining implement.
+4. Cook on low until you're happy with the texture of your onions, as these usually take the longest.
+5. Black pepper to taste shortly before serving.

acl.cool/site/writings/coronation-chicken.dj

@@ -0,0 +1,45 @@
+# Typical Coronation Chicken
+
+This recipe is adapted from the original recipe used for Queen Elizabeth's “Coronation Luncheon” in 1953 and faithfully incorporates elements of several variations served around London in 2023. Most of the changes I've made are to ratios, but I've also included more fruits, omitted watercress, and used a mayonnaise/milk combination in place of whipping cream.
+
+## Ingredients
+
+- 3 tbsp almond slivers
+- 1/2 shallot
+- 1 tbsp dried apricots
+- 1 tbsp lemon juice (roughly 1/4 of a smooth lemon)
+- 1 tbsp extra-virgin olive oil
+- 3 tsp your favorite yellow curry powder
+- 1 tsp tomato paste
+- 90 ml dry red wine
+- 30 ml water
+- 1/4 tsp dark brown sugar
+- 225 ml Duke's mayonnaise \*
+- 100 ml 2% milk \*
+- 4 tsp thompson raisins \*
+- 1 tsp dried black currants \*
+- 650 g shredded cooked chicken breast *
+
+Values marked with \* have been estimated after-the-fact. I made visual judgments during preparation to decide actual amounts and neglected to record them. The combined volume of mayonnaise and milk was measured at 325 ml. The chicken was measured at 500 g, but was too little for the amount of dressing made.
+
+## Equipment
+
+- A wide skillet or frypan
+- A knife and cutting surfaces
+- A standard set of measuring spoons
+- Two medium mixing bowls
+
+## Process
+
+1. Toast the almonds in your pan before setting them aside.
+2. Chop the half shallot and apricots very finely.
+3. Squeeze 1 tbsp of lemon juice and set it aside.
+4. Add olive oil to the pan and place it on medium heat.
+5. Add the shallot and curry powder then cook about two minutes or until the shallot begins to soften.
+6. Add tomato paste, wine, and water, then bring the pan to a mild boil.
+7. Once it boils, add lemon juice and brown sugar then simmer until the mixture is slightly reduced.
+8. Remove from heat and let cool substantially.
+9. Transfer to a bowl and mix in mayonnaise, milk, almonds, and all the fruit to complete the dressing.
+10. Place shredded chicken in another bowl and add dressing until the desired consistency is reached.
+11. Sample the mixture before adding salt and pepper to taste.
+12. Let rest in the refrigerator until completely cooled.

acl.cool/site/writings/culture-order.dj

@@ -0,0 +1,17 @@
+# Reading Order of The Culture
+
+I've generated a reading order dependency graph for books in Iain M. Banks' monumental _Culture_ series. The idea is that if there's an arrow from book A to book B, then to get the most possible enjoyment from either A or B, A should be read before B.
+
+![A dependency graph diagram of what Culture books must eb read before what others.](/culture.dot.png) Above is the graph, and [right here](/culture.dot.txt) is the vizgraph description file that lists my rationale for each dependency.
+
+- _Consider Phlebas_ before _Look to Windward_--- both are about the Idiran War, and _Consider Phlebas_ is first.
+- _Use of Weapons_ before _The State of the Art_--- these share a main character in Diziet Sma. SotA was actually released before UoW but in my opinion is more satisfying if read after it.
+- _Use of Weapons_ before _Inversions_--- UoW gives the best idea of any book about what Special Circumstances is, which must be understood to fully appreciate _Inversions_ in all its subtlety.
+- _Excession_ before _The Hydrogen Sonata_--- _Hydrogen Sonata_ is dual to _Excession_ in many ways that can't be explained here without abject spoilage. This one is not a hard rule, but HS is better if you know _Excession_.
+- _Excession_ before _Matter_--- GSV Sleeper Service is mentioned in _Matter_ as "The granddaddy, the exemplary hero figure, the very God...", referencing events in _Excession_.
+- _Use of Weapons_ before _Surface Detail_--- you must know who Zakalwe is, the main character of UoW, to fully appreciate the ending of _Surface Detail_.
+- _Look to Windward_ before _Surface Detail_--- These books deal with common themes and subjects. Some will disagree with me here, but LtW is more impactful _without_ certain knowledge revealed in _Surface Detail_.
+
+Assuming one agrees with the graph, the set of ideal reading orders (that is, the set such that for all orders it contains, no order exists which is strictly better) is the set of [topological sorts](https://en.wikipedia.org/wiki/Topological_sortinghttps://en.wikipedia.org/wiki/Topological_sorting) of the graph.
+
+This gives the number of possible ideal orders as 63840. That's a lot of good ways to do it!

acl.cool/soupault.toml.frag

@@ -0,0 +1,28 @@
+
+[index]
+index = true
+# sort_descending = true
+# sort_type = "calendar"
+# date_formats = ["%F"]
+# strict_sort = true
+
+[index.fields]
+
+[index.fields.title]
+selector = ["h1"]
+
+# [index.fields.date]
+# selector = ["time"]
+# extract_attribute = "datetime"
+# fallback_to_content = true
+
+[index.fields.abstract]
+selector = ["p"]
+
+[index.views.writings-index]
+index_selector = "#writings"
+section = "writings"
+index_item_template = """
+    <p><a href="{{url}}">{{title}}</a>
+    <br>{{abstract}}</p>
+  """

acl.cool/templates/main.html

@@ -0,0 +1 @@
+../../shared_templates/main.html

build.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+
+./deps.sh
+
+find acl.cool/serve/ ytheleus.org/serve/ -type f -mmin +11 -delete
+
+function soup_config {
+    rm soupault.toml
+    cp ../soupault.toml soupault.toml
+    cat soupault.toml.frag* >> soupault.toml
+}
+
+source ./pgvv/bin/activate
+
+find acl.cool/site/ ytheleus.org/site/ -type f \( -name '*.dj' -o -name '*.html' \) -exec cat {} + > all_chars.txt
+cat common_chars.txt >> all_chars.txt
+
+for font in fonts/JuliaMono/*{-Light,-Regular,-SemiBold}{,Italic}.woff2; do
+    echo "Subsetting $font"
+    pyftsubset "$font" --flavor=woff2 --text-file=all_chars.txt --layout-features='*' \
+        --output-file="$(awk -F '.woff2' '{print $1}' <<< "$font")-Subset.woff2"
+done
+
+#for font in fonts/Alegreya/static/Alegreya-{Regular,Italic,Bold,BoldItalic}.ttf; do
+#    echo "Subsetting $font"
+#    pyftsubset "$font" --text-file=all_chars.txt --layout-features='*' \
+#        --output-file="$(awk -F '.ttf' '{print $1}' <<< "$font")-Subset.ttf"
+#done
+#
+#for font in fonts/Alegreya_Sans/AlegreyaSans-{Regular,Italic,Bold,BoldItalic}.ttf; do
+#    echo "Subsetting $font"
+#    pyftsubset "$font" --text-file=all_chars.txt --layout-features='*' \
+#        --output-file="$(awk -F '.ttf' '{print $1}' <<< "$font")-Subset.ttf"
+#done
+
+rm css/code.css
+pygmentize -f html -S algol_nu | grep -v 'line-height' > css/code.css
+
+builtin pushd acl.cool
+soup_config
+soupault
+popd
+builtin pushd ytheleus.org
+soup_config
+soupault
+popd
+
+deactivate

common_chars.txt

@@ -0,0 +1,11 @@
+—–-
+
+⁰¹²³⁴⁵⁶⁷⁸⁹ ⁽⁾
+
+↩︎
+
+“”
+
+!"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~
+
+…

css/fonts.css

@@ -0,0 +1,234 @@
+@font-face {
+    font-family: 'Heading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadRegular.woff2') format('woff2');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Heading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadItalic.woff2') format('woff2');
+    font-weight: normal;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Heading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadBold.woff2') format('woff2');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Heading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadBoldItalic.woff2') format('woff2');
+    font-weight: bold;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Subheading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadMedium.woff2') format('woff2');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Subheading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadMediumItalic.woff2') format('woff2');
+    font-weight: normal;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Subheading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadSemibold.woff2') format('woff2');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Subheading';
+    src: url('../assets/fonts/LiterataTT/LiterataTT-SubheadSemiboldItalic.woff2') format('woff2');
+    font-weight: bold;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'BodySerif';
+    src: url('../assets/fonts/Alegreya/static/Alegreya-Regular.ttf') format('truetype');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'BodySerif';
+    src: url('../assets/fonts/Alegreya/static/Alegreya-Italic.ttf') format('truetype');
+    font-weight: normal;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'BodySerif';
+    src: url('../assets/fonts/Alegreya/static/Alegreya-Bold.ttf') format('truetype');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'BodySerif';
+    src: url('../assets/fonts/Alegreya/static/Alegreya-BoldItalic.ttf') format('truetype');
+    font-weight: bold;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'BodySans';
+    src: url('../assets/fonts/Alegreya_Sans/AlegreyaSans-Regular.ttf') format('truetype');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'BodySans';
+    src: url('../assets/fonts/Alegreya_Sans/AlegreyaSans-Italic.ttf') format('truetype');
+    font-weight: normal;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'BodySans';
+    src: url('../assets/fonts/Alegreya_Sans/AlegreyaSans-Bold.ttf') format('truetype');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'BodySans';
+    src: url('../assets/fonts/Alegreya_Sans/AlegreyaSans-BoldItalic.ttf') format('truetype');
+    font-weight: bold;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-Light.woff2') format('woff2');
+    font-weight: 300;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-LightItalic-Subset.woff2') format('woff2');
+    font-weight: 300;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-Regular-Subset.woff2') format('woff2');
+    font-weight: normal;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-RegularItalic-Subset.woff2') format('woff2');
+    font-weight: normal;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-SemiBold-Subset.woff2') format('woff2');
+    font-weight: bold;
+    font-style: normal;
+}
+
+@font-face {
+    font-family: 'Mono';
+    src: url('../assets/fonts/JuliaMono/JuliaMono-SemiBoldItalic-Subset.woff2') format('woff2');
+    font-weight: bold;
+    font-style: italic;
+}
+
+@font-face {
+    font-family: "Quote";
+    src: url('../assets/fonts/Alegreya_Sans/AlegreyaSans-Italic.ttf') format('woff2');
+}
+
+@font-face {
+    font-family: 'Math';
+    src: url('../assets/fonts/STIXTwo/STIXTwoMath-Regular.woff2') format('woff2');
+}
+
+:root {
+    --base-font-size: 16pt;
+}
+
+/* Setting the line height here apparently stops "normal" from varying
+   across the course of <body>. */
+body {
+    font-size: var(--base-font-size);
+    line-height: var(--read-spacing);
+    font-display: swap;
+}
+
+.font-hidpi body {
+    font-family: "BodySerif", sans-serif;
+}
+
+.font-lodpi body {
+    font-family: "BodySans", serif;
+}
+
+h1 {
+    font-family: "Heading";
+    font-style: italic;
+    line-height: normal;
+}
+
+h2,
+h3,
+h4,
+h5,
+h6 {
+    font-family: "Subheading";
+    font-style: italic;
+    font-weight: normal;
+    line-height: var(--ui-spacing);
+}
+
+:root {
+    --head-mult: 0.88; /* This is pairwise fixed, JuliaMono + Alegreya. */
+}
+
+h1 {
+    margin-block: 0.67em;
+    font-size: calc(2.3 * var(--base-font-size) * var(--head-mult));
+}
+
+h2 {
+    font-size: calc(1.8 * var(--base-font-size) * var(--head-mult));
+}
+
+h3 {
+    font-size: calc(1.6 * var(--base-font-size) * var(--head-mult));
+}
+
+h4 {
+    font-size: calc(1.4 * var(--base-font-size) * var(--head-mult));
+}
+
+h5 {
+    font-size: calc(1.2 * var(--base-font-size) * var(--head-mult));
+}
+
+h6 {
+    font-size: calc(1.0 * var(--base-font-size * var(--head-mult)))
+}
+
+code, pre code {
+    font-family: "Mono";
+    font-size: calc(0.84 * var(--base-font-size));
+}

css/index.css

@@ -0,0 +1,7 @@
+@import url(fonts.css);
+
+@import url(looks.css);
+
+@import url(layout.css);
+
+@import url(code.css);

css/layout.css

@@ -0,0 +1,6 @@
+.container {
+    max-width: 900px;
+    margin-left: auto;
+    margin-right: auto;
+    overflow: auto;
+}

css/looks.css

@@ -0,0 +1,175 @@
+:root {
+  --darkest-color: rgb(10, 5, 0);
+  --middle-color: rgb(60, 55, 50);
+  --lighter-color: rgb(95, 85, 80);
+  --ui-spacing: 1.25;
+  --read-spacing: 1.5;
+  --wide-gray: rgb(245, 240, 240);
+  --narrow-gray: rgb(240, 233, 233);
+}
+
+code {
+  font-variant-ligatures: no-contextual;
+}
+
+code:not(pre code) {
+  background-color: var(--wide-gray);
+  padding-left: 3px;
+  padding-right: 3px;
+  padding-top: 1px;
+  padding-bottom: 1px;
+  color: black;
+  border-radius: 3px;
+  line-height: var(--ui-spacing);
+  /* This prevents inline code from wrapping, c.f. Typst's `box`. */
+  display: inline-block;
+  /* These are needed if we allow code to line break. */
+  box-decoration-break: clone;
+  -webkit-box-decoration-break: clone;
+}
+
+pre {
+  color: black;
+  background-color: var(--wide-gray);
+  overflow-x: auto;
+  border-style: solid;
+  border-radius: 3px;
+  border-width: 2px;
+  border-color: var(--wide-gray);
+  padding-left: 0.35em;
+  padding-top: 0.1em;
+  padding-bottom: 0.2em;
+  line-height: normal;
+}
+
+body {
+  background-color: rgb(255, 255, 255);
+  color: var(--middle-color);
+}
+
+h1 {
+  color: var(--darkest-color);
+  margin-bottom: 0.05em;
+  margin-top: 1em;
+}
+
+h2,
+h3,
+h4,
+h5,
+h6 {
+  color: var(--middle-color);
+  margin-bottom: 0;
+  margin-top: 1em;
+}
+
+h1+*,
+h2+*,
+h3+*,
+h4+*,
+h5+*,
+h6+* {
+  margin-top: 0;
+  padding-top: calc(var(--base-font-size) * (2/3));
+}
+
+blockquote {
+  font-size: 1em;
+  line-height: var(--ui-spacing);
+  border-left: 4px solid var(--darkest-color);
+  padding-left: 0.45em;
+  margin: 0;
+}
+
+blockquote:has(p + p) {
+  text-indent: 1em;
+}
+
+a:link,
+a:visited {
+  color: var(--darkest-color)
+}
+
+[role="doc-noteref"] {
+  text-decoration: none;
+  font-family: "BodySans";
+}
+
+[role="doc-noteref"] sup {
+  font-size: 0.7em;
+  font-style: normal;
+}
+
+[role="doc-noteref"] sup::before {
+  content: "(";
+  padding-left: 0.075em;
+}
+
+[role="doc-noteref"] sup::after {
+  content: ")";
+}
+
+[role="doc-backlink"] {
+  margin-left: 0.25em;
+  text-decoration: none;
+}
+
+img {
+  width: 100%;
+  height: auto;
+}
+
+table {
+  --padding-px-h: 0.35em;
+  --padding-px-v: 0;
+  border-collapse: separate;
+  border-spacing: 0;
+  overflow-x: auto;
+}
+
+table tr th,
+table tr td {
+  border-right: 2px solid var(--narrow-gray);
+  border-bottom: 2px solid var(--narrow-gray);
+  padding-right: var(--padding-px-h);
+  padding-left: var(--padding-px-h);
+  padding-top: var(--padding-px-v);
+  padding-bottom: var(--padding-px-v);
+}
+
+table tr th:first-child,
+table tr td:first-child {
+  border-left: 2px solid var(--narrow-gray);
+}
+
+/* top row a.k.a. table header */
+table tr th {
+  border-top: 2px solid var(--narrow-gray);
+  text-align: left;
+}
+
+/* top-left border-radius */
+table tr:first-child th:first-child {
+  border-top-left-radius: 3px;
+}
+
+/* top-right border-radius */
+table tr:first-child th:last-child {
+  border-top-right-radius: 3px;
+}
+
+/* bottom-left border-radius */
+table tr:last-child td:first-child {
+  border-bottom-left-radius: 3px;
+}
+
+/* bottom-right border-radius */
+table tr:last-child td:last-child {
+  border-bottom-right-radius: 3px;
+}
+
+hr {
+  height: 2px;
+  border: none;
+  background-color: var(--narrow-gray);
+}

deps.sh

@@ -0,0 +1,27 @@
+#!/bin/sh
+
+if ! [[ -d pgvv/ ]]; then
+	python3 -m venv pgvv
+	source ./pgvv/bin/activate
+	python3 -m pip install --upgrade pip
+	pip install --upgrade pygments
+	pip install --upgrade fonttools
+	pip install --upgrade brotli
+	deactivate
+fi
+
+which opam 2> /dev/null
+if [[ $? == 0 ]]; then
+	opam install -y soupault
+else
+	echo 'failed to install soupault with opam' >&2
+	exit 2
+fi
+
+which cargo 2> /dev/null
+if [[ $? == 0 ]]; then
+	cargo install jotdown
+else
+	echo 'failed to install jotdown with cargo'
+	exit 3
+fi

fonts/Alegreya/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2011 The Alegreya Project Authors (https://github.com/huertatipografica/Alegreya)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.


fonts/Alegreya/README.txt

@@ -0,0 +1,75 @@
+Alegreya Variable Font
+======================
+
+This download contains Alegreya as both variable fonts and static fonts.
+
+Alegreya is a variable font with this axis:
+  wght
+
+This means all the styles are contained in these files:
+  Alegreya-VariableFont_wght.ttf
+  Alegreya-Italic-VariableFont_wght.ttf
+
+If your app fully supports variable fonts, you can now pick intermediate styles
+that aren’t available as static fonts. Not all apps support variable fonts, and
+in those cases you can use the static font files for Alegreya:
+  static/Alegreya-Regular.ttf
+  static/Alegreya-Medium.ttf
+  static/Alegreya-SemiBold.ttf
+  static/Alegreya-Bold.ttf
+  static/Alegreya-ExtraBold.ttf
+  static/Alegreya-Black.ttf
+  static/Alegreya-Italic.ttf
+  static/Alegreya-MediumItalic.ttf
+  static/Alegreya-SemiBoldItalic.ttf
+  static/Alegreya-BoldItalic.ttf
+  static/Alegreya-ExtraBoldItalic.ttf
+  static/Alegreya-BlackItalic.ttf
+
+Get started
+-----------
+
+1. Install the font files you want to use
+
+2. Use your app's font picker to view the font family and all the
+available styles
+
+Learn more about variable fonts
+-------------------------------
+
+  https://developers.google.com/web/fundamentals/design-and-ux/typography/variable-fonts
+  https://variablefonts.typenetwork.com
+  https://medium.com/variable-fonts
+
+In desktop apps
+
+  https://theblog.adobe.com/can-variable-fonts-illustrator-cc
+  https://helpx.adobe.com/nz/photoshop/using/fonts.html#variable_fonts
+
+Online
+
+  https://developers.google.com/fonts/docs/getting_started
+  https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_Fonts/Variable_Fonts_Guide
+  https://developer.microsoft.com/en-us/microsoft-edge/testdrive/demos/variable-fonts
+
+Installing fonts
+
+  MacOS: https://support.apple.com/en-us/HT201749
+  Linux: https://www.google.com/search?q=how+to+install+a+font+on+gnu%2Blinux
+  Windows: https://support.microsoft.com/en-us/help/314960/how-to-install-or-remove-a-font-in-windows
+
+Android Apps
+
+  https://developers.google.com/fonts/docs/android
+  https://developer.android.com/guide/topics/ui/look-and-feel/downloadable-fonts
+
+License
+-------
+Please read the full license text (OFL.txt) to understand the permissions,
+restrictions and requirements for usage, redistribution, and modification.
+
+You can use them in your products & projects – print or digital,
+commercial or otherwise.
+
+This isn't legal advice, please consider consulting a lawyer and see the full
+license for all details.

fonts/Alegreya_Sans/OFL.txt

@@ -0,0 +1,93 @@
+Copyright 2013 The Alegreya Sans Project Authors (https://github.com/huertatipografica/Alegreya-Sans)
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+https://openfontlicense.org
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

fonts/CommitMonoUnfancyDevNV143/.uuid

@@ -0,0 +1 @@
+b481aac1-ef8d-48d0-8d6b-b109c992addd

fonts/CommitMonoUnfancyDevNV143/custom-settings.json

@@ -0,0 +1 @@
+{"weight":350,"italic":false,"alternates":{"cv01":false,"cv02":false,"cv03":false,"cv04":false,"cv05":false,"cv06":true,"cv07":false,"cv08":true,"cv09":false,"cv10":false,"cv11":false},"features":{"ss01":false,"ss02":false,"ss03":false,"ss04":true,"ss05":true},"letterSpacing":0,"lineHeight":1,"fontName":"UnfancyDevN"}

fonts/CommitMonoUnfancyDevNV143/installation.txt

@@ -0,0 +1,11 @@
+A short guide for how to install and enable your shiny new version of Commit Mono.
+This is taken from section 08 Install from https://commitmono.com/
+
+#1 (Download the fonts)
+#2 Unzip the fonts. You'll see 4 font files. These 4 fonts make up a 'Style Group':
+    * CommitMono-Regular: Base version with settings and weight of your choice.
+    * CommitMono-Italic: An italic version, same weight as regular.
+    * CommitMono-Bold: A bold version, weight 700.
+    * CommitMono-BoldItalic: A bold version, weight 700, that is also italic.
+#3 Install all 4 fonts on your system:
+    * Windows: Right click the font in the folder and click "Instal

fonts/CommitMonoUnfancyDevNV143/license.txt

@@ -0,0 +1,37 @@
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the compon