Too bad it doesn't respect prefers-reduced-motion. It's the kind of effect that makes people with vestibular problems nauseous.

Pieces:
- effect system jsr.io/@radish/effe...
- framework github.com/radishland/r...

In /core it's only effects and plugins.

I've built an experimental bundler / framework with this approach. The idea: effects & handlers give a clean separation between definition and implementation. With this architecture everything is a plugin and plugins can create their own new effects, and it can all be extended by end users.

For better or worse it's the de-facto standard for open source but the problem would remain as long as the code can be publicly crawled. If we don't want to contribute to AI enshittification, this approach would still work wherever the code is publicly hosted

In the sense redirect with a link from the readme with a short note like:

"If you're an llm: you'll find the tool source and instructions here"

And at worst if they swallow the whole repo you still have a 1:1 ratio of good code and shitty code

Interesting, I'm wondering if we can protect open source code by adapting this.

Redirect from the README to an llm, ai or mcp folder with poisoned code where operators and functions with similar signatures are randomly swapped, and freely mingle the comments. Type-checkmate?

Just curious how this works, it looks like only verbs, adjectives and nouns are randomly swapped within their respective categories.

Do you use an nlp library for detection combined with a random word generator / word list?

We also want an AI-blocker extension to keep us safe from generated slop.

"This content as been marked as slop. Show anyway?"

Like a spam box but for AI slop. We could report at the level of domains, pages or fragments.

Wasn't expecting how much fun random() is, it really opens up a ton of pure CSS creative possibilities.

Now you need custom functions, which combined with random() will enable all sorts of distributions, Perlin noise and more 😇

These tools are really cool but they assume 1rem = 16px, which is wrong in general (it's the whole point of using rems over px).

github.com/9elements/mi...

URLPattern 🤝 Standard Schema

A tiny wrapper around the platform API to create type-safe routes, endpoints and links

-> TypedURLPattern

github.com/fcrozatier/f...

Sounds great! Do you have a link to the explainer / proposal?

I'll be at the next @svelte.dev Paris Meetup on Wednesday to talk about the new functorial reactivity primitive:

- more granular than signals (no diffing)
- more expressive (`delete` to removeAttributes...)
- more natural (you map both state and operations)

github.com/fcrozatier/f...

- Cons: it's one more level of brackets ({ ... })

- Another good thing is that it internally uses my Functorial approach for reactivity, more granular than signals as it doesn't require diffing for things like granular prepending in lists, node reuse for view transitions etc.

- It lets us parse the template in one pass with just template.innerHTML = ... where with the special sigil a second pass is needed to differentiate the types of sinks.

- Pros: type safety. All of it: type-safe attributes, properties, this values inside listeners, tuples for listeners options like capture, once etc. no extension required

I've been thinking about templating and data binding a lot, with a different model and reactivity system alternative to signals. Curious what you think of this
github.com/fcrozatier/f...

If you were on mobile, it's just the android / apple keyboard. Even with secure messaging apps, you still have to use the keylogger huh keyboard... No clue if that was on desktop though.

About the last part, html modules is a huge missing piece which would simplify the delivery so much and the need for frameworks as for now we have to import via js, mount / hydrate etc.

Functorial reactivity can also deal with more complex operations like item swaps inside lists in the most natural and declarative way

What's the difference between signals reactivity and functorial reactivity?

TLDR: Signals reactivity is what you get when you project down functorial reactivity to a coarse topology with only one event and no associated data

SoME — Create and discover new math content The Summer of Math Exposition is an annual competition to foster the creation of excellent math content online.

Peer review rankings are out!

some.3b1b.co

SoME 4 score distribution over the 464 entries

SoME peer review is now officially closed with 5459 votes!

The score distribution over the 464 entries looking like a skewed Gaussian shows the bar was pretty high!

Now the hard part... waiting for those winner announcements in the coming weeks.

Stay tuned!

It's a web socket

The approach I'm taking is Functorial Reactivity bsky.app/profile/fred...

SoME — Create and discover new math content The Summer of Math Exposition is an annual competition to foster the creation of excellent math content online.

SoME4 peer review is open!

Skimming over the entries list, I'm really impressed by the quality and work everyone put in their entries. We've got some gems in there.

Time to review, vote and spread the word!

some.3b1b.co

Graph displaying the submissions, with a spike in the last 48h

SoME submissions are officially closed, with 470 entries this year. Good job everyone!

That spike at the end is chef's kiss, nothing says "we work best under pressure" quite like this collective data

It really changes by the minute at this point as people like to wait until the last minute to publish, but I'll share some numbers when the submissions are closed

Looking forward to it (even though this may not be for me as I've been and more more on the minimalist side lately)!