This week’s featured collector is Endeji
Endeji is a fan of pfps, especially cute ones. Check it out at lazy.com/endeji
Last week’s poll split the room into two dominant camps. The top answers were “Cycles within cycles” (33%) and “Post-token era” (33%), suggesting many of you expect NFT art to continue—but not in a single, clean “comeback” narrative. One group sees the future as recurring micro-waves (new formats, new platforms, new aesthetics) rather than one big cycle; the other expects the art to survive while the NFT wrapper fades into the background.
Meanwhile, “Mutation, not comeback” (17%) and “Something else” (17%) picked up a meaningful minority, and “Underground → institutional → underground” got 0%—a surprising vote of no confidence in the idea that the scene will keep relocating as it gets gatekept. The overall vibe: fewer people are betting on a single storyline, and more are expecting messy evolution.
Animating Quines for Larva Labs: a behind-the-scenes look at “code that makes art that makes code”
If you like NFTs for the mechanics—not just the market—there’s a genuinely fun behind-the-scenes blog post you should read: “Animating Quines for Larva Labs.” It’s written by the animator/developer Larva Labs pulled in right before they announced Quine, and it’s the rare kind of post that’s both technically juicy and actually readable. The setup is classic crypto serendipity: the author bumps into John Watkinson (half of Larva Labs, alongside Matt Hall) while planning to go independent again, mentions freelancing, and John has an instant “perfect timing” reaction. Turns out Larva Labs is weeks away from launching a new project and needs someone to animate it. There’s also a gut-punch aside that will make any collector wince: the author sat next to Matt and John when they were first building CryptoPunks, got offered some, and declined because they were too busy. An all-time “pain” moment, delivered very casually.
The best part is the way the post explains what Quine actually is without getting lost in the weeds. In Larva Labs’ words, it’s “a generative art project that blurs the line between its code and the art it produces.” On the surface it looks like beautiful, procedurally-generated pixel art—but if you look closer, each piece literally contains embedded code. Extract the code, run it, and it generates the next image in that Quine’s sequence. Then it gets even more collector-brained: every Quine has a “quinity” (3-Quine, 5-Quine, 7-Quine, etc.), which determines how many generations it takes before the sequence loops back to the start. A 3-Quine loops after the third generation, a 5-Quine after the fifth, and so on. And there are two rare types that feel designed to light up anyone who loves onchain lore: Perfect-Quines, which only ever recreate themselves, and Pseudo-Quines, which can generate an effectively infinite sequence without looping. The author admits they went from “intrigued” to “hooked,” which honestly tracks.
Where the story really gets interesting—especially if you’re a creator—is the communication problem Larva Labs is trying to solve. Quine is clever, but clever doesn’t always read in a scroll. Matt and John wanted an animation that could make the generation process instantly legible: show the artwork being “printed,” show the embedded code being “scanned,” show that scanning the code produces the next generation. The author’s day job experience (they’ve animated a lot of SVGs, including at Stripe) makes them a good fit, but the Quines themselves are technical monsters. Each piece is a JavaScript program that outputs an SVG, and those SVGs can be huge—up to 14,400 little square elements plus thousands of text elements for the code inside. If you’ve ever tried to animate heavy SVGs, you know where this is going. They quickly pivot to using HTML canvas for performance, then run a bunch of tests to see what’s feasible: animating every shape individually, animating text transforms, animating grouped layers, testing layered passes. The surprise is that even the “worst case” tests aren’t catastrophic, but you can feel the author choosing the approach that won’t melt laptops.
The creative decisions are the most satisfying part. To explain something abstract, they lean into physical metaphors—printing like an inkjet, or screen-printing with separate color passes. They try a few variations (linear vs eased, single direction vs bidirectional sweeps) and land on a slow, mechanical feel because it builds anticipation and makes the process obvious. Then they realize an important storytelling issue: printing the code and the pixel layers at the same time makes them feel equal, and the code is the whole point. So they change the sequence: print the code first so you can’t miss it, then layer the squares on top, even letting the code invert as the image resolves. It’s a small move that dramatically clarifies what’s special about Quine: there’s real, meaningful code inside the artwork—not decorative “code aesthetic.”
After that comes the “scan” animation, which is basically a clever UI trick. People understand code better when they see it in a familiar environment, so the author introduces a faux code editor and a scanning line that passes over the quine, pulling the embedded code into that editor. It’s simple, but it communicates the key idea: the code is legible, extractable, and actually drives the next output. And when they combine the two sequences—print, scan, generate—the whole thing snaps into place: print the quine, scan the quine, scanning prints the quine. Suddenly a concept that sounds like a math joke becomes visually obvious.
There’s also real-world context that collectors will care about. Larva Labs announced Quine on Art Blocks and auctioned 477 of the 497 pieces, with the sale closing at 7.56 ETH (about $31,000) per Quine. After the auction, Larva Labs came back for an “expanded” version of the animation for Art Basel Miami, where Quine was shown in a gallery format: framed prints, a giant table grid showing all Quines, and a 4K TV playing an eight-and-a-half-minute loop that runs through whole sequences (with quinities ranging from 3 to 11), moves to the next Quine, and loops back to the start. The most delightful nerd detail: the author’s animation system literally extracts the Quine’s embedded code and uses it to generate the next sequence in the animation. It’s not just illustrating recursion—it’s running it. A generator of generators.
If you collect Larva Labs or care about onchain-native generative work, the post will deepen your appreciation for Quine beyond “cool pixels.” If you’re a creator, it’s basically a case study in how to explain a complex mechanism without dumbing it down—use metaphors, make the critical detail impossible to miss, and let the visuals do the teaching. Either way, it’s one of those rare reads that makes you feel the old “early internet” excitement again, minus the noise. I’d recommend reading the original for the performance and animation breakdowns alone—plus, you’ll probably laugh (and wince) at the CryptoPunks anecdote.
Read the full behind-the-scenes blog at Destroy Today.
Poll: What’s your favorite kind of “onchain magic” in NFT art?
We ❤️ Feedback
We would love to hear from you as we continue to build out new features for Lazy! Love the site? Have an idea on how we can improve it? Drop us a line at info@lazy.com