The generative plugins and shaders shipped to the canvas with a narrow goal: let designers build the tool they need at the moment they need it, from generating layouts to applying a lens distortion. Work on the capabilities continued after Config 2026, and the new release widens what those tools can do and where they can go.
Actionable advice, real talk, and colorful anecdotes from inside Figma. Behind the scenes
- Publishing. Plugins and shaders built with the Figma design agent can be published to the Figma Community, or privately to an organization on Organization and Enterprise plans.
- Motion and interactivity. The agent can build animation and interaction into any effect you describe.
- Code access. The code behind any shader or plugin you create can be viewed and downloaded, so it can be edited directly in a third-party agent.
- MCP. The Figma MCP server can be used to view and change generative plugins and shaders with your agent, or to export shaders to an agent that implements them precisely in React code.
The story of how the feature was conceived, staffed, and shipped is itself a look at where design work sits now: done alongside AI, moving between design and code, and shared on the canvas.
Prototyping a vision
Shaders are GPU programs that manipulate layers in Figma Design, applied as either a fill or an effect, and they can bend and change pixels in real time. In 2022, Product Designer Rogie King built the Noise & Texture plugin to put that power on the canvas, but there was no route to deeper integration. LLMs changed the situation by making it possible to demonstrate the idea rather than describe it. King vibe coded a WebGPU environment that behaved like Figma, where shader effects could be attached to any layer, including vectors, 3D layers, and particle systems. Three properties drove the prototype:
- Composability, so one shader's output feeds the next
- Editor ergonomics, so a design can be touched and felt through dynamically generated controls, which prompting alone does not provide
- Agentic creation, so LLMs can suggest controls the user can tinker with
Progressive blur had taken months to build in Figma Draw. In the prototype, the same shader effect came from one prompt, sometimes two. The remaining problem was turning a demo into a project, which meant a story, a pitch, and a team.
Rendering and animation engineer Yassir Solomah was the first stop, with a set of questions: would this work, was the approach right, would it tank performance in Figma? A vibe-coded approximation of a WebGPU canvas app is not the enterprise-scale, tile-rendered product. King's WebGL 2 fragment shader system was torn out and replaced with a WebGPU pipeline system, making shaders miniature programs able to render 3D objects and apply logic driven by mouse position and time to control visuals inside layers. Graphics generation scripts could then run in their own sandboxes, which meant safer user-run scripts and opened the door to logic, particle systems, compute shaders, and 3D support.
Solomah validated the prototype by producing working versions of it in Figma Design. Product manager Georgia Rust brought a bird's-eye view of work elsewhere at Figma and connected the effort to it. Product Designer Jason Calleiro had been sharing prototypes of adaptive and generative plugins in Figma Design around the same time, and Rust pushed to combine the two under the umbrella of generative tools: a suite of ways to use agents on the canvas to create custom plugins and shaders on the fly.
Several planning sessions turned a handful of demos into an executive pitch. King ran a live demo of prompting shader effects with agents, canvas handles and dynamic controls included. Solomah covered the core implementation, the security model, and performance maintenance. Rust laid out what would be built first, by whom, and where it could go next. The pitch was greenlit with a ship date of Config and two months to build.
The team logo was 80s-inspired, combining generative tools and effects as a wrench and lightning bolt. The rainbow stands for how prompting can feel like magic; the forward slant for momentum and acceleration.
How the team built
With two months on the clock, the team went back to its roots: no PRDs, no crits, and a preference for prototyping and demos over formal reviews. Engineers and designers joined one large Slack channel and presented to core sponsors weekly. Momentum built as demos reached company meetings, and the initial team of 15 grew.
Plugins and shaders shared infrastructure as promptable, dynamic, iterative, code-backed things living in the new Tools sidebar. Plugins would use the existing plugin API and were meant to look and feel like Figma, following patterns designers already knew. Shaders needed a new API entirely. King built PropsKit, a web components-based Figma UI kit that agents could use.
The first instinct, coming off the vibe-coding wins, was to start every design as a working prototype. That helped designers validate and challenge their own assumptions, but it turned out to be a poor reference for developers, PMs, and stakeholders. The team switched to static mocks in Figma that served as an exploded view of all possible states, securing alignment on key features first. Working code prototypes followed, used to test and settle on solutions without the usual loop of waiting for implementation, returning to design, re-implementing, and testing. Engineer time went to production instead; King wrote production code in the Figma codebase and put up PRs. The Slack channel filled with demos, PR reviews, and on-the-fly decisions.
The last stretch
Two weeks before Config the work was 90% done, and the final 10% was the hard part. The pace meant leaders and sponsors were sometimes reviewing builds that had already changed, and at points the project looked like it might not ship.
The response was fast, frequent communication and instinctual calls. When plugin layouts weren't landing, the team built three new UI components to improve the agent's decision-making. When custom property controls for color palettes needed another three days of engineering, the hard cut was made and a select list shipped in the meantime. Polish went out as a PR. As designer-founder, King found the cuts difficult, but had to learn what to hold back and what to push. The Config keynote, where King and Rust presented generative plugins and shaders, represented the work of the whole team.
The project also changed how the team used Figma, narrowing the gap between design and production. The Config microsite for shaders leaned heavily on the Figma MCP server: an engineer running a local agent expects to read the design through MCP with get_design_context, so code on the canvas is not far removed from design on the canvas. Shaders were built to be exportable in HTML and React, which is part of the release.
Getting started
A generative plugins and shaders playground file is available in the Figma Community. Anyone with access to the Figma design agent can build generative plugins and shaders. The agent is in open beta for Full seat users on all plans; Collab, Dev, and View seats can use it in their drafts. It is free during beta, and will begin consuming AI credits in a few weeks.
Generative plugins versus shaders: where each fits
The two mechanisms serve different jobs. A shader is best suited to per-pixel work that runs on the GPU: fills, noise, gradients, displacement, and other effects that must repaint at interactive rates. A generative plugin, by contrast, belongs where the logic depends on parameters, selections, or the surrounding document — anything that needs to read node properties, write back to the scene, or orchestrate multiple operations. Choosing the wrong one usually shows up as either a sluggish shader doing bookkeeping it shouldn't, or a plugin trying to crunch pixels on the CPU.
Practical rule of thumb: if the output for a pixel can be computed from its coordinates and a handful of uniform inputs, a shader is the lighter tool. If it depends on node properties or must create and modify layers, reach for a plugin.
Wiring parameters into the shader stage
Shader parameters travel as uniform values. The plugin's UI collects the control values and passes them through to the shader each frame, so the same shader can be reused across presets without recompilation. Keep the uniform set small and stable: every added uniform widens the interface between plugin code and shader code, and changing the uniform layout forces a rebuild of the shader program.
- Declare every tunable value as a uniform rather than a hard-coded constant.
- Update uniforms only when their values change, not on every redraw.
- Keep the uniform layout fixed across versions to avoid unnecessary program rebuilds.
Keeping interaction latency low
Perceived speed comes down to how much work happens between an input event and the next painted frame. Do parameter validation and document updates outside the render path, and leave the shader path containing only what must run per pixel. Where an operation is expensive, stage it: render a coarser version while the user is dragging a control, then commit to the full-quality pass once the interaction ends.
A build checklist
- Confirm the effect needs GPU execution before committing to a shader.
- Define the uniform interface first, then write the shader body against it.
- Hookup UI controls to uniforms with a single update path.
- Test at both ends of the parameter range, not just the defaults.
- Profile with the plugin running inside a real document, not a blank file.



