← Back to blog
GeneralAbout 6 min read

244 Pixel Effects, One File Each, and a Skill That Writes More

Published Nov 10, 2026
244 Pixel Effects, One File Each, and a Skill That Writes More

There are 244 effects in pixelfx. A campfire. A burning skull. A waterfall. A portal. A tornado. An EMP blast, a frost nova, a coin spin, a CRT-off transition, a school of fish. Each one is a small file in src/fx/<category>/<name>.js, and each one is a few lines of code that draw pixels into a grid.

That is the whole pitch, and it is a strange one to see near the top of GitHub's trending list in a month when every other repository is a wrapper around a frontier model. No weights. No API. No token bill. Just 244 small programs and a gallery you can open in a browser tab.

The repository is patch-gg/pixelfx, and it credits its method to Hugo Duprez's essay on making pixel-art effects with Claude. The line from that essay that the README repeats is the important one: code is clay, trust your eyes, feed your references. Sprite Fusion's open-source effects set the bar; a couple of the core simulation files here adapt that code and say so at the top.

Why pixel art is a good test bed

At 32 by 32 pixels there is nowhere to hide. A bad fire effect does not look "slightly off" — it looks like orange noise. A badly timed explosion does not feel a bit flat, it reads as a shape that appears and disappears. The constraints are so tight that quality becomes legible at a glance, which makes it one of the few visual domains where you can review a hundred candidates in an afternoon.

That is also why the effects can be code. A fire effect is not a rendered image; it is a rule for how heat, color and decay propagate through a cell grid. Change the decay constant and you get a different fire. Change the palette and you get a different world. The output is a function of the rules, so the rules are the artifact.

A dark room lit by a monitor showing a grid of pixel-art sprite animations

The part that made me look twice

Every effect involving a character is acted out. The character winds up, lets go, freezes on contact, recovers. A target takes the hit. Twelve complete moves chain the effects into attacks that run from wind-up to recovery, which means the library is not a pile of isolated sparkles but a small animation system with anticipation, contact and follow-through.

That is animation craft, not generation. Anticipation and recovery are the two things beginners cut first and the two things that make a hit feel like it landed. Encoding them in a shared timing model, so any effect can be dropped into a move without re-timing it, is the sort of decision that only comes from someone who has shipped a game.

The skill is the interesting bet

There is a Claude Code skill in the repo. Its job is to make new effects the way a picky pixel artist would: draft, render, look, refine. Not "generate 50 effects and pick the best one." Draft one, render it, look at it, change one thing, render again.

That loop sounds obvious, and it is the opposite of how most people use image models. The default behavior is to prompt once, get four options, and accept the least embarrassing one. The skill encodes the opposite discipline, and it can do that because the thing being generated is code — a diff you can read, a constant you can change, a file that either runs or throws.

This is the practical advantage nobody talks about. Generated images are hard to review. Generated code is easy to review, at least for effects this small. You can diff yesterday's campfire against today's and see that the decay went from 0.92 to 0.88. You cannot diff two PNGs of a person and say much beyond "this one's face is worse."

What you get on day one

The gallery plays every effect live, which is the right demo. You can recolor and mirror. You can export sprite sheets for any engine, which is the actual production path for most indie teams — nobody is going to integrate a JavaScript simulator into Unity, but everyone can import a strip of PNGs.

The categories cover the usual needs: fire, water, ice, lightning, explosions, impacts, projectiles, melee, holy, shadow, arcane, nature, weather, UI, pickups, transitions, critters, status effects, spawn and death. Sci-fi gets its own set — force fields, holograms, glitch, jetpack. There is also a publishing path to patch, which tells you where the authors think this is going: a marketplace of small, remixable effects rather than a single monolithic library.

The gaps are honest. Three hundred and fifty effects would be a lie; 244 is a number someone counted. Some categories are thinner than others. The visual style is committed — this is chunky, high-contrast, saturated pixel art, and if your game looks like a muted watercolor, none of it will fit without a palette pass.

Making your own is the intended path

The README does not treat the 244 as a finished catalog. It treats them as worked examples of a method: read a reference, describe the motion in plain language, write a small simulator, render a preview, look at it, change one number. The skill exists so that this loop can be run by an agent under supervision instead of by a person with an afternoon to spare.

That is a genuinely different posture from most AI art repositories, which present a fixed output and invite you to prompt around it. Here the invitation is to edit the source. You want a fire that spreads left instead of up? That is a vector in a file. You want the explosion to hold one extra frame before dissolving? That is a constant. The library is small enough to read, which means it is small enough to correct.

It also means the failure mode is legible. If an effect looks wrong, there is a file to open and a line to blame. Compare that to the usual experience of a generated asset that looks wrong in a way nobody can name, fix, or even describe to the model that made it.

The larger point

For a year the argument about AI and creative work has been stuck on replacement. Can it draw a hand. Can it keep a character consistent. Can it write a shader. pixelfx sidesteps the argument by picking a domain where the answer has to be verifiable. Either the animation reads as a hit or it does not. Either the file runs or it does not. There is no "it depends on the prompt."

And what it demonstrates is not that AI can make art. It is that a library of 244 tiny, inspectable, editable programs is more useful to a working developer than one impressive generated clip. The clip impresses a client. The library ships a game.

That is a boring conclusion, and it is also the one that tends to survive contact with a deadline.

Related articles