← Back to blog
AiAbout 6 min read

244 Pixel Art Effects, Each One a Small Piece of Readable Code

Published Nov 8, 2026
244 Pixel Art Effects, Each One a Small Piece of Readable Code

pixelfx appeared on October 30 and gathered 5,960 stars in about a week. It ships no weights and no API. It ships 244 files, each containing one effect, each short enough to read in a sitting.

Fire, explosions, water, ice, lightning, sci-fi, melee, impacts, projectiles, spawn and death, arcane, holy, shadow, status, nature, weather, UI, pickups, transitions, critters, and twelve whole moves. Every one lives at `src/fx//.js`.

The distribution is deliberate: eleven to thirteen effects per category, never a hundred in one pile and two in another. A library that size is browsable. A library of nine hundred is a search problem.

The method came from somewhere

The README credits it. The approach is Hugo Duprez's, from a post titled "How to make (good) pixel art effects with Claude," and it comes down to three instructions: code is clay, trust your eyes, feed your references.

His open-source effects at Sprite Fusion set the bar, and `src/core/sim.js` in this repository adapts his code with attribution at the top of the files that do. This project is the same idea at library scale, plus a skill to keep it going.

The reason code works as a medium for this is worth stating. A pixel art effect is a small simulation: particles with velocity, gravity and a lifetime, blended onto a canvas at a low resolution and then snapped to a palette. Written as data plus a loop, it is inspectable, tunable and portable. Exported as a sprite sheet, it is a fixed sequence of frames and every parameter is frozen.

Which is why the effects here play live, recolor, mirror, and export. The code is the asset and the sprite sheet is a by-product.

The characters actually act

The detail that separates this from a particle pack is in the second paragraph of the README: every effect involving a character is acted out. It winds up, lets go, freezes on contact and recovers, and the target takes the hit.

Twelve whole moves chain effects into attacks from wind-up to recovery: arrow shot, dash strike, earth stomp, fireball throw, ground pound, holy smite, and six more.

This is animation craft expressed as a data structure. An effect that just plays looks fine in a gallery and wrong in a game, because a game has anticipation and consequence. The wind-up tells the player something is coming. The freeze on contact is the hit registering. The recovery is the permission to act again.

Encoding that as three phases per effect means the library carries timing knowledge as well as frames. It also means the output is compatible with how a game loop actually sequences events, which is the difference between an asset you can use and an asset you have to re-time.

Using one

In a browser game, canvas, Phaser, PixiJS, Kaplay or three.js, the import is direct and there are no dependencies:

import { createFrame, clearFrame, createFx, composite } from "pixelfx";
import * as frostNova from "pixelfx/fx/ice/frost-nova";

Each effect is a module, so a bundler ships only what is imported. That matters more than it sounds: a library you can tree-shake to one frost nova is a library you can put in a jam project without thinking about weight.

The gallery at patch-gg.github.io/pixelfx plays everything at once, and there is a catalog at `docs/CATALOG.md` listing all 244 with categories. For engines that want frames rather than code, sprite sheet export handles it.

The skill, and what "picky" means here

The other half of the repository is a Claude Code skill that makes new effects "the way a picky pixel artist would": draft, render, look, refine.

That loop is the interesting part. The agent writes a candidate effect, renders it, looks at the result, and changes it. The repository supplies the renderer and the gallery that make looking possible, which is the actual precondition. An agent that cannot see its own output can only produce code that compiles.

The method note in the README, trust your eyes and feed your references, is advice for the human as much as the model. The skill works because the feedback loop is visual and tight, not because the model has good taste.

Three ways out of the library

Export is where a code-first library has to prove it is more than a demo. The repository offers the effects as importable modules, as live playback in the gallery with recolour and mirror controls, and as sprite sheets for engines that want frames.

The sprite sheet path is the concession, and it is the one most game teams will use first. A sheet is a fixed sequence: no parameters, no runtime cost, no way to vary a hit flash at the moment of impact. It is also what a non-JavaScript engine needs, and what an artist needs before deciding whether an effect is worth adapting.

Recolour and mirror matter more than they sound for a 244-effect library. A single ice effect recoloured four ways and mirrored twice is eight assets from one file, which is how a small library covers a large game.

Why a library still matters in an agent era

The obvious objection: if an agent can write any effect on demand, why download 244 of them?

Two reasons, both visible in how this repository is structured.

The first is a floor. An agent asked for a fireball will produce a fireball. An agent with 244 reference implementations in front of it, each written to the same conventions with the same phase structure, will produce something that fits the library. Conventions are the expensive part of a shared codebase, and a corpus of consistent examples is how they get transmitted.

The second is that some of the knowledge is not in the prompt. The twelve-move chain with wind-up, contact freeze and recovery is a design decision about game feel. You can describe it in a sentence, but the value is in having it applied 244 times so that every effect obeys the same timing grammar.

That is what a library is: not a pile of assets, a set of decisions already made consistently.

The licence and the shape of the thing

MIT. Authored by patch-gg, adapted in part from Duprez's open-source work with attribution, and honest about which parts are borrowed.

The repository is a week old and it is the kind of project that tends to keep growing, because the skill makes adding effect 245 cheap. If it does grow, the interesting number will not be the star count. It will be whether the 250th effect looks like the first 244, which is the only real test of whether the conventions were transmitted or just the files were copied.

For now the repository is a good answer to a question that comes up whenever someone says code is the new asset format. Here is a case where it plainly is: 244 effects, each a file you can read, each a simulation you can retune, all of it small enough to keep in your head one effect at a time.

Related articles