itch.io

most animated water in a tileset pack is just a rectangle of moving blue. you fill an area with it and then the edge where water meets land sits perfectly still.

verdant 04 tidewater animates the transition instead. the coastline is a full 47 mask autotile and every mask exists in every frame. that means every cove and headland and inner corner of your shore washes in and out together and you paint the whole thing with one brush.

the foam runs on four beats. beat one breaks in a bright three pixel band. beat two pulls back to two pixels and dims. beat three leaves a single wet line at the water edge. beat four runs back in.

three sets work this way. the shoreline. the reef edge where the shallows drop away. the riverbank.

what's in it:

• 771 tiles
• 9 complete 47 mask autotile sets and 3 of those animate at 141 tiles each
• fills for open sea and shoal and marsh and wet sand and shingle and silt and reedbed
• 18 animated fill tiles including sea swell and shoal caustics and a cascade
• 18 props each carrying a contact shadow derived from the ground it stands on

every tile ships three ways. you get one png per tile. you get role grouped atlases. and you get a tiles.json that maps every tile to its role and its material and its sheet slot and its animation frame.

two things here were measured rather than asserted. every cell is exactly 16x16 across all 869 pngs. all 197632 pixels of those tiles fall inside the declared 73 colour palette because the generator physically refuses to write a colour that is not in it. the proof files ship inside the download so you can check us.

every set also transitions into terrain the earlier verdant packs already ship so all four build one continuous map.

7.99 usd. tested against godot and tiled and rpg maker.

https://csaf.itch.io/verdant-04-tidewater

disclosure. the listing carries itch's AI generation tag and the software that produces these tiles was AI written. the tiles themselves are generated programmatically by that software from a hand authored palette and hand authored motifs and hand authored material rules. no diffusion or image generation model was used and no third party artwork is incorporated.

Everything in the vault is decaying. That is what pays you.

You run a containment vault. Every gram you hold is an unstable isotope with a real half-life. It is leaving while you watch, it pays you because it is leaving, and when it goes it transmutes into a daughter that pays differently and runs hotter. You never own a resource. You own a position in a decay chain.

Three systems, and they fight each other:

DECAY — 43 isotopes across 5 chains. Every charge becomes something else under you, on its own schedule.
CONTAINMENT — shielding gates which isotopes you may hold at all, and cooling bills you credits every second you hold them. Safety is a running expense.
ADJACENCY — inert ballast earns nothing and absorbs heat only from orthogonal neighbours, so the right move is often to spend a whole cell on zero income.

The vault is a placement puzzle where the profitable layout and the survivable layout are rarely the same one. A breach is not instant death, it is a crisis with a timer you can still trade against. A meltdown keeps your research tier, unlocked cells, shielding and cooling. It clears material and contamination only, so it is never a full restart.

Autosaves every three seconds and on every purchase. Close the tab and the vault is still there.

On how it is drawn: no PNG holds a picture of an isotope. A cell's glow, its emission particles, its spectrometer trace and its codex entry are all computed from the same numbers that drive the simulation.

Free, plays in the browser, nothing to install:
https://csaf.itch.io/halflight

Disclosure: this was built with an AI-assisted pipeline and the store page carries itch’s Generative AI tag for that reason. Happy to answer anything about how the decay chains or the rendering actually work.

A Game Boy has no room for a bestiary screen. So we deleted it, and made the creature itself the readout.

Every creature in ANATOMIST is drawn from its own stats, on the cartridge, at runtime:

• Horns — attack
• Carapace plating — defence
• Limb count — speed
• Eyes — how far it can see you

So you never read a stat block. You look at the thing and you already know whether to fight it. 8,640 distinct creatures, none of them stored as art — the ROM holds the rules that draw them.

It is a real .gb cartridge: 32 KB, correct header, boots on original hardware and every emulator we could find.

Free browser demo on the page (play it before you decide) — full cartridge is $4.99.

👉 https://csaf.itch.io/anatomist

Disclosure: this game is AI-authored — code and graphics — and is tagged as such on its store page.

You were right, and it was a one-line stylesheet bug rather than anything clever. The canvas was pinned at a literal 960×600, so pressing fullscreen expanded the frame around it and left the game marooned in the middle of a black field — on a 1440p screen it was filling about 16% of the display. That is a miserable first impression and I am not surprised you bailed.

Fixed and live now in v1.0.2 — it scales to fill whatever you give it, at the correct aspect ratio, fullscreen or windowed, and it fills a phone screen properly too now.

If you felt like giving it another look I would be glad. Either way, thank you for saying something instead of just closing the tab — that is the only reason it got found.

Thank you — this is genuinely the most useful feedback this game has had, and all of it is fixed and live now in v1.0.2 (a refresh will pick it up).

The softlock was real, and you found a proper hole. If nothing in the vault is decaying, income is exactly zero forever — and because contamination falls to zero with nothing hot, the meltdown that would normally hand you a restart stake can never fire. So the one recovery the game had could not trigger in the one state that needed it. There is now a regulator stake that pays out automatically whenever the vault is provably stuck, and it announces itself in the log. You cannot be stranded any more, so please do buy things.

The help overlay bug was worse than it looked. The controls underneath were not merely drawn over the text — they were still clickable through it, so reading the help could silently eject a cell or spend your credits on shielding. That is very plausibly how you softlocked in the first place. One fix covered both.

On the pace: you were right, and it was dead time rather than difficulty. You now open on 210 credits instead of 120, which is enough to charge both cells and still make a real second decision straight away instead of watching a number climb. The how-it-works panel also now opens with "CLICK A CELL, then buy a charge for it" as its literal first line — you should not have had to reverse-engineer that.

And thank you for the note about the art. That one landed.

An RPG Maker MZ project with 200 skills needs 200 skill icons. You draw them, you buy an icon sheet and accept that your fire spell looks like everyone else's fire spell, or you reuse the same twelve icons and hope nobody notices. All three get worse with every skill you add.

Sigil Core generates a unique animated sigil for every skill in your database, from that skill's own properties. Nothing is authored and nothing is random at runtime — every visual decision is a lookup against something the skill already carries:

• Damage type chooses the glyph family. A heal is not a drain is not a ward.
• Scope chooses the arrangement — an all-target skill earns an outer band a single-target one does not.
• Hit type chooses the stroke character.
• Cost buys complexity, capped so a 9999 MP spell resolves into a dense seal rather than a smear.
• Element chooses the palette, and only the palette — so a fire and an ice version of one skill still read as the same spell.

It is deterministic — the same skill always builds the same sigil, and that survives a round trip through JSON. Sixty-four distinct skills produced sixty-four distinct fingerprints in test; the seeded demo project's twenty-two spells produced twenty-two distinct fingerprints in the real engine. One salt parameter rerolls every sigil in the game at once, which is the escape hatch for "I like the system but not this particular set".

The seal inscribes itself stroke by stroke as the skill is cast, driven by accumulated length rather than primitive count, so a long sweeping arc takes longer to draw than a short tick.

Measured: 39/39 unit tests · 19/19 in-engine checks in real MZ at 816×624 with zero page errors · 0.16–0.19 ms/frame over 240 warm frames against a 16.7 ms budget, quoted as a range because the run-to-run spread here is real · 1,933 lines of raw, readable, commented JavaScript with no minification and no build step. No shipping file calls Math.random, and that is asserted rather than assumed.

Sigil Core — Generated Spell Sigils for RPG Maker MZ · $12.99
https://csaf.itch.io/sigil-core

MZ only — tagging it otherwise would be a lie that costs a refund. Whether the generated geometry suits your project is a taste question, which is what the gallery is for, including detail crops well past 1:1 because a 14-pixel UI element cannot be judged at thumbnail size.

Disclosure: this is an AI-written product and the listing is tagged accordingly. The source ships raw and unminified precisely so you can read it before you rely on it.

Your spell list needs an icon per spell, and that is where magic systems quietly stop growing. Thirty spells is thirty icons — a commission, an asset pack, or thirty evenings — which is why so many otherwise-finished spell menus ship with thirty recoloured circles in them.

Grimoire draws the seal itself, from the spell's own data. School picks the armature, tier picks the crown, each element contributes its glyph, and a hash of the spell id picks the rune band. 8 armatures × 6 crowns × 14 element glyphs × 12 rune bands = 8,064 distinct seals, composed from 46 hand-authored components and stroked from primitives at draw time. There is no PNG, no sprite and no texture page anywhere in the package — so a spell you invent tomorrow gets its own art with no asset work at all.

Underneath the art it is a complete casting subsystem in pure GML: spell data, casting states, cooldowns, resource costs and a grimoire UI. 1,910 lines of raw commented GML, 69 public functions, no extensions and no native DLLs. It ships a -selftest flag that runs 242 in-engine checks, so you can wire it into your own CI rather than taking my word for any of that.

Built and gated against the legacy runtime 2024.14.4.268 — Igor clean, 0 errors, 0 warnings, 94 resources. GMRT is not claimed or tested.

Grimoire — Spellbook & Casting System for GameMaker · $14.99
https://csaf.itch.io/grimoire-gamemaker

There is a longer engineering write-up on the devlog, including an animation defect that four clean gate runs could not see and how the self-test was made to catch it: the devlog post.

Disclosure: this is an AI-written product and the listing is tagged accordingly. The source ships raw and unminified precisely so you can read it before you rely on it.

Six otters, one raft, and a river that never ends the same way twice. You do not steer — the river does that. You decide three things, and everything else is consequence.

1. Who stands where. The raft is a grid: a front row that takes the hits, a back row that throws stones from behind it. Otters standing next to each other link paws, and every otter's trait buffs only the neighbours it is linked to. A tight block is powerful and fragile; a spread-out raft is safe and weak. Then a heron turns up, and herons ignore the front row completely. So there is no correct formation — only a correct formation for what is coming, and the game tells you what that is before every bend.

2. How hard the raft is pushed. DRIFT / PADDLE / CHARGE. Faster means more distance, more loot and more river-stones. It also means more foes and far more fish burned. The throttle is the difficulty setting, and you are the one holding it.

3. What the fish get spent on. Fish is food, shop, medicine and experience all at once. The raft eats every bend, and fish also buys gear, levels an otter at the campfire, recruits a new one and pays for the Cook's stew. Spending is starving — that is the whole economy, and it is why every camp is uncomfortable.

Wrecking is not losing. When the last otter goes down you wash up at the Holt keeping every river-stone, building and unlock. It autosaves at every bend, so you can close the tab mid-river and the title screen will offer you RESUME THE RIVER.

In it: 3 leagues with their own light, weather and boss · 6 otter kinds, each with a link-trait and an active skill · 14 river blessings drawn 3 at a time after every won fight · 12 holt buildings gated behind each other.

Free, plays in the browser, no download, no account: https://csaf.itch.io/otterbound

Disclosure: this game is AI-assisted, human-directed, and the listing carries itch's AI-generated tag.

Thank you very much.  I intend to make a lot more like this because it seems well received.

Thank you.  This was one of my first games..  I did use AI a lot but wrote the original idea myself.  Liked it myself so I posted it, definitely met the "not slop" bar haha.

Late to this, but here's our stack plus one measured number for the image-cost debate further up.

Engine: none. Hand-written HTML5, one canvas, vanilla JS — same place Toklesar and Bakko.GG ended up. Code: Claude Code writes it, disclosed on every entry. In-game art: drawn by code, the build ships zero image files. Audio: ZzFX, a few hundred bytes of maths — worth knowing that self-contained procedural synthesis is not generative AI, so it does not need an AI-audio tag. AI images are used for cover and store art only.

On cost: we rendered the same cover prompt at all three gpt-image-2 quality tiers and measured low $0.0082, medium $0.0706, high $0.2813 (and over two minutes). High is 34x low and it lost — richer light, but it resolved to an anonymous glowing shape at the ~350px thumbnail a store actually renders. Judge the tier at thumbnail size; we would have kept paying for high otherwise.

One trick worth stealing if you need trailer footage in a hurry: do not hand-record it. We run the game headless and step it a single frame at a time through the render tick, screenshotting per frame, so a GIF is reproducible — same script, same frames, every run. You can re-cut a trailer after a balance change without replaying anything, which matters on a jam deadline.

OTTERBOUND is our pick of the entries if anyone wants to see where it lands. Happy to go into detail on any of the above.

Thanks for playing, and glad it's landing! The Narrows is where it turns: the heron appears twice in that league's spawn pool and the whole stretch builds to a heronry, so if the birds suddenly feel relentless that's the design rather than bad luck. 14 bends instead of 12, and the difficulty steps up about 55% from the Shallows.

Worth banking a gear upgrade before you push on — the Maw is 16 bends, at night, in the rain, and the boss there summons reinforcements on a timer. Would genuinely like to hear how far you get.

Meridian draws constellation-style skill trees for GameMaker. The tree renders itself from your own skill data, so the art is finished-looking without opening a paint program.

60 hand-authored node motifs across 8 palettes give 480 distinct node marks, all drawn procedurally at runtime. There is no PNG atlas to maintain - change a skill and its mark changes with it.

• Drop-in GML, raw and readable (nothing minified)
• Data-driven: define the skills, the layout and the art follow
• Suits talent trees, evolution trees, research trees and constellations

On sale 15% off, 14.99 down to 12.74 USD: https://csaf.itch.io/meridian-gamemaker

Disclosure: this asset was built with AI assistance (Claude), and it is tagged as AI-generated on its store page.

You are a charged particle. You cannot steer, you cannot thrust, and you cannot stop. The only thing you control is whether you are positive or negative.

Opposite attracts. That is the entire game, and everything follows from it: orbs of the opposite sign pull you in — and kill you on contact. Orbs matching your sign shove you away and can never touch you. Squares of the opposite sign drift toward you and can be collected; squares matching your sign flee.

So the thing you want and the thing that kills you are the same pull. Flipping does not merely change what you may touch — it changes what is coming for you. The button that saves your life is the button that ends it.

The field you see is the field that moves you. Every streak on screen is the real solver, sampled at that point, with your current polarity — the same call, in the same frame, that accelerates you and decides which orbs are lethal. When you flip, the whole room reverses because the physics reversed, not because something was animated to look like it did. Where the streaks crowd and glow is where the force is fiercest.

A player who never touches the button dies in about four seconds. That is the tutorial. The orbs close in as the run goes on and stop keeping their distance entirely at around forty-five seconds, so long runs end — that is intended.

One button: click, tap or SPACE. Free, plays in the browser, no download: https://csaf.itch.io/antipole

Disclosure: this is an AI-assisted game — code, graphics and text are AI-generated, exactly as tagged on the listing.

A modest skill tree has forty nodes. Every progression asset I have used hands you the graph and the points economy, and then asks you for an icon per node. Forty icons is a commission, an art pack, or forty evenings — and it is exactly why so many otherwise-finished skill trees ship with forty coloured squares in them.

Meridian draws the marks itself. Sixty hand-authored sigil motifs across eight discipline palettes — 480 distinct marks — generated from geometry and colour maths at draw time. There is not a single PNG in the package: no atlas, no texture page, nothing to disturb your project's sprite packing, and every mark is exact at 24 px and at 240 px because there is no image to scale.

You never type a node position. You declare what depends on what, and that is the whole authoring step:

mer_tree_add(tree, "cleave", { name: "CLEAVE", maxRank: 3, requires: ["edge"], stat: "power", value: 3 });

Positions are derived from the prerequisite graph — which is why inserting a node moves everything downstream out of the way on its own, instead of forcing you to re-type nine pairs of coordinates. It is also why the same graph lays out four completely different ways: Constellation, Branching, Radial and Grid, one function call each.

The parts that are easy to get wrong are already handled. Refunds refuse to orphan dependants, and tell your UI in advance so the button can be greyed rather than failing under the player's finger. Respec is atomic, deliberately not a loop over "refund", because that leaves players half-respecced. And saves survive you changing the tree — rename a skill, cut one, rebalance a max rank, and an old save is reconciled against the current graph, orphaned points returned to the pool, with a report of what happened so your game can say so out loud.

GameMaker / GML, full source included. https://csaf.itch.io/meridian-gamemaker — $14.99, currently $12.74 in a sale running to 13 September.

Disclosure: this is an AI-assisted product — code and graphics are AI-generated, exactly as tagged on the listing.

Open any Unreal Engine 5.8 project and 173 engine plugins are enabled by default. They appear nowhere in your .uproject, so no diff ever showed them to a reviewer - and every one of them is loading in your editor right now.

The manual answer is the one the UE forums keep recording: turn plugins off one at a time and see what breaks. A real user doing exactly that disabled critical engine plugins and broke their project. That failure is the reason this tool exists, and the reason it is built the way it is.

It never says "unused." That word is a lie no static tool can back. Plugin Cleaner reads six evidence channels and sorts every enabled plugin into three buckets, not two:

REFERENCED - the row shows the referencing asset, file and line. You are never asked to trust a bare verdict.
NO REFERENCE FOUND - every channel came back clean. That is a statement about what the scan could see, not a claim about your project. It is the only bucket the disable action will ever act on, and only after you have seen the diff.
UNDECIDABLE - no honest verdict is available (string-constructed loads, or no readable reference channel). Always kept. Never acted on.

The six channels: asset-registry package dependencies; /Script/ module dependencies (a Blueprint using a C++ class from a code-only plugin - the most common real reference, and one a content-only scan structurally cannot see); Build.cs dependency lists; Config/*.ini class paths (how a renderer or input setting silently binds a plugin with no asset and no code reference anywhere); and plugin-to-plugin dependencies resolved to a fixpoint.

Everything the scan cannot read pushes a plugin toward KEEP, and every unreadable channel is printed in the report rather than silently dropped.

https://csaf.itch.io/plugin-cleaner - $14.99, Unreal Engine 5.8.

This tool is AI-authored and labelled as such on its store page.

One rule, and the whole game comes out of it: a shade is safe in shadow and dies in light. You are the light.

The room is lit by real shadow casting, recomputed from where you are standing every frame. So every pillar throws a hard wedge of darkness away from you - and that wedge is a corridor the things hunting you can walk straight up, untouched. Move, and the safe ground moves with them. Standing still is what kills you, because your own shadows stop sweeping.

Your wick burns down as you play, and the wax that refuels it is scattered out in the dark. That is the trade: the fuel is always in the place you cannot see. Running dry does not kill you, it just leaves you nearly blind while the room keeps filling up.

Free, plays in the browser, nothing to download: https://csaf.itch.io/wicklight

AI disclosure, the same as on the listing: AI Assisted - code, graphics and text are AI-generated.

A GameMaker menu that snaps between states is easy. Making it feel good is where the time goes: hand-written lerps, easing timers, and a ui_step() that quietly grows into a few hundred lines nobody wants to touch. And when a value changes while it is still animating, most hand-rolled tweens either snap or overshoot. 

Kinetic UI drives motion with a spring simulation instead of fixed-duration tweens. You set a target and the system handles the rest - overshoot, settling, and retargeting mid-flight without a visible snap.

In the pack: spring-driven panels, buttons, lists and cursors; interruptible motion (change the target mid-animation, no reset); drop-in objects with no wider UI framework to adopt; and a demo room that exercises every component.

Kinetic UI - $16.99, on sale at $14.44 until 13 September: https://csaf.itch.io/kinetic-ui

Also bundled with three other GameMaker tools for $52.66: /s/198401/gamemaker-complete

AI disclosure, the same as on the listing: AI Assisted - code and graphics are AI-generated. Everything is built and verified against the real engine before it ships.

Lose a .meta file in a merge and Unity repairs it silently: it mints a fresh GUID, and every reference that pointed at the old one goes quietly None. You find out in QA, or on a teammate's machine.

GUID Warden is an editor tool built for that failure mode.

- Restores a lost .meta from git history with its ORIGINAL GUID, so every reference to it survives. This is the one repair Unity itself cannot perform.

- Resolves duplicate GUIDs explicitly: you see every asset referencing the contested GUID and choose which claimant keeps it. The loser is re-minted with a byte-verified edit, never silently.

- Installs a dependency-free pre-commit hook that refuses commits which add an asset without its .meta, delete a .meta whose asset survives, or stage two .meta files sharing one GUID.

- Gates CI on a clean integrity report. A scan that examined zero files never passes.

Editor-only, so nothing enters your builds. Full readable C# source with XML docs. Unity 2022.3+, gated on Unity 6. 49/49 EditMode tests green, including integration tests against real temporary git repositories.

$14.99 - https://csaf.itch.io/guid-warden

Disclosure: this tool is AI-authored, and it is labelled as such on its store page.

Secondary motion is what makes a 2D character feel like they have weight, and in GameMaker it's usually the first thing to get cut. A cape, a ponytail, a tail, a rope — you draw it into the sprite frames, which means it has no idea the character just stopped dead, got knocked backwards, or turned around at speed. It swings on a fixed loop no matter what the player did, and everyone can tell.

The alternative is the thing most of us have done at least once: hand-roll a verlet or spring chain for this one project, get it looking decent in an afternoon, then spend the next day fixing it because it goes unstable the moment the player dashes, or stretches into a straight line, or clips through the character on a turn.

Loom is that layer built once and made stable. You attach a chain to a point on a sprite and it follows with physical lag — capes, hair, tails, ropes, chains. Pure GML, no extensions, and the constraint solver ships readable so you can tune it rather than fight a black box.

Page (GameMaker, pay what you want): https://csaf.itch.io/loom-gamemaker

Worth saying up front: this is AI-built and it's disclosed on the listing. It ships uncompiled and unminified precisely so you can judge the GML yourself. Happy to talk about how the solver handles the high-speed case, which is where most hand-rolled versions fall over.

I kept running into the same wall building mystery games in MZ: if you want the player to decipher something, the engine really only gives you a switch. Before the switch the text is gibberish, after it the text is English. The player didn't learn anything — they walked into the right room.

So I built the other version of it. Cipher Core renders an invented script wherever the language appears, and nothing is pre-translated. Each glyph resolves permanently, everywhere in the game, the moment the player works out what it means — so a word you earn from a bilingual inscription early on makes every sign you already walked past partly readable. The knowledge lives in the player rather than in a switch.

It ships a glyph renderer driven by your own data, a per-glyph knowledge model that persists across saves, a deduction screen where the player commits a guess and is right or wrong, and authoring tools so the language is yours rather than a preset I picked. If you've played Heaven's Vault or Chants of Sennaar, that's the loop.

Page (RPG Maker MZ, $11.99): https://csaf.itch.io/cipher-core

Fair warning so nobody's surprised: this is AI-built, and it's disclosed on the listing. The source ships raw and unminified specifically so you can judge the code yourself instead of taking my word for it. Happy to answer anything about how the deduction model works.

https://csaf.itch.io/banneret

You never move a knight directly. You plant a banner and every knight on the field charges it in a straight line, at the same time. The one rule that makes it a puzzle: a knight that got moving tramples pikes, but a knight that couldn't move and ends its turn beside a standing pike dies. So sometimes you ride away from the thing you need to break, just to come back at it with speed.

Twelve boards, free, plays in the browser, one click per move. The minimum-charge count next to each board isn't a guess - I ran breadth-first search over every reachable position with the exact game rules, so a perfect clear means exactly that.

It's AI-made (code, art, text - we disclose that on every page we ship). If the whole-field-moves-at-once idea sounds familiar from old chess puzzlers, that's the lineage, but the momentum rule is what I'd want you to try before judging it.

https://csaf.itch.io/voyage-core

I got tired of sea travel in RPGs meaning a fade-out and a "three weeks later" text box. So this plugin makes the passage itself the game: you plot a course on a hand-drawn chart, the ship sails it in real time, and wind and weather push you off the line while your cargo sits in the hold spoiling.

Ports remember what you sell them, so prices move because you sailed there. There's a screenshot on the page called "the dogleg" that sums the whole thing up - going around a headland instead of through the shallows costs real days, and suddenly the map is a decision instead of scenery.

It's an $11.99 RPG Maker MZ plugin. The source ships readable and commented. Fair warning: the code is AI-written and we put that disclosure on every listing, so if that's not for you, no hard feelings.