yosh's blog

JPEG XL for imhex (+ pattern language thoughts)

2026-04-30T17:30:00Z

JPEG XL is the final image format. Or, one of the final formats, that is. It’s not going to subsume raw camera formats or certain specific interchange formats, but that’s alright; it’s enough to encompass most images most computer touchers encounter. I’ve been following the format for at least a few years, and it’s been quite exciting to see its gradual adoption among desktop software. Between screenshots, photos, and archival scans, it’s the dominant form of images on my computer, and one day I hope this is the same for the web.

In tandem, I’ve been trying to focus more on doing things; it helps manage the tedium of life when I contribute to projects or pursue knowledge on my own. Kind of “de-consumptioning” myself a bit—motioning away from the sludge of it all. This leads to me occasionally perusing the things I use to see if there’s anything I can help out with, filing issues or maybe a PR should motivation be tickled enough.

So, I talk to jonny about JXL a bunch. He relays updates on the standard & libjxl from the developers, and we have a good time ruminating its progression. Typical nerd stuff. Around two weeks ago (as of writing), I was looking around the libjxl repo and found this bug that he filed—seemingly an error when a specific flag is switched. Recreating the bug & putting the files in the imhex hex editor to diff them led to an interesting observation: only one bit in the first several bytes changes between the broken image and the correct image.

Interest was piqued, as combining this with the hint someone else commented pointed towards some bug in header encoding or decoding. Searching ‘round the block to see if anyone had made a JXL pattern for imhex turned up with this pull request on the patterns repo. A noble effort for sure, but a couple things with it didn’t work for my case:

It only matches against the box file format standard.
- A “bare” codestream is an equally valid JXL file, so this pattern would fail on those kinds of images.
Corollary: it doesn’t do any fine-grained codestream decoding, which is what the entire bug is about.

I ~could~ have trawled through the libjxl source code with the stacktrace from someone else, but alas, the JXL standard is quite lengthy, and the source code of libjxl is quite sprawled¹. It’d be folly to run through the bits myself or print at every stage of decoding every time a header bug pops up.

Given it all, I thought it’d be much faster, more useful to everyone, and kind of just a fun idea to make my own pattern for JXL. I’ve never made an imhex pattern before (or for that matter, I’ve barely used imhex at all before), so it’d be a simultaneous journey of learning imhex’s DSL and internalizing the JXL standard.

the file!

Cutting to the chase: You can get the pattern at my imhex patterns repo. While I would have wished that I could parse every bit of the format, the entropy coding parts² are just a bit too complex to realistically implement in imhex’s not-that-much-of-a-programming language. As such, there’s a few deficiencies:

Codestreams that have an embedded ICC pattern or a permuted TOC will return early with a warning.
No fine-grained parsing is done of the actual frame groups—they’re just generic byte spans.

Despite those unimplemented paths, it seems to be one of the most complex imhex patterns that exist:

$ wc -l jxl.hexpat
1073 jxl.hexpat
$ wc -l /usr/share/imhex/patterns/* | sort -nr | head
   5594 /usr/share/imhex/patterns/dicom.hexpat
   1312 /usr/share/imhex/patterns/pe.hexpat
   1140 /usr/share/imhex/patterns/3ds.hexpat
   1121 /usr/share/imhex/patterns/java_class.hexpat
    934 /usr/share/imhex/patterns/stdfv4.hexpat
    921 /usr/share/imhex/patterns/dotnet_binaryformatter.hexpat
    835 /usr/share/imhex/patterns/elf.hexpat
    833 /usr/share/imhex/patterns/max_v104.hexpat
    726 /usr/share/imhex/patterns/selinux.hexpat

Subtract about 150 lines from mine due to comments. They’re quite dense lines as well! Most of the lines for the other high rankers are taken up by huge lookup tables or pattern matches, while JXL just has a ton of conditional branching, bitfields, & types inherent to it.

It’s quite snazzy to see it in action:

And yes, in the end, I did end up fixing the bug with the help of this pattern. It was quite easy to see what caused it when I could quickly visualize that it happens on a byte boundary!

sidenote: jxl is crazier than I thought

I knew that JXL was The Future Image Format for a while now, but actually delving into the standard has made me realize just how much is done for the various use cases it wants to exist in.

For example, the codestream performs extensive bit packing techniques to squeeze out mere bytes. Is it storing width and height as 4 bytes each? nah, use 1 bit to determine if it’s a “small” image or not, and if it is, it read 5 bits for the height, then the real height is that multiplied by 8. Then read 3 bits to determine the “ratio”, which is a lookup table of common ratios. If it’s not any of those common ratios, then the width is encoded separately. Otherwise, no more bits are needed.³ The separate encoding isn’t just 4 bytes or whatever either; it uses two bits to multiplex four different other integer widths so that smaller images just use less space overall.⁴

In isolation, these things only shave off like, what, a couple tens of bytes? if you consider the entirety of the codestream’s complexity. But if you’re dealing with hundreds of thousands of low-resolution, standardized images (like, say, for thumbnailing or previewing), those bytes saved add up real fast.

That’s the kind of stuff the codestream does. It’s quite neat.

the pattern language…

Since this was my first imhex pattern, I made sure to scour the entire documentation and all the different avenues I could approach writing it from. While writing, I mentally noted aspects of the language that poked some thorns in my side. First off, things that jumped out at me:

I do not enjoy that variables are syntactically scoped like a conventional language. I have to use global variables to simultaneously track state and assign “default” values to fields, since variables in, say, an if block are scoped to said if block.
- I think the greatest “simple” thing that would make the language much better is if variables in a pattern were scoped to the pattern itself. This alone would eliminate most of the global variable duplication in the JXL pattern.
- In addition, being able to assign “default” values to memory-backed variables that would serve as its value in case it never gets matched in the file.
For some reason, template types don’t work on bitfields. However, non-type template parameters do? Very confusing.
- This means I had to create five separate types for JXL’s U32 parameterizations, since they’re bit-level types.
I don’t understand why untagged unions exist when conditional parsing is a thing. the documentation only gives the use case of inspecting data as multiple types, but that could also be accomplished by a change to the pattern data viewer—some kind of format casting built in or something.

In an overall sense, the language feels like if C++ was kludged into a binary file pattern matcher, with a few minor rust-isms taken up along the way, rather than built from the ground up as its own DSL for its own domain.

So, it got me thinking about the language, and my mind wandered off many times along the way. A few scattered ideas came out of it all—some loose thoughts on how I’d want a pattern language to operate and feel like:

No treating bytes as something absolutely fundamental to the pattern language; bits and bytes should exist in harmony rather than separated by different types.
- As a result, there’s only one type for “collections” of things, and you can control whether it’s padded by default or bit-packed by default, with a quick way to make exceptions for individual fields.
Patterns are declarative rather than mimicing how an imperative language would go through something. This would alleviate cognitive disconnect when combined with pattern-scoped variables.
- Combine this with “flattening” the syntax to further hound the idea that only pattern-level scopes matter. Say, instead of if (parse_x) { x : u8 }, it’s x : u8 if parse_x.
Variables are immutable; patterns can’t affect the file. A variable’s value is determined only by its memory or, if its condition for existing isn’t met, some other method of assigning a default value (adding on to the if? x : u8 if parse_x else 0? Propagating sum types of non-existent variables?).
It would be cool if there was some kind of external plugin system that allowed more complex tasks to be done in a less domain-specific language (like, say, entropy decoding).

The overarching idea is just that matching patterns against a file would fit better as a more declarative (“functional”?) paradigm than how imhex operates. Alas, a complete, exact syntax escapes me, since I haven’t thought about it too much. I didn’t find much more enjoyment on thinking about what could be something when implementing it would be quite a large undertaking for little benefit (I don’t reverse engineer formats often enough, and imhex is already quite dominant, so would anyone even use a different pattern language?). But it’s nice to passively think about.

So many ideas, so little time.

Jon Sneyers said on the JXL Discord about it: “libjxl has never been a particularly elegant or clean codebase, it was born by smashing together the pik and fuif code and then doing lots of experimental stuff on top of that. I think it was a bit too ambitious to try to be at the same time a reference implementation, cutting edge in terms of both speed and compression performance, and production ready. I mean, I think it kind of achieves all of that, but not in a way that is easy to maintain or contribute improvements to.” ↩︎
Annex C of ISO/IEC 18181-1:2024 ↩︎
Section D.2 of ISO/IEC 18181-1:2024 ↩︎
Section B.2.2 of ISO/IEC 18181-1:2024 ↩︎

some C habits I employ for the modern day

2026-01-17T21:02:00Z

Despite it being the first “proper” programming language I learned—by reading K&R front-to-back no less—I don’t write C too terribly often nowadays. Playing resonite has gotten me into writing a load of C# for modding the game, and most of what I do day-to-day is automating the tedium on my computer, which gets delegated to shell or python because of all the existing infrastructure.

Alas, every now and then, something arises where I have to or just want to write some C (or C++). Sometimes it’s when I need to make some bindings for a library; sometimes it’s to fill a niche of a language/architecture gap. It also remains as my favorite language to prototype stuff in, though I’m not quite sure why.

In any case, C is an interesting language without much standardization on the whole “style” or “practices” part. Most other languages have very clear “this is the best way to use X” messages, either subtly embedded in the syntax itself or through “official” documentation channels. C doesn’t have an official documentation channel, nor does it have syntax or standard library constructs that encourage one particular way of doing things. From this, there’s a bunch of inconsistencies in how people do things, and—especially in the early days of the language and standard library—the landscape and general practice is quite error prone. As such, I’ve developed my own habits when writing C, usually picked up from blog posts, writing C# or rust, or just out of perfectionist brain.

I’m not saying you should write stuff this way, nor am I claiming it is the best way to write C all the time. I break some of these practices when working with embedded systems or when I’m writing things to be as fast as they can possibly be. But it is the baseline I tend to start with for most projects, and if I don’t write it down, I’ll never be consistent with it.

the basics

I usually use C23 for my new C projects. When contributing to other projects, I of course use their revision, but C23 enables a fair amount of the things possible in this post, so it’s what I stick with for projects that aren’t trying to target absolute maximum portability or embedded architectures (i.e. I’d only care about GCC, clang, and maybe MSVC). almost every platform, including any POSIX-compliant one, has CHAR_BIT set to 8, so I like to make it explicitly clear that this is what the project is for by putting this in there:

#if CHAR_BIT != 8
	#error "CHAR_BIT != 8"
#endif

Something very small that I liked a lot when learning rust was its short way of referring to fixed-length types. Combine that with chris wellon’s other typedefs and I end up having all these typedefs in my projects:

typedef uint8_t   u8;
typedef int8_t    i8;
typedef int16_t   i16;
typedef uint16_t  u16;
typedef int32_t   i32;
typedef uint32_t  u32;
typedef uint64_t  u64;
typedef float     f32;
typedef double    f64;
typedef uintptr_t uptr;
typedef ptrdiff_t isize;
typedef size_t    usize;

You may notice that the byte and b32 from wellon’s post are missing here. As said before, when employing this style, I don’t care for systems where char isn’t 8 bit, so the distinction between u8 and char doesn’t mean anything to me here. Additionally, the intent of whether the buffer is used as “raw” memory chunks versus a meaningful u8 is pretty clear from the code that it gets used in, so I’m not worried about confusing intent with it.

b32 is missing because I just use the C23 bool type. If I’m working with >=C99, I use stdbool.h and bool. Its semantics are familiar to me already, and it just feels more right to use for, well, booleans.

I’ve long been employing the length+data string struct. If there was one thing I could go back and time to change about the C language, it would be removal of the null-terminated string. Alas, we do not live in the perfect world, so I work with this for now:

typedef struct {
	// includes null terminator (for bad functions)
	u8 *data;
	// excludes null terminator (for copying memory)
	isize len;
} String;

Along with some functions to initialize from an existing cstr or buffer, copy the string safely, etc.

parsing, not validating

I think one of the most eye-opening blog posts I read when getting into programming initially was the evergreen parse, don’t validate post. If you haven’t read it yourself, I highly encourage you to do so. The TL;DR of it is to work with your language’s type system to the fullest extent, making function signatures take very strict types that can only really be created through trusted interfaces that you provide. In doing so, you get to have an incredibly robust API with very clear, usually compile-time indications when something goes wrong.

I was thinking about how to apply this sort of philosophy to C for a bit—I knew that the most flexible and strong part of C’s comparatively weak type system is the humble struct—but I didn’t know how to go about the whole “can only really be created through trusted interfaces” bit and promptly put it out of my mind when working with C. A few years later, I saw someone link it again on the web, and curiously looked up to see if anyone else tried applying it to C. This took me to lelanthran’s blog post that talks about it, where I learned that you can in fact create arbitrary opaque types and thus properly employ this style.

I was going to embed an in-progress rewrite I’m doing of blsm that employs this principle, but I accidentally overwrote most of the code via a mishap with syncthing. Oops. So, you’ll just have to trust me when I say that I actually do this nowadays for non-playground projects :)

tuples!

One of the more exciting changes of C23 is the explicit standardization that tagged types (struct, union, enum) with the same name and contents are completely compatible with one another. Oftentimes, I wish to return multiple values from a function, but feel as if there’s not much semantic need to assign explicit names to the structure or the members within. Enter the humble tuple:

#define Tuple2(T1, T2)           \
	struct Tuple2_##T1##_##T2 {  \
		T1 a;                    \
		T2 b;                    \
	}

Others may use different names for the members—I’ve seen _0, _1, etc. To roughly mirror rust’s semantics, but I find that a little awkward. The english alphabet is more than familiar to me, so it’s what I’ve stuck to.

Unfortunately, as one might have noticed, this cool feature gets severely limited by the fact that this does not apply to anonymous tagged types (I’d personally consider “untagged” tagged types with the same content to be compatible, but I guess WG13 disagrees). As such, every instance of this feature requires an actual name to be bound to the type. This means that pointers will throw a wrench into it:

$ cc kmp.c
In file included from kmp.c:5:
kmp.c: In function \'apos;main\'apos;:
kmp.c:29:20: error: pasting "*" and "_" does not give a valid preprocessing token
   29 |         Tuple2(char*, int) buffer;
      |                    ^
../common/tuple.h:5:25: note: in definition of macro \'apos;Tuple2\'apos;
    5 |         struct Tuple2_##T1##_##T2 {  \
      |                         ^~

This can be worked around by either making a typedef for the pointer or by having the user provide an explicit name for the struct. Neither are exactly the most ergonomic, so I don’t find myself using this feature as much as I wish.

In any case, for tuples specifically, I’m usually not storing a pointer in them. When it gets to that point, I probably want an actual struct with semantic meaning instead.

returning results

With the idea of trying to encode as much as possible in the type system itself, I’m a pretty big fan of sum types when it makes sense for the language to have them. Naturally, I try to employ using them in C.

In the absence of proper language support, “sum types” are just structs with discipline. These structs will usually be used for public-facing apis and/or have semantic meaning in their own right, so I’m more comfortable making them a typedef as opposed to trying to fuddle in a “result” type into this whole equation. Maybe if C ever allows anonymous tagged types to be compatible will this change, but for now it’s what I have to work with.

The structures generally follow this pattern:

typedef enum {
	...
} ErrorCode;

typedef struct {
	char *val;
} SafeBuffer;

typedef struct {
	bool ok;
	union {
		SafeBuffer *val;
		ErrorCode err;
	};
} MaybeBuffer;

Along with functions to handle printing error messages/etc. For the various error codes that can be returned. The idea is for the caller to always check the ok upon return. You could probably add on a “match” function to specifically handle this without the ability to actually introspect on the struct like before, but that’s incredibly verbose and poor ergonomically in my opinion—this is all compensation for the lack of proper sum types anyway.

When these result types are combined with the previous “parse, don’t validate” approach, I find that I don’t actually dread handling errors in C. If I encounter a function that I know “parses” something, I know it’s going to return a Maybe struct and check ok. If I’m implementing a function that uses one of those SafeBuffer types, I know that there are certain invariants that I can assume to be true, since that type could have only been created through the parsing function.

It sacrifies a bit of verbosity (since C lacks all the nice functional syntax sugar that makes this concise) for much nicer flowing (and safer!) programs

on dynamic memory management

I don’t personally do things that require dynamic memory management in C often, so I don’t have many practices for it. I know that wellons & co. Have been really liking the arena, and I’d probably like it too if I actually used the heap often. But I don’t, so I have nothing to say.

If I find myself needing a bunch of dynamic memory allocations and lifetime management, I will simply start using another language—usually rust or C#. But I also don’t find myself programming that kind of stuff often in general, so it’s really just something I need to explore more as a whole.

anything else?

A few smaller things:

I tend to avoid the string.h functions most of the time, only employing the mem family when I want to, well, mess with memory.
other than that, I only use the standard library in general when I need to do OS functions—I find that a lot of the apis are less than ideal to work with and usually prefer to just reimplement needed ones.

There isn’t much else that I really feel the need to mention. I check the documentation for any external functions I use—because there’s always a wrench that can hide in man—and try to check any nontrivial accesses or funky stuff that might need to be done. Maybe I’ll try to go about making a sort of “slice” type to make that stuff safer, but for now, nothing’s bitten me just yet.

I hope this can get anyone to try thinking about their own C style. I love this language a lot of times yet hate it many other times. At least the limitations can make for some fun problems to solve and safeguards to create :)

going further (2026-03-02)

I meant to put this in the original post, but I completely forgot. Metalang99 is a metaprogramming language implemented in the C preprocessor that allows for a range of interesting things that would be pipe dreams (or horrors) in normal C. Such dreams include interface types or actual algebraic data types.

It would be quite interesting to see how this manifests in a real project. Maybe I’ll use it one day.

rambling about polar quaternions (and some clifford algebra)

2025-09-27T22:32:17Z

I’ve wanted to make my own “how to actually understand and work with quaternions” thing for a bit now. it’d try to explain things in a way that doesn’t require any visualization, but also doesn’t try going too much into the formalities that tend to come with non-visualizations of quaternions.

this isn’t that explanation, but rather some miscellaneous rambles in my journey to re-derive all of quaternion stuff from only the definition.

the core of this kind of explanation relies on euler’s formula:

e^{i x} = cos x + i sin x

this is familiar to most who are already content with complex numbers, and easily provable from knowing the taylor expansions of $e^{x}$ , $cos x$ , and $sin x$ . in any case, the key to this is the idea that $i$ specifically isn’t special here. any “thing” that squares to -1 will work in this formula, and this includes quaternions.

polar complex numbers

to get back to complex numbers, say we have a complex number $a + b i$ . to express it as an exponential:

z = a + b i = | z | e^{i atan 2 (b, a)}

e.g. $3 + 4 i = \sqrt{9 + 16} e^{i atan 2 (4, 3)} = 5 e^{0.9273 i} .$

this is what’s called the polar form (or exponential form) of a complex number, because the number outside the $e$ is the length of the resulting complex number, while the number in the exponential is the $a n g l e$ between the complex number and $1 + 0 i$

I used those vector terms because complex numbers actually map quite nicely to vectors, and by mapping vectors into complex space, operations can be done on them that have geometric meaning, mainly rotation. if we only care about rotational complex numbers, then $| z | = 1$ , so no need to worry about that part.

take this complex number (note: I am using $τ$ to mean $2 π$ ):

z_{1} = - \frac{\sqrt{2}}{2} + \frac{\sqrt{2}}{2} i = e^{\frac{3 τ}{8} i}

look what happens when we multiply it by, say, $z_{2} = 1 + 1 i = \sqrt{2} e^{\frac{τ}{8} i}$ :

\begin{matrix} z_{1} z_{2} & = e^{\frac{3 τ}{8} i} \sqrt{2} e^{\frac{τ}{8} i} \\ = \sqrt{2} e^{i (\frac{3 τ}{8} + \frac{τ}{8})} \\ = \sqrt{2} e^{i \frac{τ}{2}} \\ = \sqrt{2} (- 1) \\ = - \sqrt{2} + 0 i \end{matrix}

check that out! it sorta “rotated” that complex number 135 degrees. this is what stems from that polar transformation, and why it’s so useful for multiplying complex numbers together. you can do that same computation in the rectangular (“standard”) form of complex numbers and see that you end up with the same result

thus, if we use a mapping from a euclidean vector to the complex numbers, the polar form of a complex number $e^{i θ}$ can be interpreted as rotation by $θ$ in the xy plane.

but wait

there’s a different way to convert a normalized complex number to the same polar form. instead of the $atan 2 (b, a)$ bit determining the sign of the thing, we can just use a “normalized” imaginary part, which with only 1 component means the sign of $b$ . for determining the $θ$ of rotation, that’s just $acos (a)$ :

a + b i = e^{acos (a) \frac{b}{| b |} i}

do note that this only works for magnitude-1 complex numbers, since the $acos$ will start going imaginary outside of $[0, 1]$ . you can probably adapt this equation to be more general, but that’s not important for this at all. what’s important is that this works and will be relevant for the next section.

quaternions

how does this get adapted to quaternions? how do we get a quaternion to square to -1? well, as it turns out, any quaternion composed of only imaginary components that also has magnitude of 1 will square to -1:

\begin{matrix} q & = x 𝐢 + y 𝐣 + z 𝐤 where x^{2} + y^{2} + z^{2} = 1 \\ q^{2} & = (x 𝐢 + y 𝐣 + z 𝐤)^{2} \\ = - x^{2} + x y (𝐢 𝐣) + x z (𝐢 𝐤) + y x (𝐣 𝐢) - y^{2} + y z (𝐣 𝐤) + z x (𝐤 𝐢) + z y (𝐣 𝐤) - z^{2} \\ = - x^{2} - y^{2} - z^{2} \\ = - 1 . \end{matrix}

this can be used to create the polar form of a normalized quaternion, derived directly from the way we did a normalized complex number:

\begin{matrix} q & = w + x 𝐢 + y 𝐣 + z 𝐤 where | q | = 1 \\ = e^{acos (w) \frac{z}{| z |}} where z = x 𝐢 + y 𝐣 + z 𝐤 \end{matrix}

e.g.

\begin{matrix} q & = \frac{1}{2} + \frac{1}{2} 𝐢 - \frac{1}{2} 𝐣 + \frac{1}{2} 𝐤 \\ = e^{acos (\frac{1}{2}) (\frac{1}{\sqrt{3}} 𝐢 - \frac{1}{\sqrt{3}} 𝐣 + \frac{1}{\sqrt{3}} 𝐤)} \\ = e^{\frac{τ}{6} (\frac{1}{\sqrt{3}} 𝐢 - \frac{1}{\sqrt{3}} 𝐣 + \frac{1}{\sqrt{3}} 𝐤)} \\ = cos (\frac{τ}{6}) + (\frac{1}{\sqrt{3}} 𝐢 - \frac{1}{\sqrt{3}} 𝐣 + \frac{1}{\sqrt{3}} 𝐤) sin (\frac{τ}{6}) \\ = \frac{1}{2} + \frac{\sqrt{3}}{2} (\frac{1}{\sqrt{3}} 𝐢 - \frac{1}{\sqrt{3}} 𝐣 + \frac{1}{\sqrt{3}} 𝐤) \\ = \frac{1}{2} + \frac{1}{2} 𝐢 - \frac{1}{2} 𝐣 + \frac{1}{2} 𝐤 \end{matrix}

this leads to a (tentative) geometric meaning of the polar quaternion $e^{θ 𝐳}$ : it’ll rotate by $θ$ in the plane that gets defined by $𝐳$ . this plane can also be thought of as a vector axis with no loss of generality

how does this manifest into reality? take a very simple quaternion $q = e^{\frac{τ}{8} 𝐤} = \frac{\sqrt{2}}{2} + \frac{\sqrt{2}}{2} 𝐤$ . here $𝐤$ would represent the x-y plane, or the upwards-pointing z axis, and $\frac{τ}{8}$ would represent a rotation of 45 degrees. so this should, somehow, rotate some mapping of a euclidean vector into the quaternions 45 degrees in the xy plane.

the “some mapping” there is the key crux here. in the complex number system, a simple mapping from a euclidean vector to the real and imaginary part worked wonderfully, but there’s a less clear idea here. there’s three imaginary parts and 1 real part. if we use one real part like the complex numbers, one of the imaginary numbers gets left out. that feels weird. so perhaps we can map vectors to the imaginary part and find something that comes from that

so, taking the simple vector $v = ⟨ 1, 0, 1 ⟩$ , this would get mapped to $1 𝐢 + 0 𝐣 + 1 𝐤$ . in theory, our quaternion $q$ would, when multiplied by this vector, perform a 45 degree rotation in the x-y plane, resulting in $\frac{\sqrt{2}}{2} 𝐢 + \frac{\sqrt{2}}{2} 𝐣 + 1 𝐤$ . does this come into fruition?

\begin{matrix} q v & = (\frac{\sqrt{2}}{2} + \frac{\sqrt{2}}{2} 𝐤) (1 𝐢 + 1 𝐤) \\ = \frac{\sqrt{2}}{2} 𝐢 + \frac{\sqrt{2}}{2} 𝐤 + \frac{\sqrt{2}}{2} 𝐣 - \frac{\sqrt{2}}{2} . \end{matrix}

no.

there’s one idea to try to remedy this: multiplying a quaternion (or any complex thing) by its conjugate will always result in a real number:

\begin{matrix} q \bar{q} & = (w + x 𝐢 + y 𝐣 + z 𝐤) (w - x 𝐢 - y 𝐣 - z 𝐤) \\ = w^{2} - w x 𝐢 - w y 𝐣 - w z 𝐤 \\ + x w 𝐢 - x x 𝐢𝐢 - x y 𝐢𝐣 - x z 𝐢𝐤 \\ + y w 𝐣 - y x 𝐣𝐢 - y y 𝐣𝐣 - y z 𝐣𝐤 \\ + z w 𝐤 - z x 𝐤𝐢 - z y 𝐤𝐣 - z z 𝐤𝐤 \\ = w^{2} + x^{2} + y^{2} + z^{2} \end{matrix}

moreover, this real number will be equal to 1 with normalized quaternions. can this be used to “cancel” the adverse effect of the quaternion?

\begin{matrix} q v \bar{q} & = (\frac{\sqrt{2}}{2} 𝐢 + \frac{\sqrt{2}}{2} 𝐤 + \frac{\sqrt{2}}{2} 𝐣 - \frac{\sqrt{2}}{2}) (\frac{\sqrt{2}}{2} - \frac{\sqrt{2}}{2} 𝐤) \\ = \frac{1}{2} 𝐢 - \frac{1}{2} 𝐢𝐤 + \frac{1}{2} 𝐤 - \frac{1}{2} 𝐤𝐤 + \frac{1}{2} 𝐣 - \frac{1}{2} 𝐣𝐤 - \frac{1}{2} + \frac{1}{2} 𝐤 \\ = \frac{1}{2} 𝐢 + \frac{1}{2} 𝐣 + \frac{1}{2} 𝐤 + \frac{1}{2} + \frac{1}{2} 𝐣 - \frac{1}{2} 𝐢 - \frac{1}{2} + \frac{1}{2} 𝐤 \\ = 1 𝐣 + 1 𝐤 \end{matrix}

would you look at that. we’re no longer getting a weird quaternion that can’t be mapped back to a vector. this appeared to have rotated the vector in the x-y plane by twice the angle specified by the quaternion. this is a general thing that can be applied to any quaternion. the construction of

e^{\frac{θ}{2} (x 𝐢 + y 𝐣 + z 𝐤)} 𝐯 e^{- \frac{θ}{2} (x 𝐢 + y 𝐣 + z 𝐤)}

will “rotate” the “vector” $𝐯$ by $θ$ radians in the plane defined by $x 𝐢 + y 𝐣 + z 𝐤$ (or, as a more familiar notion, the axis defined by that imaginary quaternion)

ok now polar multiplication

now it’s time for the actual reason why I was going to write this. it was originally going to be just this part and nothing else, but that felt weird. everything before was review, now this is where intrigue sets in

so, complex numbers can be composed via multiplication. you get a new complex number that represents both rotations at once. this is the same thing with quaternions: multiplying them gives you a new quaternion that represents applying one rotation and then the other.

with complex numbers, multiplying is extremely easy in the exponential form:

\begin{matrix} z_{1} & = e^{i θ} \\ z_{2} & = e^{i ϕ} \\ z_{1} z_{2} & = e^{i θ} e^{i ϕ} \\ = e^{i (θ + ϕ)} \end{matrix}

you can verify this by converting to and fro the two forms while multiplying them.

however, this construct does not generalize to the quaternion form:

\begin{matrix} q_{1} & = i = e^{\frac{τ}{4} i} \\ q_{2} & = j = e^{\frac{τ}{4} j} \\ q_{1} q_{2} & = i j = k \\ q_{1 e} q_{2 e} & \overset{?}{=} e^{\frac{τ}{4} i + \frac{τ}{4} j} \\ = e^{\frac{τ \sqrt{2}}{2} (\frac{\sqrt{2}}{2} i + \frac{\sqrt{2}}{2} j)} (this is useless) . \end{matrix}

I believe this is because of the anticommutativity of quaternions. when converting to exponents and multiplying, that anticommutativity gets lost. I found this page that describes a scheme for multiplying two polar quaternions, but I can’t really make sense of it. very bad notation on the page.

something about clifford algebra

this section is unrelated to the polar stuff, but I do want to mention it

complex numbers and quaternions seem to be fundamentally different from each other when viewed through this lens, but they’re actually subalgebras of a very general algebraic structure called a clifford algebra. this is not the post to start explaining what a clifford algebra is; I want to make something like that for realsies eventually. but the core idea is that the mappings used for complex/quaternion stuff, while they do enable for the transformations so long as rules are followed, are not very generalizable. how would these mappings be done in 4d? 5d? not the easiest.

clifford algebra is a much more generalized framework that both complex numbers and quaternions are subalgebras of (as well as several, several other complex-like algebras). it separates the notion of a vector and what we consider “imaginary” sections of complex numbers/quaternions. after all, it’s a bit weird how in complex numbers, a 1:1 mapping from vectors to complex numbers can be done, but in quaternions, the mapping has to be done to the imaginary part only.

I hinted at this by not refering to rotations as “around an axis” by default, but rather “in a plane” by default. this was a hint to the existence of bivectors and the different way of thought they bring to the table.

but again, conversation for another day

there wasn’t really a point to this post

I kinda just wanted to coalesce this curiosity about quaternions in this post. there wasn’t really a point to it nor did I really desire to make it “organized”, which is probably evident. this was mainly trying to re-derive quaternion stuff without trying to say anything super formal or making absolute 100% sense of anything, but rather experimentation and seeing where ideas and threads lead.

…but that seems to have become the point of the post. math is about doing experiments with structure, finding patterns, and seeing if those patterns have a relation to something more tangible. there’s no real “nice” way to fundamentally explain why the “sandwich” “product” exists other than it’s an interesting emergent pattern of the created algebra that was then realized to have geometric meaning. sometimes stuff just happens in math, and we derive meaning from the things that happen. that’s what it’s all about! discovery, experimentation, and making relations.

so, go out there and experiment

quickly converting djot to html+mathml

2025-07-06T04:45:34Z

I write djot instead of markdown for my site. I was enticed by the promises of speed and and an actually consistent syntax. check out how djot scales in file size compared to markdown, using the two fastest featureful parsers that I personally know of (jotdown for djot and lowdown for markdown):

# of headings	lowdown	jotdown
1000	0.631s	0.023s
2000	4.584s	0.085s
3000	15.403s	0.188s

you can see that lowdown seemingly scales polynomially while jotdown scales linearly as more headings exist. probably similar with other kinds of environments. though, for my blog, I’m not really working with files of this size. the build time difference between lowdown and jotdown is negligible for me and probably always will be. oh well.

in any case, I still find djot nicer to write. there’s less rules and ambiguity in the syntax. it’s a bit awkward how I have to make a new paragraph when writing nested lists, but that’s about my only reservation. one of the things I found neat about djot is that is has a definite math syntax, when markdown parsers with a LaTeX math extension need to fiddle with that awkward double dollar sign syntax. I’ve experienced it exploding once when I was writing physics notes in markdown some years ago.

here’s how jotdown parses a math block:

$ cat math.djot
## check out this matrix

$$`
\begin{bmatrix}
	1 & 0 \\
	0 & 1
\end{bmatrix}
`

cool, right?

$ jotdown math.djot
<section id="check-out-this-matrix">
<h2>check out this matrix</h2>
<p><span class="math display">\[
\begin{bmatrix}
1 &amp; 0 \\
0 &amp; 1
\end{bmatrix}
\]</span></p>
<p>cool, right?</p>
</section>

ah. it parses the math and spits it out, but it doesn’t exactly do anything with it spare surround it with the proper LaTeX display/inline math delimiters. when making my blog post about shearing, I externalized all the mathml parsing to LaTeXML and raw-inlined the math into the djot. this was really annoying for two reasons:

whenever I wanted to edit an equation after editing a bunch of other stuff or having closed my editor, I had to reconstruct the LaTeX from the annotation that LaTeXML makes. the program minifies and slightly changes the styling of the math, so it took a bit of time to mentally parse and edit.
the file became incredibly difficult to navigate in general. I use soft wrapping in kakoune, not hard wrapping, and the entire blob of mathml for every equation made navigation clunky

it wasn’t until about two days ago that I learned that pandoc is able to do this fine:

$ pandoc -f djot --mathml math.djot
<h2 id="check-out-this-matrix">check out this matrix</h2>
<p><math display="block" xmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mo stretchy="true" form="prefix">[</mo><mtable><mtr><mtd columnalign="center" style="text-align: center"><mn>1</mn></mtd><mtd columnalign="center" style="text-align: center"><mn>0</mn></mtd></mtr><mtr><mtd columnalign="center" style="text-align: center"><mn>0</mn></mtd><mtd columnalign="center" style="text-align: center"><mn>1</mn></mtd></mtr></mtable><mo stretchy="true" form="postfix">]</mo></mrow><annotation encoding="application/x-tex">
\begin{bmatrix}
1 &amp; 0 \\
0 &amp; 1
\end{bmatrix}
</annotation></semantics></math></p>
<p>cool, right?</p>

…but if I built my site with pandoc instead of jotdown, my build time septuples since I call it for every markdown file. currently, it takes about 0.17 seconds to build my site when using jotdown and 1.3 seconds if I use pandoc instead. not great, especially if I were to add a bunch more djot files, I’d imagine!

so I quickly hacked together a little rust program that combines the jotdown library with the math-core crate for rendering mathml from LaTeX. I’ve never written rust before, so it’s not exactly perfect, but I don’t need it to be. it works for me! maybe it’ll work for you too.

update (2026-03-26)

I made a custom renderer that fixes that issue mentioned earlier, so now it’s pretty much perfect for my use case!

representing a shear/skew with only rotation and scaling

2025-06-26T08:07:00Z

clickbait title: “rederiving an extremely elegant equation from a classic 1990 computer graphics book”

note: this post uses MathML for formatting the math. this is supported by all the major browsers (I tested chromium, firefox, and pale moon), but more obscure browsers might not render it

I’m in resonite—as I am—hanging out with some critters in a world—as one does. sparsely out of the corner of my eyes and ears, I oversee and overhear someone else in the session messing about with a cube, cursing at how the math they’re doing isn’t working out. of course, I hear the word “math” and perk up immediately, going over to observe their happenings. what was their plight? what accursed math must they be doing to provoke this reaction? fumbling with quaternions? higher-dimensional happenings and mappings?

turns out, they just wanted to shear a cube. that’s right—this funny little transformation:

and it was ending up being harder than they thought. I was then ~~conscripted~~ nerd sniped into figuring this out as well, which took up approximately four full days of time thinking about this problem and gaining knowledge of a neat little linear algebra thing in the process, hence why I am writing this post about it.

for reference, in resonite, components for meshes, rendering, all the like are attached to things called “slots”. these slots make up a hierarchy in the world, and each slot can have a transformation applied to it. however, you only have access to translation, rotation, and scaling on any individual slot. as such, if you want to express complex, arbitrary transformations on components, you have to compose the transformations on these individual slots. you do not have access to arbitrary transformations directly—all transformations have to eventually be represented in this hierarchy of slots alone.

as an example, if I want to stretch out a cube along one of its axis-aligned diagonal, I have to:

rotate the cube by 45 degrees (inner slot)
scale the cube in the desired direction (outer slot)
rotate the cube back 45 degrees (outer slot)

now you might be able to see where the problem lies.

my initial attempt

I came into this armed with a heap of trigonometry knowledge, so I took a crack at trying to solve this myself. I & the other critter came up with the process of:

rotate the object 45 degrees towards the skew direction
scale the object in the direction of skew
undo the rotation with some trig at the end
undo the deformation that results from the scaling in step 2

and I was the one to figure out the number crunching and equation solving for it.

this idea actually worked!… kinda. there were two issues with it:

it required four transformations, or at minimum 3 slots (the scale and undo-rotation in step 2 and 3 can be done in one slot). I was under the impression that this has to be possible in only 3 transformations, or two slots
it only worked for angles up to 45 degrees. while the object can stretch infinitely long in step 2, that stretch has to be compensated for in step 4 to preserve the side lengths on axes that shouldn’t be affected by the skew. this would cause the transformation to get closer and closer to 45 degrees… but never truly reach it.

here’s the three pages of work I scrawled while figuring out this method:

you can notice how I had the idea of using non-45 degree angles to prevent the limit that 45 degrees caused, but analyzing that with only trigonometry got way too unwieldy for me to pursue. as such, I decided that it was time to start thinking more analytically

problem statement

the basic premise of a shear/skew is this: we want to scale one axis based on how far along another axis we are. this causes points close to the zero line of the shear axis to move only a little bit, while points far away from the shear axis to move a lot. this can be seen visually in the image back at the top of this post.

to progress in this endeavor, however, it would help a lot to represent this analytically. we leave the land of geometry and trig for the land of matrices. unfortunately, I will not be explaining everything there is to do with matrices for this post—it would be too much and sprawl the post out too much—but there are excellent resources online to get started with them. to reduce clutter further, I will only be looking at the 2d case throughout most of this post—the 3d case follows directly from the 2d concepts.

to begin, a shearing matrix looks like this:

[\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}]

this accomplishes our goal of scaling one axis as we move along the other axis:

[\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}] [\begin{matrix} x \\ y \end{matrix}] = [\begin{matrix} x + a y \\ y \end{matrix}]

now, we want to represent this matrix with rotations and scaling only. I’ll save the complications and just state that translation is not needed throughout this entire thing. as a refresher, a rotation matrix looks like this:

[\begin{matrix} cos θ & - sin θ \\ sin θ & cos θ \end{matrix}] [\begin{matrix} x \\ y \end{matrix}] = [\begin{matrix} x cos θ - y sin θ \\ x sin θ + y cos θ \end{matrix}]

and a scale matrix looks like this:

[\begin{matrix} S_{x} & 0 \\ 0 & S_{y} \end{matrix}] [\begin{matrix} x \\ y \end{matrix}] = [\begin{matrix} x S_{x} \\ y S_{y} \end{matrix}]

and to “compose” transformations, we just multiply the matrices together.

you can glance at these three matrices and quickly realize that this isn’t quite as trivial as it may seem. figuring out some special rotation and scale constants to cancel everything out to 1 along the diagonal, 0 in the bottom left, and a nonzero term in the top right is not something that can just be done in a human brain.

usually, when pursuing such a question, it’s best to first see if anyone else thought of this problem as well. time to start researching.

research

there’s not much existing information online about this specific conundrum. turns out, in most places where this might be an issue (such as Unity), you have access to arbitrary shader code, which means arbitrary transformations either way. it makes this kind of thing extremely niche and only really relevant in places where you’re hard-constrained to these basic three transformations—which describes my situation exactly.

nonetheless, I did find a few hints at a direction to look in, thanks to stackoverflow:

both of these questions pointed towards something I haven’t heard before—this thing called the “SVD”. following one of the links to this college homework assignment from 2003, question 3 gives more insight on this whole thing. while it displays a formula for a special case of a shear matrix—where the shear factor is $a - \frac{1}{a}$ —this is not a general form that made me happy. looking at the end of the question, a particular book is referenced: “Graphics Gems I”, page 485.

I acquired that book and went to the page in question. there, the following equation is presented without comment:

for some reason—and I didn’t realize this until writing this post—this section of the book (unsure about the whole book) shows all the matrices as their transposes than what you’d expect. their rotations are clockwise by default rather than counterclockwise by default—their skews not aligned with current conventions. they might be doing their matrix multiplication as right multiplications rather than the conventional left multiplication.

to translate this from the primitive formatting and backwards convention of the book, it states the following:

[\begin{matrix} 1 & tan a \\ 0 & 1 \end{matrix}] = R (θ + \frac{π}{2}) \times [\begin{matrix} γ & 0 \\ 0 & \frac{1}{γ} \end{matrix}] \times R (θ)

where

\begin{matrix} γ & = \frac{1}{2} (tan (a) \pm \sqrt{{tan}^{2} (a) + 4}) \\ θ & = - arctan (γ) \end{matrix}

and $R$ is the rotation matrix as described above. if you want to change the direction of shear, you can simply swap the scale values and axis of rotation.

what a neat and elegant equation! I noticed that the $tan a$ part was only necessary for knowing the angle of shear, and that I can just replace all the tangents in the equation with just a constant “shear factor”, simplifying it a bit.

I went ahead and ported this to protoflux—resonite’s node-based programming language for this kind of thing—and it just, worked perfectly fine.

I was simultaneously excited that I found an implementation that worked, but also incredibly disappointed that I had no idea how it worked. how did they derive this? what thought process went in to this? of course, the book itself didn’t derive it at all. nothing in that entire section leds up to that formula, nor did they give any hint at how to derive it in the first place.

but if you remember, I was given a hint from stackoverflow & the homework: this silly little thing called the “singular value decomposition”

what the hell is a singular value

if you try and search what the singular value decomposition is online, chances are that you’ll get swamped with formalisms and definitions and have a very hard time. I was like this when looking at the wikipedia article about the subject, and I ended up obsessing over everything when it didn’t quite matter all the time.

I’ll assume you already know what a matrix is, the basic operations on them, and a few basic linear algebra terms related to them. I kinda already did that up above. it’ll also be helpful to know what an eigenvalue and eigenvector is. if you don’t, the wikipedia page for them is much more practically understandable than the SVD page.

before explaining the SVD, there’s a few quick facts you should internalize first:

the eigenvalues of $A A^{T}$ and $A^{T} A$ are the same.
the matrix products $A A^{T}$ and $A^{T} A$ are both symmetric matrices. this means that, for both of the matrices, their eigenvectors are orthogonal to each other, and thus can be used to construct an orthogonal matrix if you normalize them.

with these two facts in mind, here’s an hopefully intuitive understanding of what the SVD is, starting with an informal definition and building on it:

any matrix—and thus any linear transformation—can be represented as a multiplication of three special matrices:

$U$ : an orthogonal matrix
$Σ$ : a diagonal matrix
$V^{T}$ : a transpose of another orthogonal matrix, which means that it itself is also orthogonal

this is commonly notated like $A = U Σ V^{T}$ .

what does this mean for transformations? well, an orthogonal matrix is used to rotate things, and a diagonal matrix is used to scale things, so… any linear transformation can be represented as a rotation, followed by some scale, followed by another rotation. pretty neat, isn’t it?

to get specific about what these values are, the columns of the $U$ and $V$ matrices are made up of the normalized eigenvectors of the matrices $A A^{T}$ and $A^{T} A$ , respectively. these two sets of eigenvectors are called the left singular vectors and right singular vectors, respectively. the entries along the diagonal of $Σ$ are the square roots of the eigenvalues of $A A^{T}$ or $A^{T} A$ (since these two matrices have the same eigenvalues). they should align in the same columns as their corresponding eigenvectors in the other two matrices, and the most common convention for this is to put them in descending order along the diagonal.

why does this work?

recall what eigenvalues and eigenvectors are for a minute. if we can represent a matrix multiplied with a vector as a scalar multiplied with said vector, what would happen if we had a way to make a “base” of orthogonal eigenvectors, applying different scales to each eigenvector? we’d be able to represent that matrix transformation with only scaling. this is the essence of the SVD.

keeping in mind that the convention is to left-multiply the transformation matrix against the vector, this is the order of transformations:

when multiplying by $V^{T}$ , we rotate our coordinate space from our original basis—what we’d consider the “x” and “y” unit vectors geometrically—to the basis of the eigenvectors of $A^{T} A$ .
now that we’re in this coordinate space, we use the singular values to perform the transformation of A in the eigenspace of ATA.
- I was confused as to why these singular values did this transformation, but I think I get it now. conventionally, when you square a matrix, the eigenvalues of that new matrix are the eigenvalues of the original matrix squared. this is not the case when you multiply a matrix by its transpose. however, when we’re in the basis of $A^{T} A$ , the eigenvalues of that product are doing that transformation in that basis, but squared. we have to account for this by square rooting the eigenvalues. this is just my line of reasoning that I am attempting to deduce from this and is in no way formal. if someone who knows about this more than me sees this and it’s completely wrong, let me know and I’ll edit this!
finally, after we do the transformation, we need to rotate back to our original basis. therefore, we multiply by $U$ composed of the left singular vectors.

deriving the shear case

that’s all well and good, but this was supposed to be about the shear transformation! oh dear. I’m 170 or so lines into this djot file and haven’t talked about the shear transformation yet. but no longer! because I will finally be showcasing the derivation of that one equation that I was so obsessed over. this will serve both as a more accessible reference for this equation, as well as a complete workout of computing the singular value decomposition, since there’s a severe lack of that on the internet. let’s go!

remember: the shear matrix looks like so:

A = [\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}]

the singular values

we first compute $A A^{T}$ and $A^{T} A$ :

\begin{matrix} A A^{T} & = [\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}] [\begin{matrix} 1 & 0 \\ a & 1 \end{matrix}] = [\begin{matrix} 1 + a^{2} & a \\ a & 1 \end{matrix}] \\ A^{T} A & = [\begin{matrix} 1 & 0 \\ a & 1 \end{matrix}] [\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}] = [\begin{matrix} 1 & a \\ a & 1 + a^{2} \end{matrix}] \end{matrix}

then we compute the eigenvalues of either of these two matrices. we don’t need to do both, since the eigenvalues for the two matrices are the same. going against sheldon axler for a moment here, we’ll get the characteristic polynomial:

\begin{matrix} det (A^{T} A) & = (1 - λ) (1 + a^{2} - λ) - a^{2} \\ = 1 + a^{2} - λ - λ - a^{2} λ + λ^{2} - a^{2} \\ = λ^{2} - (a^{2} + 2) λ + 1 \end{matrix}

and solve for the eigenvalues, this time simply with the quadratic equation:

\begin{matrix} λ & = \frac{1}{2} (a^{2} + 2 \pm \sqrt{(- (a^{2} + 2))^{2} - 4}) \\ = \frac{1}{2} (a^{2} + 2 \pm \sqrt{a^{4} + 4 a^{2} + 4 - 4}) \\ = \frac{1}{2} (a^{2} + 2 \pm \sqrt{a^{4} + 4 a^{2}}) \end{matrix}

I’ll split the two eigenvalues up like so:

\begin{matrix} λ_{+} & = \frac{1}{2} (a^{2} + 2 + a \sqrt{a^{2} + 4}) \\ λ_{-} & = \frac{1}{2} (a^{2} + 2 - a \sqrt{a^{2} + 4}) \end{matrix}

where the square root always represents the positive square root.

note how $λ_{+} > λ_{-}$ for all values of $a$ .

to get the singular values from these, all we need to do is take the square root of these eigenvalues:

\begin{matrix} σ_{+} & = \sqrt{λ_{+}} \\ = \sqrt{\frac{1}{2} (a^{2} + 2 + a \sqrt{a^{2} + 4})} \\ = \frac{1}{2} \sqrt{2 a^{2} + 4 + 2 a \sqrt{a^{2} + 4}} \\ = \frac{1}{2} \sqrt{{(a + \sqrt{a^{2} + 4})}^{2}} \\ = \frac{1}{2} (a + \sqrt{a^{2} + 4}) \end{matrix}

you can go through these same motions for $λ_{-}$ to find $σ_{-}$ :

σ_{-} = \frac{1}{2} (a - \sqrt{a^{2} + 4})

in the context of the SVD, these singular values are used to construct $Σ$ , the middle matrix, by placing them along the diagonals. the order of these values doesn’t really matter so long as the singular vectors corresponding to said eigenvalues are placed in the same columns of $Σ$ . however, it’s a common convention to sort them in a descending order, making our middle matrix:

Σ = [\begin{matrix} σ_{+} & 0 \\ 0 & σ_{-} \end{matrix}]

if you remember what the equation says, this seems ridiculous! both diagonal entries are stated in terms of only one number, not two like we have here. to remedy this, we can pull off some neat little algebra for a cool result:

\begin{matrix} σ_{-} & = \frac{a - \sqrt{a^{2} + 4}}{2} \\ = \frac{a - \sqrt{a^{2} + 4}}{2} (\frac{a + \sqrt{a^{2} + 4}}{a + \sqrt{a^{2} + 4}}) \\ = \frac{a^{2} - a^{2} - 4}{2 (a + \sqrt{a^{2} + 4})} \\ = - \frac{1}{\frac{1}{2} (a + \sqrt{a^{2} + 4})} \\ = - \frac{1}{σ_{+}} \end{matrix}

which makes our $Σ$ :

Σ = [\begin{matrix} σ_{+} & 0 \\ 0 & - \frac{1}{σ_{+}} \end{matrix}]

right singular vectors

now we need to find the eigenvectors of both of the matrices. even though the eigenvalues are the same, the eigenvectors are not. starting with the right singular vectors, we need to find the eigenvectors of $A^{T} A$ corresponding to our two eigenvalues:

starting with $λ_{+}$ :

\begin{matrix} [\begin{matrix} 1 - \frac{1}{2} (a^{2} + 2 + a \sqrt{a^{2} + 4}) & a \\ a & 1 + a^{2} - \frac{1}{2} (a^{2} + 2 + a \sqrt{a^{2} + 4}) \end{matrix}] [\begin{matrix} v_{1} \\ v_{2} \end{matrix}] = 𝟎 \\ \Rightarrow {\begin{matrix} - \frac{1}{2} (a^{2} + a \sqrt{a^{2} + 4}) v_{1} + a v_{2} & = 0 \\ a v_{1} - \frac{1}{2} (- a^{2} + \sqrt{a^{2} + 4}) v_{2} & = 0 \end{matrix}, \\ \Rightarrow a v_{2} = \frac{1}{2} (a^{2} + a \sqrt{a^{2} + 4}) v_{1} (Using 1st equation) \\ \Rightarrow v_{2} = \frac{1}{2} (a + \sqrt{a^{2} + 4}) v_{1} \\ \Rightarrow 𝐯_{+} = [\begin{matrix} 1 \\ \frac{1}{2} (a + \sqrt{a^{2} + 4}) \end{matrix}] = [\begin{matrix} 1 \\ σ_{+} \end{matrix}] \end{matrix}

now we need to normalize this vector such that it can be used in an orthogonal matrix. if we look at the reciprocal of its length:

\frac{1}{‖ 𝐯_{+} ‖} = \frac{1}{\sqrt{1^{2} + σ_{+}^{2}}}

hey, wait a minute… if we refer to wikipedia’s table of inverse trig identities, this is an identity!

\frac{1}{\sqrt{1 + σ_{+}^{2}}} = cos (arctan (σ_{+}))

this makes the normalized form of the eigenvector extremely simple:

\begin{matrix} \frac{𝐯_{+}}{‖ 𝐯_{+} ‖} & = [\begin{matrix} cos (arctan (σ_{+})) \\ cos (arctan (σ_{+})) σ_{+} \end{matrix}] \\ = [\begin{matrix} cos (arctan (σ_{+})) \\ sin (arctan (σ_{+})) \end{matrix}] \end{matrix}

hooray! we have computed one of the right singular vectors of $A$ .

for brevity’s sake, I will not go through this entire process again for the other three eigenvectors we need. with all that I have stated in this post, one is able to go through roughly the same motions for the rest of the eigenvectors of $A^{T} A$ and $A A^{T}$ . think of it as an exercise for the reader.

anyway, if you go through that process again for $λ_{-}$ , we can get our second right singular vector:

𝐯_{-} = [\begin{matrix} - sin (arctan (σ_{+})) \\ cos (arctan (σ_{+})) \end{matrix}]

and with that, we now know the columns of $V$ ! making sure to line up our singular vectors with the singular values in $Σ$ , we get:

\begin{matrix} V & = [\begin{matrix} cos (θ) & - sin (θ) \\ sin (θ) & cos (θ) \end{matrix}] \\ where θ & = arctan (σ_{+}) \end{matrix}

left singular vectors

if you go through the same motions as the right singular vectors but for the matrix $A A^{T}$ , you will find the left singular vectors. without any simplification further than what I did for the right singular vectors, I found:

\begin{matrix} 𝐯_{+} & = [\begin{matrix} sin (θ) \\ cos (θ) \end{matrix}] \\ 𝐯_{-} & = [\begin{matrix} cos (θ) \\ - sin (θ) \end{matrix}] \\ where θ & = arctan (σ_{+}) \end{matrix}

making our $U$ matrix:

U = [\begin{matrix} sin (θ) & cos (θ) \\ cos (θ) & - sin (θ) \end{matrix}]

putting it all together

finally, after all that math, we have our decomposition! our funny shear matrix, represented as a multiplication of an orthogonal, scaling, then other orthogonal matrix, is:

\begin{matrix} [\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}] & = U Σ V^{T} \\ = [\begin{matrix} sin (θ) & cos (θ) \\ cos (θ) & - sin (θ) \end{matrix}] [\begin{matrix} σ_{+} & 0 \\ 0 & - \frac{1}{σ_{+}} \end{matrix}] [\begin{matrix} cos (θ) & sin (θ) \\ - sin (θ) & cos (θ) \end{matrix}] \end{matrix}

where

\begin{matrix} σ_{+} & = \frac{1}{2} (a + \sqrt{a^{2} + 4}) \\ θ & = arctan (σ_{+}) \end{matrix}

…wait a second. this doesn’t look like what we want at all. those two orthogonal matrices aren’t proper rotation matrices, so we can’t use them in slot transforms. and wait, scaling by a negative number? that’s prone to breaking a lot of things! certainly, this isn’t the end of the line. we need to do a little matrix algebra.

first off, we can change $θ$ to $- θ$ , knowing that $cos (x) = cos (- x)$ and $sin (x) = - sin (- x)$ :

A = [\begin{matrix} - sin (- θ) & cos (- θ) \\ cos (- θ) & sin (- θ) \end{matrix}] [\begin{matrix} σ_{+} & 0 \\ 0 & - \frac{1}{σ_{+}} \end{matrix}] [\begin{matrix} cos (- θ) & - sin (- θ) \\ sin (- θ) & cos (- θ) \end{matrix}]

which makes $V$ look like a proper rotation matrix

second, we can split up $Σ$ into two matrices:

\begin{matrix} Σ & = [\begin{matrix} σ_{+} & 0 \\ 0 & - \frac{1}{σ_{+}} \end{matrix}] \\ = [\begin{matrix} 1 & 0 \\ 0 & - 1 \end{matrix}] [\begin{matrix} σ_{+} & 0 \\ 0 & \frac{1}{σ_{+}} \end{matrix}] \end{matrix}

and since matrix multiplication is associative, we can multiply $U$ by the matrix shown on the left:

[\begin{matrix} - sin (- θ) & cos (- θ) \\ cos (- θ) & sin (- θ) \end{matrix}] [\begin{matrix} 1 & 0 \\ 0 & - 1 \end{matrix}] = [\begin{matrix} - sin (- θ) & - cos (- θ) \\ cos (- θ) & - sin (- θ) \end{matrix}]

finally, knowing that $sin (x) = cos (x - \frac{π}{2})$ and $cos (x) = - c o s (x + π)$ :

\begin{matrix} [\begin{matrix} - sin (- θ) & - cos (- θ) \\ cos (- θ) & - sin (- θ) \end{matrix}] & = [\begin{matrix} - cos (- θ - \frac{π}{2}) & - sin (- θ + \frac{π}{2}) \\ sin (- θ + \frac{π}{2}) & - cos (- θ - \frac{π}{2}) \end{matrix}] \\ = [\begin{matrix} cos (- θ + \frac{π}{2}) & - sin (- θ + \frac{π}{2}) \\ sin (- θ + \frac{π}{2}) & cos (- θ + \frac{π}{2}) \end{matrix}] \end{matrix}

after putting all of that together, and renaming $σ_{+}$ to $γ$ because I think it looks nicer, we end up with:

\begin{matrix} [\begin{matrix} 1 & a \\ 0 & 1 \end{matrix}] & = U Σ V^{T} \\ = [\begin{matrix} cos (θ + \frac{π}{2}) & - sin (θ + \frac{π}{2}) \\ sin (θ + \frac{π}{2}) & cos (θ + \frac{π}{2}) \end{matrix}] [\begin{matrix} γ & 0 \\ 0 & \frac{1}{γ} \end{matrix}] [\begin{matrix} cos (θ) & - sin (θ) \\ sin (θ) & cos (θ) \end{matrix}] \end{matrix}

where

\begin{matrix} γ & = \frac{1}{2} (a + \sqrt{a^{2} + 4}) \\ θ & = - arctan (γ) \end{matrix}

this is exactly what we wanted! in the book equation, they use $tan a$ instead of $a$ to have an “angle” of shear rather than a ratio of shear, but nonetheless, it functions the same!

the above image shows shearing the x axis with respect to the y axis. switching these two axes is quite easy—it’s a matter of just swapping some values around. you can even “combine” two shears like this under four slots, so long as they don’t create a loop of shearing, as that’d result in a wrong shear.

you can find a doodad for this in resonite in my public folder, under Plux/Tidbits: resrec:///U-yosh/R-397fd2e1-f035-4dbd-a5e5-217a1f8eb95c

and, for completion’s sake, here’s the four main pages of work that I did for this problem:

further endeavors

I want to eventually derive the same equation for an arbitrary 3x3 “shear” matrix:

[\begin{matrix} 1 & a & b \\ d & 1 & c \\ e & f & 1 \end{matrix}]

but that will be for when I’m particularly bored one day, as I don’t envision it to be very fun, even when I can get wolfram alpha to do lots of the heavy lifting for me.

perhaps other funny matrix transformations can be derived in a similar way

I don't want to watch videos

2025-01-09T10:34:49Z

I join a session on resonite. it’s a gridspace—or maybe a small, quaint little hangout. my friends are in there. I like my friends. but I join—I wander, wander, eventually finding the critters—and see nothing but empty husks of models surrounding a flat video player. smack dab in the middle of a random room.

I leave, usually

I don’t need any auditory gaps to be filled. I don’t need to give my brain stimulation through empty Content. I don’t need every moment of my time in this digital space to be filled with noise

and I especially don’t want to watch a meme compilation.

at best, I can play along. on average, I turn the volume off. if I’m sufficiently annoyed or out of it, I will leave. I feel like shit when I do. I feel like I don’t fit. almost none of the time do I want to drop everything to watch a video in a social space. it’s almost always not something I’m interested in, for one. for two, if I’m in a social space, I usually want to be social, damnit

I don’t care about this 20 minute eccentrically edited video of some guy making a thing. I’d rather read a blog post about it. I don’t care about this hit new piece of tech that I won’t buy. it’s probably going to be discontinued in half a year and sends your data to 50 billion advertisers. I don’t care about this twitch streamer e-celeb that’s always loud and relies on the parasocial bond between themselves and a soulless chat. almost all of them I can’t stand, spare a small and select few

I don’t want to zombie out at a “try not to laugh” compilation where everything is stolen from 3 places anyway. feeling like shit the whole time usually means I’m not laughing

tell me about your day. tell me about your latest interest. tell me about any interest you have. what you’re working on. how’s life. what’s life. how was the weather today. I don’t know man. I’d rather share the silence than try and fill its blissful emptiness with artificial noise from a source that shouldn’t even be in the conversation.

the silence is social. we experience the silence together. we can envelop ourselves in its odd warmth.

it’s boring, but it’s a boring that leaves you content. silence is what true freedom is

I feel more lonely watching Content with others than sitting in silence with myself. I feel more together sitting and doing nothing with another critter than softening my brain with a recap of a movie everyone in the room has already watched. and if a video is less than 60 seconds and 9:16, the volume’s going to zero faster than what gravity could do.

I don’t have all the answers. I don’t know what to say myself a lot of the time. so I won’t expect other critters to force words out of their maws. but silence is more than enough

I just really, really don’t want to watch a video

composable keybinds should be everywhere

2024-09-23T13:21:40Z

the title is a little clickbait—it should really be “composable keybinds should be in a lot more places than just text editors”, but that’s a little long for a blog title.

I started using vim when I started using linux basically. I can’t remember why exactly I started—was it because of the claim of “vim is crazy efficient” or “vim is everywhere” in an effort to be hip with the cool linux kids? not sure. in any case, I really enjoyed working with it! I never really got too deep into vim-fu—trying to puzzle out the exact obscure editing commands that would minimize keystrokes and save like… maybe 0.5 seconds at most compared to no-brain doing “less optimal” keystrokes wasn’t really my thing

I switched to kakoune for my text editing work some months ago, but that’s not the point of this post (debate the editor war on your own time). the point is, vim’s composing-keybinding style stuck with me, and seeing that kakoune is an editor inspired heavily by vim, I wanted to try it as well! the way kakoune approached its model editing flow felt like a nice, fresh experiment compared to vim, which kept me around to using it and eventually just removing vim from my system as a whole

the main takeaway is that I think composing keybinds is a bit… under-represented in the software sphere right now. we really only have it in text editors, and really only because vi existed all that time ago. and yet, for some use cases, I must wonder how keybindings could be if they were made “modal” or “composing”, and whether they’d work better for the application’s purpose, if not just for me

gimp (and other image editors)

take gimp. it’s an image editor. it edits images. there’s a few different ways you can interact with an image in gimp:

tools, like a paintbrush, pencil, fill, etc.
filters, like a blur across the whole image, distortions, etc.
selections, like rectangle, circle, etc.
paths, like a curved path to fill in later or reference, text outline paths, etc.
and many more…

the fact that one can group a bunch of related things screams composability to me. currently, I have s bound to the rectangular select tool and Shift+e bound to the ellipse tool, since e normally is taken up by the eraser. I have v for fuzzy select and Shift+c for color select, since c is for clone stamp and I just couldn’t find any other key that fuzzy select could be on. instead of having s be meaningless on its own but rather a keybind specifically for rectangular selection, what if we had this schema:

s -> enter selection mode
se -> select ellipse
sr -> select rectangle
ss -> select scissors
sf -> select foreground
sw -> select wand
sc -> select color

not only does this allow for semantically sensible keybinds, but it additionally compartmentalizes keybinds into their own quarters of the application, allowing for the keyboard keys to be free for other modes and keybinds. this means we can make something like…

t -> enter tool mode
te -> eraser tool
tf -> fill tool (gimp calls it “bucket fill”, but whatever)
tb -> brush tool
tB -> pencil tool (as opposed to needing to use two hands/move a lot to reach p)
tc -> clone stamp tool
…

you can see the vision here right. because of having these separate “modes” to branch other keybinds off of, less cognitive overhead is spent trying to remember the obscure keybind you set a month ago or breaking your wrist to chord the correct keybind on one hand. yeah, maybe it’ll be slower compared to someone who does know their existing keybinds like the back of their hand, but the speed difference is negligible for something like gimp (and arguably the speed difference modal editors do with their “hyper optimized bindings” is greatly exaggerated)

other places

I know blender has somewhat composable keybinds. some keybinds pop up a little menu that you can select from, but (I don’t think) you can compose another keybind to select something in that menu without using arrow keys or whatever. can’t remember—someone who has used blender more than I can probably chime in on this more. but in any case, it’d be nice to see proper modal editing and/or composable keybinds there

I’ve used pentadactyl on pale moon for many years now. I like being able to use gt/gr to go right and left in my tabs. I like gg and G. I like using d and u to scroll pages, p/P to paste a url, t/T to open, o/O to open, all the like. I’m not nearly an expert pentadactyl user—some things in a web browser are just better to do with a mouse—and the simple existence of “single/double key keybinds” isn’t exactly “modal” or “composability” to its fullest, but it’s a neat thing that I enjoy using and would like to see more

the conclusion paragraph

yeah this was kinda just a no brainer hour-long writing spree about this so I could get my thoughts all on one page. I’d like to see composable keybinds and “modes” of a program be explored more outside text editors, because I feel like there are places where they can work well. of course, not everywhere, but not an insignificant amount of applications. I think it’d be cool

stop saying "content"

2024-07-20T20:15:44Z

this is a rant. it’s not meant to flow nice, like a serious post. it’s a dump of my mind

I feel like a certain shift occurred within the past few years. a shift of semantics and how we refer to art and entertainment forms online. this shift is especially prevalent for videos, where historical evidence of only a few years ago (searching with before:2021-01-01 on google) represents such a stark shift in a short amount of time. it’s a shift that confuses me, leaves me befuddled, and weirdly like I’m the odd one out for noticing it, because I haven’t heard anyone else talk about it

if someone makes a video, what words do we have to describe that video, and what words do we have to describe the video creator? if I make a long video covering a specific topic, delving into well-researched facts to tell a story, what video is that? by any reasonable merit, it is a documentary. short ones would be mini-docs. or docs! they don’t have to be long. and I’d be a documentarian. if I make a shorter video—about 20 or so minutes—playing a video game with friends, what would that be? a let’s play? maybe, if the intent was of progression. recorded banter? maybe, if the game is more casual and quick. how about a blender animation? art? motion design? we have so many words to describe to many things. language is flexible and wide-spanning

but this shift doesn’t respect that. it’s a shift that homogenizes—puts everyone in the same box—and dilutes the water for everyone.

content.

that word itches at me. does it itch at you? everything is content now. thanks for the content. I love your content. please make more content. your content is some of the best on the platform. wow, more content from you.

we’ve reached a point where concerts aren’t concerts. art is content. media is content. artists are content creators, no matter their profession. except maybe 2d illustrators. those aren’t content creators. those are still artists. vrchat avatar creator? no, vr content creator. resonite tool creator? no, resonite content creator. video game streamer? no, content creator. documentary? long-form content. videographer? content creator. urban explorer? content creator.

it’s tiring

why?

why have we gotten to this point? what caused it?

I don’t know, really. a leading theory by a friend of mine is that influencers started realizing that people hated influencers, and decided to distance themselves from the term.

that’s a nice theory, I guess, and I want to think it’s kind of true. I haven’t heard the term “influencer” used seriously in quite a while. rats, they all are.

though I don’t think that’s the whole story. I think things kinda just, changed in our interfaces—how the corporate marketers described their userbase has shifted. a little, at least. youtube changed the description of “things uploaded on your channel” from “videos” to “content” some time between september 2020 and january 2021 (I don’t recommend opening these in a non-private session lest one wishes to plague their recommendations with entrepreneur slop). I don’t think this was a response to shifting language, but rather the source of the language shift. when the words used to describe a thing are imbued in the interfaces one uses to interact with the creation of a thing, the new language shadows the original words.

youtube used “youtuber” in october 2020, yet “creators” that produced “exceptional content” in 2024. of course, they’ve always kinda used “content” if you ctrl+f hard enough, but I feel like we, as beings in the world, thought of it as “corporate speak” that we shouldn’t adopt

and yet we did

it sucks though

creatures make things. living things with sentience make things. they make videos, books, posts, blogs, art, music, whatever. it’s a creative process, one that laborious hours, days, weeks, maybe months, and maybe years are put into. by calling the things we create “content”, we lose that creative process. it shifts the focus of art from the process—the creative juices and work put into an art piece—to the result. the thing to be Consumed, by Consumers, as part of the Content Market, where likes are power and money’s the end all be all of whatever you create.

by calling things “content”, we implicitly support this dynamic. the dynamic of corporations controlling the art we create, reducing it to views, likes, and followers. we implicitly shift our mind to the false idea that the end result is the sole part of creation that matters. not relaxation, not allowing our creative mind to flow, not for the simple self-fulfillment of pursuing an idea. what matters is that your Followers get the Content that they want, and your enjoyment of creation should be put on the sideline for them

this “creator economy” is fueled by malice. we constantly butt heads with others and put ourselves down over the most menial things—“this art isn’t worth $5000”, “you shouldn’t be gatekeeping information”, “why did this get 1000 likes, but my serious work only gets 50?”. these problems have always existed—I’m not saying they’re new by any means—but it kinda feels more. I dunno. harsh now. meaningful? by stealing away followers and likes, ruining the “economy” brought on by the Gods above, who can make whatever changes they want for whatever reason? yeah. it’s hard to describe.

it’s a stupid dilemma of “artists need to make money because our shitty society doesn’t have UBI” and “art should be for the artist’s sake, not for anyone else’s”. the 2nd breaks down because the 1st is true. when artists need to create art to survive, they’re not creating for their own sake, but rather for the sake of others, wherein likes bring in ad revenue and adopts and sticker sales and t-shirt sales and what have you. all for the benefit of the corporations running the “platforms” we use.

society is a mess.

am I alone?

I’ve only seen one person blog about this and one other person make a reddit post about it. maybe there’s more laments across microblogging sites or youtube videos or private MUCs, but not many people are saying it outright

so, I dunno, be loud about it. call the things your favorite artists make art. your favorite documentarians’ videos documentaries. your favorite blogger’s blog posts… blog posts. books, novels, short stories, audio, music, sound design, gadgets, doodads, doohickeys, whatever. the more people stop using that corporatized, demeaning, way-too-general word, the better in my books

just stop saying it

I’m not saying ban it all together, of course. that’d be awkward. “table of contents” is a pretty established phrase I’d say, and trying to change that due to the actions of corporatespeak isn’t quite the battle we should be fighting. content is still a perfectly fine word when used to describe… the contents of something. “the content of the video”, “the content of this post”—there’s no better word for that kind of thing. I’m just saying to not use the word to describe the thing that some being made itself

I propose a split of the word—capital-C Content and lowercase-c content. reserve Content for the youtube trending tab. reserve Content for the seo-optimized slop that plagues a googler’s front page. reserve Content as an insult, not as the default. make Content Creator an insult to those making Content for the sole purpose of gaming something—living off our attention, and not for their own sake. then reserve the words identifying the thing created for the living beings. the artists. the documentarians. the bloggers. all the like. an artist makes art—or music, sometimes; a blogger builds a blog; a documentarian makes documentaries; an essayist makes opinion pieces, video essays, whatever it may be. just, not “content”. lowercase-c content shall be used when appropriate, of course. the content of this blog post supports that claim

thanks for reading. more text-focused content on the way. be sure to Follow and Like each post, as that’s obviously what matters the most

music on my mind

2024-06-04T16:20:13Z

I recently created a topster for myself. I don’t usually do these kinds of things, but I restricted it strictly to music that I downloaded and was released in 2024. here’s that topster:

I’m not going to bother listing out all of what’s on here—I feel like doing so would just result in a glob of music that people would just skim over without much thought into it. instead, I think I want to make it an occasional thing to post about music that’s particularly on my mind, which I feel more accurately represents what is my current earworm. in any case, here’s the music on my mind right now

leumas - bloom

I’m sure this quote from someone I showed this to sums this up quite nicely:

[20:44] Yuri Lowendtheory: wow this is the least intense dariacore ive ever heard

this album treads a fine line between “plunderphonics” and “uh, mashcore? dariacore?”. those words probably mean nothing to most people reading this, so I’ll just try to describe what I like about it. it’s almost like a sample collage, but rather than going down the likes of incoherent random darts and more confusion than music, everything flows into each other in a very… laid back way. if you’ve listened to dariacore by leroy, you’d see what I mean by the distinction of this album. it oddly feels like an album I can chill too—I’m actually listening to it while writing this post, lmao. definitely one of my favorite albums released this year, and probably up there with my top-tier albums ever. definitely looking at this artist some more

favorite track: timeshare. the segment from 0:40 to 1:10 is so… dreamy? I love how they layered the vocals with the instrumental—it’s a perfect fit

tdstr - 7 Grand Dance

a spiritual successor to internet brainrot, this album is (very nearly) entirely in 7/4 time signature, just like good ol’ vsnares. unlike vsnares, however, we aren’t stopping at silly little “breakcore”—we’re going beyond the percussion and embracing the samples of cyberspace. good fucking shit right here. music nerds and internet nerds unite

favorite track: don’t tell me. kicks to make you spasm

under.net - under.net compilation vol.1

I first heard of beansclub when I was randomly scrolling through bandcamp one day with the tag “sextrance” and came across his bootleg comp vol. 1. ever since then I’ve been following his musical journey, and I feel the culmination of what he and his copatriots have made in this one compilation album has resulted in one of the best trance albums ever. it’s not all “pure trance”—LGBT for example leans elsewhere—but damn does it never sound boring. synths are repetitive enough to be trancy but not repetitive enough to be boring. the perfect mix. get lost in this one

favorite track: this one’s really tough. I mean, rl1805 - LGBT is one of the catchiest songs I’ve ever listened to, but beansclub - hanshin feels like I’m going to a different realm of existence. so probably both

wawawa - plastic symphonies: the evidence I was here

I’ve been trying to find someone who encapsulates all venetian snares. I’ve never been able to find that perfect sound that hits the mark—not to say that people who diverge from his classic works are bad, but I just want… more. then wawawa came along. this album feels like you could tack all the tracks into Rossz Csillag Alatt Született and nobody would be able to tell what tracks vsnares made and what tracks wawawa made. and that’s not to say it’s a “bland copy”. everything about it is perfect. wawawa gives their own flair to their work, reminiscent of I guess… nostalgia? it sounds like what vsnares is meant to sound like in 2024. an excellent pick. glad I follow wawawa

favorite track: plastic symphony. I mean, it’s the title track. why not go all out on it?

ハヤトムラカミ - 糸波

and now for something completely different. this album is unlike any other piece of ambient work I’ve heard. one of the tracks appears on a different compilation album, but this is the one complete work of all four of them. it feels like I’m dying. but. not really. it feels like I’m leaving for a brief moment, taken on a 30-minute journey to explore the clouds while everything else disappears around me. a sense of being in a dream, yet also more than enough sounds to ground me in the present—to not lose focus. I listen to this when I want to escape for a bit. just lie my head down and get lost in the atmosphere it creates. I hold this one dear to me

favorite track: 糸波Ⅳ. a brief visit to a cosmological cafe, near the end of the journey, where voices bustle and slowly you get ushered down to the world of the living. gives me chills when listening to it, and that’s something music almost never does to me

so. that’s the music on my mind. until next time

buying some microns

2024-05-04T08:23:00Z

I’m buying some pigma microns. just an 8-pack of 0.05mm ones. I already had a 6-pack of ones ranging from like 0.005mm to 0.1mm, but they’re quite old and I want to draw more, so that one pack isn’t going to cut it

I’ve always been in a little cycle of “wanting to draw” to “never drawing for months”. it’s not really a motivational “my art sucks” kinda way, moreso just getting bored. but I’d rather disconnect from everything for a bit and. draw. I guess

I’ve always randomly sketched, studied, and gesture drew, but I’ve never properly learned fundamentals. I still chicken-scratch not out of style choice, but out of habit. I’m gonna try out drawabox‘s tutorials and exercises. some hours of the day—mostly during free time—will be dedicated. hopefully every day, minus the time when I’ll be at fwa, of course. maybe I’ll start after fwa? I dunno.

one day I hope to look back at this blog post and smile at how it was the start of honing a skill I enjoy doing. maybe I should do this for more things