If you want an example, I wrote a blog post about this a few years ago: https://www.falsifian.org/blog/2021/06/04/catalytic/

Alternatively, Ian Mertz's survey might be a bit more accessible than the original catalytic paper: https://iuuk.mff.cuni.cz/~iwmertz/papers/m23.reusing_space.p...

Yes, I'm using it with notmuch, and it works reasonably well. A couple of caveats: - If you want to save outgoing mail, you need to include your own mail-sending script (mine is below). This is because aerc treats the notmuch backend as read-only. - For the same reason, you can't postpone messages with the notmuch backend. - I find it a little annoying jumping between search queries. Basically, I have to type out the new query each time. The aerc notmuch backend treats notmuch queries like folders, but it instantly forgets the previous "folder" existed when you go to a new one. It probably wouldn't be too hard to fix these; if I stick with aerc I'll probably try eventually.

My mail-sending script; tested only on OpenBSD:

  #!/bin/sh
  #
  # Save a copy of an email in Sent, then send it with sendmail.
  set -e
  
  TMP=$(mktemp -d)
  cat > "$TMP/message"
  notmuch insert --folder=Sent < "$TMP/message"
  sendmail -f falsifian@falsifian.org "$@" < "$TMP/message"
  rm -r -- "$TMP"

Sorry! It is because I was too lazy to figure anything else out.

To be honest I usually used my browser's zoom functionality to make it bigger while debugging, and you can too. Changing the aspect ratio would require some code changes, though.

Yes. (This has to be the case because I'm drawing everything with triangles in WebGL.)

That is one of my fantasies, if I had enough time. Apply different rules to different regions of space.

I am grateful for the idris2-dom library by Stefan Höck: https://github.com/stefan-hoeck/idris2-dom/ . It covered most of the web APIs I used.

I'm using the WebGL API pretty directly, though. So if it were missing I could have hacked it with some foreign function calls, but it would have been a lot more effort.

Thanks!

There is a little bit of CSS. And I would have gone for no javascript, but unfortunately in this case that's the whole point.

This demo is actually fairly close to showing you a hypercube.

The six rooms in the house form six cells of the hypercube. You can make one more cube by joining up the tops of the walls: that cell is always above you. And finally, there would be one more cell below you. (To be a bit more precise: the six rooms of the house would have to be extended to be twice as tall. The tops of the walls are at coordinates (+-1, 1, +-1, +-1), but right now the bottoms of the walls are at (+-1, 0, +-1, +-1). You have to remove the floor and make the walls go all the way down to (+-1, -1, +-1, +-1).

You can do this for any 4D polytope. Taking it down a dimension, the layout of the house shows how to put a cube on a 2-sphere. I could have done it for any other 3D polyhedron. Give the sphere and the polyhedron the some centre point, and then project all the lines of the polyhedron onto the sphere. Each face of the polyhedron becomes a 2-D region on the sphere (in the case of the house, each room is a square). Going a dimension up, you can centre the 3-sphere and the polytope on the same point, and do the same kind of projection. Every cell of the polytope turns into one 3-D region of the 3-sphere.

I wish I had had time to include that.

The 4D coordinates are almost treated as ratios. (x,y,z,w) = (tx,ty,tz,tw) when t is positive, but if t is negative it's a different point.

This happens to work with (Open/Web)GL. Here's my understanding of why. Say you tell WebGL to draw a triangle with points at clip space coordinates (i.e. after all the transforming is done) (1,0,0,1), (0,1,0,1), (0,0,0,1). If you multiply all those by a positive number, e.g. (10, 0, 0, 10), (0, 10, 0, 10), (0, 0, 0, 10), you get the same triangle. But if you multiply by a negative number, they will not be drawn at all: (-1, 0, 0, -1), (0, -1, 0, -1), (0, 0, 0, -1) is not drawn. I think this is because of the rules for clipping: only points where -w <= x,y,z <= w survive the clipping step. If w is negative, that's impossible.

Related: my code draws the universe twice on each frame. First I draw things that are more than halfway around the sphere from you, and then I reset the z buffer and draw things that are closer to you. https://git.sr.ht/~falsifian/s3d/tree/main/item/src/S3D/Draw...

Another thing maybe worth mentioning: the magnitudes matter when GL is doing interpolation, which is especially noticeable when there are textures.

That is, if you scale just one of the three points of the triangle, e.g. (1, 0, 0, 1), (0, 1, 0, 1), (0, 0, 0, 1000), then while the triangle will appear in the same place as before, interpolation (e.g. deciding which part of the texture to draw in each pixel of the triangle) changes.

The current version of the demo doesn't have any textures but that's mostly laziness on my part. For a while I gave the rooms "ceilings" which were each a checkerboard-pattern square, which forced me to figure out how to get the interpolation thing right. So I can confirm it can be done. But I dropped the ceilings because they just got in the way.