Feature Library
A still of the garden walk: A walker loops a small island garden: it gives way, it burns, it grows back.

Every part here fits in a frame.

187 working parts for web apps and games, each measured to the hundredth of a millisecond. Watch them run. Take the source.

Browse all 187 parts
Click the ground to walk · drag to look round

This frame, part by partGarden walk · each part measured alone on RTX 4060 Laptop

4.0 of 16.7 ms
Brush through 0.55/1.77Meadow grass 1.44/0.28Plants burn 1.32/1.09Humanoid rig 0.28/0.82GPU / CPU ms
Showcases

Small finished apps. Every slice is a part you can take.

Parts are made to be put together. Each showcase runs several in one scene, and shows what each one costs in the frame.

The library

187 parts, laid on one frame.

Each dot is a part, placed by what it costs a frame on its busiest bench scene. Most of the interface sits far left. The heavy simulations earn their place on the right.

Skip past the chart
Placed by the worse of GPU and CPU ms a frame, RTX 4060 Laptop, 1920×1080. Log scale.The same parts as a list

Simulation 33

Things that move by their own rules: plants, cloth, fire, cars, bodies.

Surfaces & materials 16

Materials and surfaces: grass, fur, clay, glass, stone, wear.

Particles 10

Many small things at once: rain, fireworks, sparks, swarms.

Screen effects 8

Effects over the whole picture: lenses, fog, haze, transitions.

See all 8

Techniques 18

The plumbing: cameras, instancing, compiles, lights, picking.

Canvas & 2D 7

Drawing in 2D: brushes, ink, pixel art, guides, endless canvases.

See all 7

UI & interaction 49

Interface that behaves: dialogs, palettes, menus, tables, tours.

Data & layout 25

Charts and layout: tables, treemaps, globes, schedules, sheets.

Systems & tooling 21

Under the hood: tiers, sync, audio, memory, performance gates.

Why trust a part

Every one of the 187 parts was run for 600 frames, 3 times over, and timed. 88 of them cost under half a millisecond. 129 run without WebGPU. And 2,073 pitfalls are written down, so you and your coding agent don’t fall into them.

RTX 4060 Laptop · 1920×1080 at 1× · on mains power · the median round kept · latest run 16 November 2026 · read from the library when this page was built

Made in my own apps first
I build games and tools. When a part held up there, I lifted it out, measured it, and wrote down where it bites. This is that shelf.

Hannes Andersson · Sweden

HaTac102 parts
SpaciousPro44 parts
My other apps17 parts
DeckStudio2 parts
Written for the library22 parts
Your frame

The more you take, the less each part costs.

Look at every demo and write-up for free. Buy a part and you get its source, the full guide and pitfalls, its tests, and 12 months of updates for each part. The basket works out the cheapest mix for you.

Individual licence, for 1 developer. Prices include VAT.

  1. One part

    €29
    €29 a part

    Team, up to 10 developers: €79

    One part, when you need just that.

    Pick a part
  2. 5 parts

    €99
    €20 a part

    Team, up to 10 developers: €249

    A licence for any 5 parts, chosen now or within 12 months.

    Fill five
  3. 10 parts

    €169
    €17 a part

    Team, up to 10 developers: €429

    A licence for any 10 parts: a studio project’s worth.

    Fill ten
  4. Whole library

    €349
    €2 a part today

    Team, up to 10 developers: €899

    All 187, and every part first released within 12 months.

    Take the whole library

Enterprise: more than 10 developers, or a group of companies. Write to us

Prices include VAT and 12 months of updates for each part. Use the code in any number of your own products, commercial ones included, but don’t resell it or publish it as a library or template. After a part’s 12 months you keep every version you downloaded. The licence · Terms of sale · Refunds.

Free reading

How the parts are made. Free to read.

The playbooks: what I learned building them, with the reasons, and a checklist for your own work.

Page shapesThe overall shape of a page before its parts: what the first screen does, the kind of header, one column, sections, cards or a sidebar, and where the reading ends, for nine kinds of page from an app workspace to an event, and a method to compose a shape when none fits.Placement and layoutWhere menus, toolbars, panels, charts, forms and buttons go, and why: one home per job, functions grouped by what they act on, editors beside their work and never over it, things that grow kept to free room, settings panels in rows, live figures that say what they are, and a layout that holds from a phone with its keyboard open to a wide desktop.Layout studioSketch a screen on desktop, tablet and phone grids from a template: move, resize, swap and rename its blocks while the placement rules are checked live, then copy a prompt, CSS and JSON for an agent to build it from.Performance budgetsA frame rate turned into milliseconds, shared out before the work starts: budgets for the worst frames, one allowance for work that can wait, counts per device tier, nothing drawn while nothing changes, and measurements you can trust.Motion and feelWhen to move things and how: motion that explains a change, a few named durations and curves, changes animated but arrivals not, springs that feel the same at any frame rate, cheap and interruptible motion, and reduced motion done properly.Accessibility baselineWhat every screen should meet before it ships: keyboard first, contrast tested on the theme, nothing said by colour alone, names and states, changes announced once, charts with words, and zoom that holds, with the checks to run.Layouts that never breakComponents that hold whatever goes in them: long names, translations, huge numbers, missing pictures, right to left, text at 200% and little room, with every state designed, sizes that bend within limits, and the tests that find what spills.Ingest that never double-countsReading files from a folder into a sheet or a database without ever writing one twice or losing one: know each file by its content, never write when the duplicate check can’t run, keep your own record of what was written, wait for files to settle, one writer, a log nobody can rewrite, and two PCs sharing one synced folder.Many agents, one codebaseRunning several AI agents on one repository at the same time without them colliding: how to shape the code so they can’t, what goes in their brief, and how to check what comes back.Sculpted, not assembled: 3D assets from a Blender scriptBuilding a model in code so it reads as one sculpted form: overlapping volumes unioned, voxel-remeshed, smoothed and decimated per tier, shaded from a smoother copy, crisp lines cut last, review renders that resume, a ray sweep for parts showing through, and names a runtime can trust.Branching and forkingWhen parallel work has to touch the same files: a branch and a worktree per worker, merging them one at a time, and when an AI helper should be a fork, a fresh agent or a session of its own.Office and desktop companionsTaking web work where office people already are: a live web page inside a PowerPoint content block (how the block stores it, what its browser allows, no network, storage sealed per block, the white first frame, focus handed back to the clicker), a local web app shipped as a Windows tool (PyInstaller and a per-user Inno Setup installer, an Edge app window, one instance, a tray icon, start with Windows), and rows appended to an Excel workbook without ever breaking it.Several people, each with their own agentsWhen a team shares a codebase and everyone brings their own AI helpers: the agreements that have to live in the repository, who claims what, who may approve what, and how work survives the end of a session.