Figma Config 2026: The Canvas Is Becoming the Operating System for Design

I’ve just returned from Figma Config 2026 in San Francisco, and I’m still processing everything I saw and heard. After catching up on sleep and recovering from the annual “Config Cold,” I’m finally ready to share my thoughts on Figma’s latest announcements and what they reveal about where our industry is heading.

The Best Part of Config Has Never Been the Keynote

Every year, the thing I look forward to most isn’t the keynote or the product announcements. It’s the people.

It’s unexpectedly meeting someone I’ve only known online, reconnecting with former students and friends, or talking to a designer who has just landed their first design systems role and can’t wait to tell their story.

I always leave Config feeling grateful for this community, and this year was no different.

But I’ll be honest — the atmosphere felt different.

There was still plenty of excitement. The room nearly exploded when Figma demonstrated multiple animation export formats. Yet beneath that excitement was something heavier. Almost everyone I spoke to had been affected by layoffs, either personally or through friends and teammates. There’s a real sense of uncertainty hanging over the design industry right now.

It would feel strange to write a cheerful product recap without acknowledging the reality in which these features are arriving.

If you’re carrying that same uncertainty, know that you’re not alone. There were about 10,000 designers sitting beside you at Config who felt it too.

With that said, let’s talk about what’s new.

The Big Idea: The Canvas as the Center of Everything

This year’s message from Figma was remarkably clear:

The canvas is becoming the place where everything comes together.

Design, code, motion, shaders, AI workflows, and team collaboration are all converging into a single environment.

It’s an ambitious direction and one that positions Figma closer to Adobe’s territory than ever before. Whether every feature succeeds remains to be seen, but the vision itself is compelling: one canvas where every creative material lives together.

Code on the Canvas

For years, the industry has debated design versus code.

Figma’s perspective this year is refreshingly simple:

Code is just another design material.

Just as images and vectors exist on the canvas, code should live there too.

Soon, designers will be able to transform any design layer into an interactive code layer with a single click or a prompt. Those code layers can be duplicated, compared, annotated, and explored side by side.

The experience resembles prototyping, except it happens directly inside the canvas instead of another browser tab or window.

Even more interesting, designers can move between code and editable design layers effortlessly.

What captured my attention wasn’t necessarily the code generation itself — it was the collaborative potential.

Traditionally, code has lived in isolated environments that often feel intimidating to designers. By bringing code onto the canvas, Figma is transforming it into something that can be explored collectively, discussed openly, and iterated on together.

As someone who thinks deeply about systems, that shift feels significant.

Figma Motion

I have a confession:

I’m not a motion designer.

I struggle to visualize movement. I can hold static layouts in my head all day, but the moment I need to imagine how something should animate, I freeze.

So, I approached this announcement with skepticism.

What Figma introduced is a fully integrated motion timeline directly inside Figma Design. It includes keyframes, presets, editing controls, and AI-assisted starting points.

And yes, the export features that had the audience cheering live here too.

But the real opportunity goes beyond animation itself.

Because motion now exists natively inside Figma, it can become part of our design systems.

We can animate a component once and have that behavior travel everywhere, just like typography, spacing, and color definitions already do.

Motion can become a reusable primitive.

The introduction of motion variables suggests that designers and design systems teams will soon need to think about motion as infrastructure rather than decoration.

Personally, what excites me most is something much simpler.

Motion no longer feels like a separate discipline locked behind another tool. It’s right there on the canvas, inviting experimentation.

No additional software. No extra files. No excuses.

Perhaps that’s exactly what I needed.

Shaders

Even if the term is unfamiliar, you’ve already seen shaders everywhere.

They’re the grainy gradients, liquid surfaces, glowing textures, and lighting effects that make interfaces feel almost physical.

Figma has actually used shaders internally for years. Creating them yourself, however, typically required learning specialized programming languages.

I had always categorized shaders as something smarter people did.

Now, you can simply describe the effect you want or provide a reference image, and the Figma Agent generates the shader for you.

What makes this particularly interesting is that the output isn’t locked away in a black box.

The generated shader arrives with editable controls directly on the canvas. Designers can tweak parameters, combine effects, and shape the result until it feels uniquely theirs.

Equally impressive was the performance.

Every demonstration ran smoothly and in real time, entirely on the web and available in both the browser and desktop application.

The real magic happened when shaders met motion.

Every exposed property can now be keyframed on the motion timeline. Any parameter controlled by a slider can also become an animation.

Watching shaders ripple, shift, and evolve alongside animated interfaces felt like witnessing workflows that previously required multiple specialized tools suddenly collapse into one environment.

Again, the pattern becomes clear.

Figma is investing heavily in expanding what’s possible on the canvas.

They’re building a bigger room.

What we create inside it remains up to us.

Generative Plugins

Every designer has repetitive tasks.

Renaming layers. Creating placeholder data. Arranging images. Performing dozens of tiny operations that are strangely specific to individual workflows.

Historically, our solution has been simple:

Hope someone in the community already built a plugin.

Thankfully, many people did.

It’s worth pausing to appreciate how much of Figma’s ecosystem exists because designers and developers spent countless hours building and maintaining tools for the rest of us.

Many of our workflows quietly depend on their generosity.

The new capability changes that equation.

Now, you can describe the tool you need, specify its behavior and controls, and generate a custom plugin without setting up development environments or learning plugin APIs.

You can keep the tool private, share it with your team, or eventually publish it to the broader community.

As a systems designer, I find this incredibly interesting.

For years we’ve shared components and design patterns.

Soon, we may begin sharing our internal tools with the same ease.

I do have one question, though.

If everyone can generate custom tools on demand, what happens to the community plugin ecosystem we’ve relied upon for years?

Maybe simple, one-off utilities become easier to build personally, while sophisticated community plugins become even more valuable.

I don’t know the answer.

I just hope we don’t forget the people who helped make Figma feel like Figma in the first place.

Figma Weave

From a strategy perspective, this may be the most interesting announcement of all.

Weave began as Weavy, a small startup from Tel Aviv that Figma acquired last year in what was reportedly its largest acquisition ever.

That alone tells you how much Figma believed in what the team was building.

Weave is now a node-based canvas for generative workflows.

Instead of sending one prompt and hoping for the best, you can connect models, transform assets, compare outputs, and refine ideas visually through branching workflows.

The philosophy is important:

AI output is not the final answer. It is material to work with.

At Config, many of these capabilities began integrating directly into the Figma canvas.

Again, everything comes back to the same idea.

The canvas.

I don’t have a definitive opinion on Weave yet, but I find its emphasis on experimentation particularly compelling.

It’s a tool designed entirely around trying, branching, comparing, and refining.

That feels perfectly aligned with this year’s broader vision.

The Figma Agent

If there was one thread running through every announcement at Config, it was the Figma Agent.

It creates shaders. It generates motion starting points. It builds custom plugins. It increasingly acts as the connective tissue beneath the entire platform.

The agent officially became available to everyone just before Config, and it gained several important capabilities during the event.

The first is Skills.

Teams can now package workflows, conventions, and instructions into reusable behaviors that the agent can follow.

If you’ve ever written documentation hoping people would actually use it, this idea will feel familiar — except now the guidance becomes actionable.

The second capability is Connectors.

The agent can access context from tools like Notion, Slack, GitHub, Granola, and others, allowing external information to flow directly into the design process.

I’m particularly excited to experiment with this.

Because once again, the pattern emerges.

Figma isn’t simply adding features.

It’s building a system where design materials, code, workflows, AI, and context all converge in one place.

And increasingly, that place is the canvas itself.