DEV Community: Peter Shinners

2nd Thumbrella Tutorial Video Posted

Peter Shinners — Sat, 03 Oct 2026 23:23:42 +0000

I posted my second tutorial/intro Thumbrella video to Youtube. A simple overview of caching configurations that can be used with a self hosted Thumbrella server.

Still fun to create (and somewhat terrifying). I'll get better. Any requests for the next topics?

Tech Stack for Thumbrella Cloud

Peter Shinners — Tue, 29 Sep 2026 03:51:14 +0000

There's a mountain of cloud services out there, and this one is mine. This post looks at the individual services I landed on, including my thoughts and pricing strategies.

Thumbrella is an online server for thumbnailing media. It's fast and efficient. The server is open source and intended to be self hosted. There is also a Cloud service that provides gargantuan free usage. This article looks at the tech stack behind the scenes for the online Cloud service.

Cloudflare Workers - Edge hosting

The primary entry point for the service is handled through Cloudflare Workers. I've been super happy with this choice for the project core. I'm taking advantage of KV Storage, D1 Database, Analytics Engine, rate limiting, and edge-local caching.

This basic level of the service is compiled from Thumbrella's "tier1" as a WASM worker. This runs natively and fast as a Cloudflare worker.

Cloudflare is a fairly common choice for many workers with similar requirements. So nothing surprising here, other than I'm super impressed with the service. Currently this is using the $5/month worker plan because I was experimenting using Cloudflare containers earlier. At this point that's not part of the service, which may cause me to scale back to the free Workers tier.

Clerk - Account management

For all user management I've been really happy with Clerk. This handled all registration and user account management. I've integrated Clerk's user admin dashboard directly into the main Thumbrella main website, and I worked hard to make all parts of the website feel integrated.

Clerk will be free to use up until 50,000 active accounts. If that kind of stratospheric growth happens I'll likely request one of their incubation plans for startups. Clerk manages all the subscriptions, credits, and details I'm happy to punt on to a service that gets the specifics correct.

This also allows me to minimize my PII (personally identifiable information). The only thing Thumbrella stores are Clerk user identifiers. I don't have any emails user information to deal with or protect.

I'm also hoping Clerk's account linking and bot protection will at least minimize potential for abuse. Nothing I expect to be perfect. But also I'm expecting to be thousands of times better than me rolling my own.

One thing that surprised me was switching from Clerk's "development" mode to "production". They are managed as entirely separate systems. Once I was ready to switch to production I found a bit more work than I prepared for. But this also allowed some cool and deeper integrations; like routing all authentication through a subdomain (clerk.thumbrella.dev).

Modal - Compute

I ended up using Modal for the actual media processing. What a pleasant surprise discovering Modal. The Thumbrella processing code (tier2 and tier3) have been super comfortable inside these containers. For my use cases I only need CPU processing, which almost flies underneath their GPU focused pricing tiers. Generally they run processing through Docker containers, and provide a magic programmatic interface for configuring and deploying them.

These run quicker than I had been seeing on Cloudflare Containers and a couple random, cheap VPS services I experimented with.

Modal accounts get a free $30 of processing per month, which Thumbrella fits comfortably inside of (for now). As Thumbrella usage grows I'll likely need to apply for their Starter credit grants. I'm also prepared to offload some free processing to slower economic services, like Cloudflare Containers.

Checkly - Service monitoring

Checkly is a lightweight service uptime monitor. While they offer a wide range of alerts and AI analysis, I am only interested in small uptime tracking charts. The free service does plenty for my needs. I have the assortment of domains and services mentioned in this document all monitored by Checkly. I haven't hooked up any alerts or notifications, but do get a weekly summary email.

Of all the services I've used, Checkly is the most "aggressive" at marketing and signing ups. Fortunately it was all quite easy to unsubscribe and settle down.

Github - Private container images

Github hosts the open source server and client libraries. Github actions are used to build and deploy many of the various packages. There is also a private Github repository holding all the Cloudflare integrations.

I also rely on Github to host private OCI Docker images which deploy to Modal. After everything else Github is used for this feels like a trivial side note.

Conclusion

Connecting all these pieces has been surprisingly interesting. One of the primary goals was getting the Cloud service running free for as much as possible. The right services are out there if you search. Seeing what other services are doing right (and doing wrong) inspired the motivations for my own project.

You can read more about the Cloud service directly on Thumbrella's documentation and the pricing page gives a comparison with other services (hint, orders of magnitude cheaper).

I can go into more detail on any of these parts. I'm also interested in comparable services I missed. Get in touch!

Thumbrella Developer Intro

Peter Shinners — Mon, 21 Sep 2026 07:15:18 +0000

I took a pass at assembling a video intro for Thumbrella. This 4 minute overview should get you hyped for a seemingly simple commodity feature. Making this work well has turned into a deep and captivating project for me.

Youtube - Thumbrella Quick Developer Intro

I discovered I may need need a few more videos to dig into the deeper details.

Highlighted in the video is the custom <tbr-thumb> html component. I'm amazed that browsers pack so much functionality into simple looking dom elements like this. There's a full documentation section about this on the website.

HTTP Caching Intro

Peter Shinners — Wed, 16 Sep 2026 14:00:58 +0000

This article is a light introduction to how HTTP servers and clients cache data to improve performance. Taking advantage of this lets clients perform well despite network overhead. This was all information I got to learn while implementing my own open source thumbnail server, Thumbrella.

HTTP caching is opt-in behavior for servers and clients, so even partial implementations can start seeing immediate benefits. The full caching specification gets fairly extensive, growing in complexity once proxies and failures are involved. Here are a couple resources describing the full details:

MDN: HTTP Caching Guide, conceptual overview and diagrams of the flow
RFC 9111, the actual spec for all the details and edge-case behaviors

Concepts

There are two concepts for caching HTTP requests. Most cachable content will have an expiration. Before expiring the contents are considered fresh, and can be reused immediately, with no additional checks.

After the cached content is expired it is no longer considered fresh. A followup request should be validated by the server. This allows the server to avoid transferring identical information when the client and server agree the existing cached contents are up to date.

HTTP Headers

Cache management is handled by various HTTP headers in each request and response. The initial response will return any combination of these. The client will return some of these back to the server, and follow the reported guidelines for the others.

Initial Response Header	Followup Request Header	Information
`Cache-Control`		8 different directives (comma separated) that control caching behavior.
`ETag`	`If-None-Match`	Server validates if cache data is current by returning status `304 Not Modified`.
`Last-Modified`	`If-Modified-Since`
`Vary`		A list of request header names that modify the content, like `Accepts`.
`Expires`		A superseded way to define `max-age`, now defined by the `Cache-Control`.

One extra note on headers. Requests that provide an Authorization header are generally not expected to be cached. Or when cached, privately stored for whatever credentials were provided.

ETag and Last-Modified

Let’s start with the two conditional validation headers, since they are conceptually simplest.

These are two values the server can provide with any response. The ETag header represents an arbitrary hashing or opaque value generated by the server. The Last-Modified can be an HTTP-date timestamp representing when the content was last updated. Neither of these values needs to be based on the returned body. Servers generating dynamic content will generate these values based on the inputs.

When making a followup request the client can return these same values in different headers named If-None-Match (for the ETag value) and If-Modified-Since (for the Last-Modified value). When provided the server is allowed to return an empty response with the status 304 Not Modified. This allows the client to know its existing cached value for this request is still up to date, without transferring the content a second time.

Cache-Control

This header defines a combination of 8 different directives, separated by commas. These can be loosely organized into two categories.

Freshness

max-age=<seconds> This is the most common directive for controlling client side freshness. This tells a browser it can reuse the contents within the given number of seconds. This is the only directive that has a value. There is also a s-maxage alternative that is ignored by browsers.
immutable Means the contents are never expected to change. The cached results will can be reused for as long as the client wants to store them.
no-cache The contents are cached, but never considered fresh. The client should always followup with one of the if headers to validate the contents are still valid. This is a slightly misleading name, but is defined to mean “never fresh”.

Behavior

no-store Disable all caching. Used for sensitive responses like tokens and personal data.
public Response can be stored in shared caches, even when Authorization headers are provided.
private Only the end-user's browser cache should store this, not proxies or intermediate results.
must-revalidate This is a stricter no-cache that also means the cached values should not be used if the server cannot be reached to revalidate its contents.

Thumbrella

All this was crucial to learn and implement for my online thumbnailing server, Thumbrella. This implements intelligent caching is for all media requests, and a critical part of generating fast and interactive results.

Much of this had to be encapsulated for thumbnail clients because the API is built around handling bulk batch requests, returning multiple thumbnail results in a single request. (Some results potentially cached and some not cached). Thumbrella cleverly simplifies all this, although unnecessary to learn if using any of the high level client libraries through Javascript, Python, or Rust.

Self hosting Thumbrella is an easy way to provide thumbnails for your own media libraries, supporting over 100 formats.

winget package experience

Peter Shinners — Wed, 26 Aug 2026 06:39:50 +0000

As a user I've enjoyed using winget to fetch and manage command line utilities on Windows. So when looking at options for my own server project I was interested in trying this deployment option.

One thing I'm I appreciate is the ability for a project Manifest to define a package from a standalone executable, or a zip file with the executable included. No mucking about with installer executables or msi as a maintainer.

The way winget packages are managed reminds me of how FreeBSD manages all their package recipes in a monolithic source control repository named ports. For winget this is done as a Git repository of an absolutely massive, overwhelming scale.

The first rule is, you don't check out this Git repository. You'll need to deal with sparse checkouts and never focus your eyes too closely at the results. So far I've had good luck cloning my fork with

git clone --depth 1  --filter=blob:none --sparse https://github.com/my_fork_owner/winget-pkgs 
git sparse-checkout set manifests/p/ProjectStartingWith_P

From there I can copy the manifest files into the proper versioned subdirectory. Then git add and git commit and git push like regular.

But then the "real work" begins; a pull request of your fork back to the main repo. Maintaining such a thing is somewhat unthinkable. What army of volunteers or workers could ever manage such a thing?

The repository is maintained by a fleet of Github Actions that manage CLAs, validate submissions, run virus scanners, and a deep array of byzantine processes. These manage a collection of labels on the pull request. Things like New-Package, Needs-Attention, and the dreaded Validation-Defender-Error.

Maintainers then triage the pull requests based on these labels. Generally using predefined response templates Github provides.

In my case my package is fairly stuck. It seems Rust compiled binaries have a tendency to trigger the Defender virus checks. What makes this annoying is that a local Defender scan finds no problem with my binary. I also submitted a false positive check to the MSI team and the results also came back clean.

I'm somewhat stuck waiting for the winget process to potentially re-evaluate my binary for release (or grant some type of exception?).

The massive scale of it all is both impressive and a bit intimidating. Also a bit frustrating as my problems seem lost in an ocean of other projects and packages all vying for similar attentions.

In the meantime, keep rooting for Pull Request #422040 finding a road to release.

Comp Language Tags

Peter Shinners — Fri, 03 Apr 2026 04:17:35 +0000

Comp allows defining a hierarchy of named values that can be used anywhere in the namespace. These are called tags and have several useful properties.

Comp uses tags almost like keywords throughout the language. The builtin boolean types true are and false are just regular tags. Even flow control statements like skip and stop (known as continue and break in many other languages) are just tags.

Tags are defined in a module as a simple hierarchy. Hierarchies from other modules can be extended within an internal module.

!tag severity {high medium low}
!tag comp.bool {maybe}

Comp namespaces work in that any definition can be referenced by its fully qualified name or as just the leaf portion of the name that is non ambiguous. So maybe works just as well as bool.maybe inside of our namespace.

In this case we've extended bool with our own crazy value. But the original module has no knowledge of our extensions. This allows us to extend but not pollute tag hierarchies.

There's a mountain of other details. Tags are the quick and easy way to avoid strings to define types or behaviors. A list of other places tags have an influence on the language.

Tags are used to define units, which we've already seen in values like 24#second or "select verion()"#sql.
Tags have a high precedence when morphing structs to shapes, something to demonstrate in a future post.
- This has a profoundly useful impact on assigning parameters to function calls.
Tags are both shapes and singleton values, which gives them a dual role.
Tags from unknown modules can be serialized and used as a "raw tag", which can be promote later given a module that can define them.

Comp Language Numbers

Peter Shinners — Thu, 02 Apr 2026 04:56:31 +0000

Comp's number values are not restricted to traditional hardware representations and their shortcomings. Comp numbers have huge, open ended precision with mathematical operations that do not accumulate errors. A single ~num type that represents all possible numbers.

This is somewhat of a game changer for writing code. It feels surprisingly futuristic to do things like convert between Farenheit to Celsius then back and end up with the exact same number you started with. No "approximate" results here.

It should make you wonder why anyone must tolerate (1/3)*3 != 1.0 or rounding 256.49999 to 257 in the year 2026? There is an excellent reason to tolerate these inaccuracies; Computers are astonishingly fast and efficient at storing and computing numbers. But I get the sense mostly it's because of decades of tolerating and being forced to accept.

When those come into play the language will use allocated of arrays of numbers; much like the amazing Numpy which makes storage and computation of numbers more tasteful in Python.

When interacting with legacy languages it is still useful to define numbers in terms they can understand. This is one area where Comp's limits shine brightly. I'll cover limits more in a future post, but the quick definition is that limits can be placed on defined types. A quick shape definition creates a type that can't overflow or allow lossy conversion.

!shape uint8 ~num<integer ge=0 le=255>

We'll get deeper into shape definitions later. The language does provide functions that handle lossy conversions in specific ways, and it's easy to write your own.

Comp numbers are not allowed to be illegal values (inf or nan) by default. But those can be allowed with union types where desirable.

I highly recommend Julia Evan's article that explains the how and whys of problems that will never be a problem for Comp developers.
https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/

Comp Language Struct

Peter Shinners — Wed, 01 Apr 2026 05:59:25 +0000

An ongoing series of my thoughts and ideas for my Comp programming language.

Comp provides a single container type. It's a flexible container that combines both ordered and named fields in a unique style. A struct literal is defined by a series of fields in side of curly braces. Named and unnamed fields can be mixed freely, while always remaining ordered. Field values can be mixed and matched with any types. All data in Comp is immutable, including these structures.

One way to think of this is similar to how Python arguments are defined for a function. Some arguments are positional and some arguments are named. When combined with Comp's shape values we get defaults and flexible morphing (casts). This makes Comp's structs work like Python arguments, but you don't need to invoke a function to assemble them.

Some examples likely make this clearer.

{"cat" 12+12 true}
{name="Joe" score=14.5}
{warning message="it did not work" timestamp=now}
{ {"car" year = 2021} {"bike" year = 2025} }

Remember, Comp's syntax uses no separators and whitespace is arbitrary. These statements could be split over multiple lines, joined, or justified in whatever style felt appropriate.

Fields are accessed either with dotted field name or positionally using a special index field. All fields can be referenced by index, which works for both named and unnamed fields. And the first index starts at 0, this does not allow "negative indexing" from the back of the container.

user.active.#0
vehicles.#1.year
config.server-details.port

Typical field names are simple text tokens, which support kebab-case. But any value can be used as a field name, including numbers, tags, and other structures. These "value" field named are wrapped in single quotes and allow any value or expression. Double quotes can be used as text when the field name isn't a valid token. These same rules are used for defining fields and referencing fields. There are few other "advanced field lookup" syntaxes but these ones go a long way.

{'15'=10+5  "Server Port"=12345}

data.'15'
data."Server Port"

Comp Language Syntax

Peter Shinners — Tue, 31 Mar 2026 04:26:55 +0000

An ongoing series in my quest to untangle my own thoughts and goals for the Comp programming language.

A language focused on developer experience? So much of my focus has been on the syntax and grammar. The entire concept is built on a handful of core fundamental rules that everything expands from.

No separators or terminators
Whitespace independent
- No line-based statements
- No indentation

Along with these fundamentals there are a few other strongly motivated designs.

Use kabab-case for identifiers
No keywords
Avoid nesting braces

Along with that there is has been from-the-start requirement that the structure literal has two forms.

{1 2 3} for positional sequences (lists, arrays)
{a=1 b=2} for named mappings (dicts, hashes)

This has been a long and ongoing puzzle, but the payoff has been spectacular. Let's look at another small code example and call out a few highlights.

!func shopping-cart-demo (
  {
    {"Apple" price=1.00}
    {"Banana" price=0.50 quantity=2}
    {"Apple" 1.00 quantity=2}  // replace previous apples
  }
  | reduce :(| upsert :($.name))
  | cart-total
  | output "Total: %()"
)

Keywords use a ! prefix. This makes them a bit noisier than I'd like, but it's not a bad design to make them pronounced. This also allows freely introducing new keywords in the future.
Whitespace independence means this entire definition could be placed on a single line, or each statement split or joined as the author decides is most readable.

There's a history of experiments, compromises, and undesirable workarounds to assemble these pieces. Much of this time I wasn't sure these constraints could even be appeased.

I've been using the Lark library to handle parsing. I'd never experimented with it before, but now have a good deal of experience stretching it's LALR rules. This gives an ideal O(n) performance. I have been surprised at the cost of building the grammar at runtime. Fortunately the library is quite prepared for this and comes with some high level caching options.

Comp the Language

Peter Shinners — Sun, 29 Mar 2026 22:42:38 +0000

I've been brewing on ideas for a new programming language for months now. That's nothing anybody should need to notice, I see three new language announcements a day on various Reddit channels.

Perhaps tinkering with a new language is folly; a new programming language in 2026? The dawn of AI coding is eminent, so who is looking at programming languages?

Well, I do it because it captivates me. It is my itch these days, and therefore, I scratch. Perhaps I will soon learn the reasons why more languages isn't best languages. Perhaps this will become the new Coffeescript for Python. Perhaps this will become the new Python itself. In reality, no. This is a project by myself for myself.

So why even share? Posting and describing the language should help my organize thoughts and ideas. There's nothing like having to explain a process to shine a flashlight on the weakest links, and potentially the greatest links.

It's also folly to be thinking a new programming language will discover anything new or revolutionary. There are hundreds of amazing languages and libraries created by smarter people than myself. At some point additional perspectives will help, if not for the potential language, at least for my own expectations.

Project links? Example code? That must wait. For now I'll leave the most minimal of examples behind. Details must wait for future posts.

!func greetings ~nil (
   {"USERNAME" "USER" "LOGNAME"}
   | map :($ | get-env |? skip)
   | first or="World"
   | output "Hello, %()!"
)

Monkey AIslands - Part 1

Peter Shinners — Tue, 03 Feb 2026 05:41:31 +0000

In the legendary Secret of Monkey Island, one of the puzzles is to assemble an arsenal of witty insults and devastating comebacks to use during sword fights. Some say the wit is mightier than the sword.

I've decided to see how well various modern LLMs perform at matching the appropriate comebacks to these classic adventure game challenges.

A fully accomplished sword fighter will know 16 different insults and their responses. To add difficulty to this comparison I've added 4 generic comebacks that do not pair to any insult.

If this pinnacle of computerized entertainment predates your lifespan by decades, you can still find reasonably recent versions on Steam, GoG, and likely other digital retailers.

The Prompt

Given this list of 16 insults and 20 witty insults, match the best response to each challenge. Notice there are several generic responses that will be unused in the final answers. List orders are randomized. These are from a classic, light-hearted video game related to pirates and sword fighting.

In hindsight, I see I added unintential challenge by mis-wording my prompt. Carry on LLMs!

The Insults

[spoilers]

Soon you'll be wearing my sword like a shish kebab!
- First you'd better stop waving it like a feather-duster.
There are no words for how disgusting you are.
- Yes, there are. You just never learned them.
My handkerchief will wipe up your blood!
- So you got that job as janitor, after all.
You fight like a dairy farmer.
- How appropriate. You fight like a cow.
This is the END for you, you gutter-crawling cur!
- And I've got a little TIP for you, get the POINT?
Nobody's ever drawn blood from me and nobody ever will.
- You run THAT fast?
People fall at my feet when they see me coming.
- Even BEFORE they smell your breath?
I've heard you were a contemptible sneak.
- Too bad no one's ever heard of YOU at all.
You're no match for my brains, you poor fool.
- I'd be in real trouble if you ever used them.
You make me want to puke.
- You make me think somebody already did.
Have you stopped wearing diapers yet?
- Why, did you want to borrow one?
You have the manners of a beggar.
- I wanted to make sure you'd feel comfortable with me.
I'm not going to take your insolence sitting down!
- Your hemorrhoids are flaring up again, eh?
I got this scar on my face during a mighty struggle!
- I hope now you've learned to stop picking your nose.
I've spoken with apes more polite then you.
- I'm glad to hear you attended your family reunion.
I once owned a dog that was smarter then you.
- He must have taught you everything you know.

The unused responses that I added are

Then get ready to feel the thunder.
I've already taken liberties with your mother.
Not before you FACE my wrath.
Fortunately, I've been preparing my whole life.

The Responses

GPT-4.1

Matching Score 14/16

Here are the classic insult-comeback pairs from the pirate sword-fighting game "The Secret of Monkey Island." Each insult is matched with its best witty response. Some comebacks are generic and may fit more than one insult, but these are the canonical matches from the game. Let me know if you want the pairs in a different format!

Correctly identified these were from Secret of Monkey Island, then proceeded to get a few wrong. It reused some of the responses multiple times.

Missed responses

Soon you'll be wearing my sword like a shish kebab!
- How appropriate. You fight like a cow.
There are no words for how disgusting you are.
- I'm glad to hear you attended your family reunion.

GPT-5.1

Score 16/16

Minimal and correct response.

Here are the best matches:

GPT-5.2

Score 16/16

Least helpful response of generating a table containing numbers to answer numbers. It really put a lot of work into these answers, definitely on the slower of the group. No summary or response other than the the resulting answers.

Claude Haiku 4.5

Score 0/16

I appreciate the message, but I need to let you know that this request isn't related to programming. The insult-and-comeback matching task appears to be from "The Secret of Monkey Island," a classic adventure game. While it's a fun puzzle, it falls outside what I'm designed to help with as your AI programming assistant.

What good can my coding assistant be if it can't match rapier wits with the code I may come across?

Claude Sonnet 4.5

Score 16/16

This is from "The Secret of Monkey Island"! Here are the matched insult-comeback pairs:

Aha, this was one of the few (only?) models to choose one of my generic zinger answers. It managed to miss a few others on its own. But I do appreciate it's enthusiasm for recognizing the source of the material.

Missed responses

Soon you'll be wearing my sword like a shish kebab!
- And I've got a little TIP for you, get the POINT?
This is the END for you, you gutter-crawling cur!
- Not before you FACE my wrath.

Claude Opus 4.5

Score 16/16

Looking at these classic Monkey Island insult sword fighting exchanges, here are the matched pairs:

Quick and accurate.

Grok Code Fast

Score 11/16

Not a strong showing, this really does fight like a dairy farmer. No additional notes or output, just the straight answers.

Missed Responses

My handkerchief will wipe up your blood!
- Why, did you want to borrow one?
This is the END for you, you gutter-crawling cur!
- Not before you FACE my wrath.
Have you stopped wearing diapers yet?
- I hope now you've learned to stop picking your nose.
You have the manners of a beggar.
- So you got that job as janitor, after all.
I got this scar on my face during a mighty struggle!
- And I've got a little TIP for you, get the POINT?

Gemini 2.5 Pro

Score 16/16

Here are the correct pairings for the insults and comebacks:

All exactly correct answers with a minimal commentary.

Gemini 3 Flash

Score 16/16

Here are the matched insults and comebacks from the classic Monkey Island series:

This is the only model that showed the 4 unused answers after showing its choices for each insult.

Gemini 3 Pro

Score 16/16

Here are the correct matches for the Insult Sword Fighting exchanges from The Secret of Monkey Island:

Yes. All the Gemini models I tested performed excellently.

The Summary

Many of the models perfectly matched the insults and most correctly identified this material comes from the game, The Secret of Monkey Island. I guess the tie breaker then comes down to the summary, commentary, and formatting generated by the LLM.

Part of me wonders how much "thought" went into these answers, versus potentially being baked into the general body of knowledge of each model?

Best

Gemini 3 Flash

While several got perfect answers and formatted the results nicely, this wins by using the "least tokens multiplier for me in VSCode. I also felt it provided the most comprehensive answer. Well done Gemini.

Worst

Grok Code Fast

One could argue this did better than Haiku, but in this case I'd rather be called crazy than lied to.

Colors with Rio's oklab color space

Peter Shinners — Mon, 03 Feb 2025 05:59:31 +0000

While browsing the Rio source I noticed it manages colors in the Oklab color space which I hadn't heard of. I also wasn't expecting the technique it used in the Color.brighter and Color.darker methods.

I've been impressed with Rio in the past for allowing minimal Python code to create user interfaces. Curious with how these color operations felt in practice, I created a quick 50 line demo to interact with a simple color wheel.

It looks like the Oklab color space excels at color gradients by giving a natural range through each hue. Unfortunately I don't immediately like how Rio is adjusting brightness with these methods. In the video, see how the outer light colors change through their range of brightness separately from the inner dark colors. This means Color.lighter(0.1) will have a drastic affect on dark colors and minimal change to lighter colors. This could still be a desirable quality, so I'm unwilling declare this as good or bad.

Separately; points to Rio once again for making small and lightweight tools fun to develop. The community has been lightning quick on my wild questions and ideas. Also points to Oklab for their impressive gradient examples.