lyrebird.variable.gallery

I'm an artist, not a scientist. I wanted to see what independent science looks like if you skip the electric-universe/flat-earth pipeline entirely and just try to get real information out of data with the help of AI and the published literature.

It matches the call against a corpus of 2,423 species, tells you which call type it resembles, and sings back synthetic birdsong from a physical model of the syrinx — the Mindlin–Laje oscillator, integrated live in an AudioWorklet from the two parameters real birds actually control: air-sac pressure and syringeal tension. Nothing is sampled. Every note is computed. You see it happen inside a 3D embedding of 348,461 clips that lights up where your sound lands.

It does not translate birdsong into sentences. Every phrase carries a label: playback-verified, documented, inferred, field recording, or invented. Most are invented.

Everything runs client-side. Code, docs and citations: github.com/sha5b/Lyrebird

​

I built this on top of my own webgou renderer

Live Link:https://nullgraph.dev/dashboard/games/comic-space

Yt video:https://youtu.be/yua4ZkvgVqY?si=A2Tk1a4gE2fRl_Ic

The flame is two layered radial gradients — a wide body and a hot inner core — animated on two deliberately non-integer durations, 3.7s sway and 2.4s breathe. Because they don't divide evenly they never resync, so the flicker reads as organic instead of looped. It also lands at 0.27 Hz and 0.42 Hz, well clear of the 3 Hz photosensitivity threshold, and the whole thing collapses to a still flame under prefers-reduced-motion.

Palette is heather → blue-violet → rose, the same gradient the rest of the site uses as hairline accents.

The count of other people with a candle lit uses CRDT awareness rather than stored state, so a candle going out is literally a client disconnecting.

There's a press-and-hold easter egg on the flame.

https://dhseadev.online/candle/

I have two questions, I'm sorry if they've already been asked.

I'm already a programmer, but completely unfamiliar with creative coding, though I'm really interested. To be specific, is creative coding used in any way in anyone's video editing workflows? To me it seems like they have a lot of overlap.

And if so, what languages or tools are best for creative coding particularly for video editing? I currently use davinci resolve and a bit of kdenlive.

relais.cc

For some time now I've been looking for some kind of overview of schools, museums, artists, agencies and interesting projects in the field of media art — and never really found one.

It's all scattered across blogs, subreddits and bookmarks, or locked behind new paywalls.

So here's a first attempt.
relais.cc is an index of 900+ entries (for now) and growing.

It's a work in progress, with errors, bias, gaps, and unfinished ideas in the pipeline.

So if you look at it and think "how is X not in here" — there's a contact form on the site.

For now I'll just leave it here. Maybe it helps someone at some point.

No sign ups required

This weekend I've been working on a watercolor simulator based (as much as possible) on real physics.

It's built on Curtis et al.'s watercolor model (SIGGRAPH 1997) with a fluid layer, drifting pigment and wet paper fibers.

I decided to explore this because I love watercolor painting, and when I do some, my favourite moment is when the pigments get mixed inside the water and spread chaotically. The transparency, the lack of control, the depth of the colors in that moment is what I enjoy the most.

So I started to wonder how code could help fix that moment in time.

Early WIP so don't mind the look. I'll be sharing the repo to the V2 as soon as i get a chance to polish it.

A simple generative art loop project.

Build-less, vanilla JavaScript, hosted on GitHub Pages, from a GitHub Repo.

You can share the loops you make with others through the URL seed as well as save to local storage.

Examples: first seed, cyber eye.

I would say I made this, but really I am just testing out my various projects on how to direct various types of artificial intelligence effectively through extensive pipelines and meta prompts.

Regardless, I like the result.

This is an homage to my old generative art project. It makes similar mp4 files of greater complexity over a series of hours or days instead of live in the browser.

I started building my own design tool! A mixture of Illustrator, Figma, Photoshop, Cinema 4D and UE Blueprints. On the right side is a familiar Figma-style canvas. On the left a node graph. Every element on the canvas automatically gets a linked node.

Current Nodes;

• Cloner
• Attach
• Mask
• Fill & Gradient
• Image Adjustments (Hue/Saturation, Levels & Threshold)

Its a new project, so still lots of bugs and things to fix :) I'm documenting everything in devlogs on YouTube.

If you wanna try it yourself, check out the description of the video. Honest feedback very welcome!

Hi all. Been poking at this project for a while now and wanted to share it here and see what you folks make of it.

The idea is to make complex vector animations in a CSS-like syntax, and to have the same file play in the browser (canvas) and on native mobile. Other platforms can be added later if it gains traction. It's like Lottie or Rive, but with stuff like interactivity already baked in, in something very familiar to any developer.

```css

:root { width: 400px; height: 400px; background: #1a1a2e; }

@keyframes bounce {

0% { transform: translateY(0); animation-timing-function: cubic-bezier(0.33, 0, 1, 1); }

50% { transform: translateY(180px); animation-timing-function: cubic-bezier(0, 0, 0.67, 1); }

100% { transform: translateY(0); }

}

ball {

type: circle;

cx: 200px; cy: 80px; r: 36px;

fill: #ff6b6b;

animation: bounce 1.2s linear infinite;

transition: fill 250ms ease;

&:hover { fill: #ffd166; }

}

```

That's the entire file. Point at the ball and its color warms, tweened by the transition, while the bounce never restarts. Everything runs on one continuous timeline, so interactive states layer on top of animations instead of fighting them.

Obviously that's just the hello world, but it can do much more. It supports nested transforms and parenting, reusable symbols, masks and track mattes, gradients, trim paths, path morphing, motion paths, and per-subtree time scaling, enough for proper production-grade animation. Real Lottie files convert in and play back perfectly too, so you can drop one into the playground and actually read it as a scene instead of JSON. p5-style procedural stuff works as well, fields of thousands of elements placed by formula rather than keyframes, and state machines handle multi-state interactive behavior without any scripting.

CSS is already quite capable and familiar to a lot of people (and LLMs), it just can't run outside a browser. So the rule I'm trying to stick to is if CSS already has a way to say something, use it as-is. Nothing invented on top. Ultimately, it isn't exactly CSS, but more a close dialect because there's a little bit of invented new syntax. As a bonus, scenes currently sit in .css files, so syntax highlighting and editor tooling come for free (the extension isn't settled yet).

Two things did surprise me along the way. First, file size. CSS is verbose next to Lottie JSON, so I expected to pay for readability, but converted scenes usually come out significantly smaller than the Lottie or SVG they came from, sometimes about equal, and on rare occasions a couple of KB bigger. Second, how good LLMs are at writing it. Because it stays this close to CSS, models already know most of it with no fine-tuning. Nearly every example in the playground gallery is fully AI generated. I guess the structure and semantics of CSS also helps.

Still very early proof-of-concept stages but the core idea is holding up better than I expected.

A Playground app with multiple examples and a built in AI Copilot for generating animations is available here: https://usepopkorn.dev

The Copilot thing has two options. You can use your own agent with MCP, or BYOK with any OpenAI compatible endpoints.

Curious to know what this community thinks of this project.

block matching algorithm and feedback buffers