Config 2026 Keynote with Dylan Field (CEO & Co-founder, Figma)

Config 2026 Keynote with Dylan Field (CEO & Co-founder, Figma) — Figma

Figma

AI-assisted summary of Config 2026 Keynote with Dylan Field (CEO & Co-founder, Figma) — original source. Check the original for full context.

Source published:

Key ideas

  • Figma introduced native Code Layers, bringing live, interactive code frames directly onto the design canvas with support for multi-instance execution, Option-drag branching, and two-way Git synchronization via Make. (10:24)
  • Figma Motion launched in open beta, integrating a professional timeline primitive, auto-keyframing, live easing curves, and real-time multiplayer animation tools natively into the canvas without external video software. (46:42)
  • The Figma Agent now enables on-the-fly generation of custom plugins, GPU-powered shader fills and effects, and conversational timeline keyframing directly inside canvas files. (29:05)
  • Acquisition technologies were formalized into the core product, with Weavey integrated as Figma Weave for node-based AI workflows and Modify powering the new timeline engine. (21:44)
  • Figma announced that Config will expand globally with its 11th edition taking place in Bangalore, India, on October 15, 2026. (68:09)

Detailed notes

## Background Published by Figma on YouTube on June 24, 2026, this keynote video records the opening presentation of Config 2026 led by CEO and co-founder Dylan Field. According to the page description, the session explores how product development and design roles are being fundamentally rethought from the ground up, highlighting Figma's biggest product launches of the year.

## TL;DR Celebrating its tenth Config conference, Figma unveils a sweeping product evolution anchored by the thesis that AI lowers the barrier to entry while human designers must raise the ceiling of creative ambition. The keynote introduces Code Layers directly on the canvas, enabling live code execution, real-time multiplayer branching, and seamless GitHub synchronization. Figma also debuts Figma Weave for node-based visual AI pipelines, on-the-fly generative plugins and native GPU shaders powered by the Figma Agent, and Figma Motion, a comprehensive timeline and keyframing animation engine integrated natively into the design canvas. Together, these tools bridge visual design, generative AI, and production code into a single unified creative environment.

## Atmosphere & style The presentation carries the electric, celebratory energy of a milestone community gathering, balancing polished, high-production Silicon Valley staging with genuine creator nerdiness and camaraderie. Dylan Field sets a warm, reflective, and philosophically ambitious tone, which is energized by team members stepping up for live, high-wire canvas demonstrations filled with playful banter, audience cheers, and spontaneous laughter. As complex generative workflows, live shaders, and looping timelines unfold effortlessly in real time, the atmosphere builds into a palpable sense of awe, transforming abstract talk about AI into tangible, hands-on craft.

## Bulletin - [10:24](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=624s) Figma introduced native Code Layers, bringing live, interactive code frames directly onto the design canvas with support for multi-instance execution, Option-drag branching, and two-way Git synchronization via Make. - [46:42](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2802s) Figma Motion launched in open beta, integrating a professional timeline primitive, auto-keyframing, live easing curves, and real-time multiplayer animation tools natively into the canvas without external video software. - [29:05](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1745s) The Figma Agent now enables on-the-fly generation of custom plugins, GPU-powered shader fills and effects, and conversational timeline keyframing directly inside canvas files. - [21:44](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1304s) Acquisition technologies were formalized into the core product, with Weavey integrated as Figma Weave for node-based AI workflows and Modify powering the new timeline engine. - [01:08:09](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=4089s) Figma announced that Config will expand globally with its 11th edition taking place in Bangalore, India, on October 15, 2026.

## Key takeaways - [06:59](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=419s) Dylan Field reframed the historical 'design vs. code' debate, arguing that code is not the opposite of design but a moldable creative material. - [06:59](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=419s) While AI lowers the barrier to entry for building software, elevating the ceiling of creative possibilities remains the responsibility of human practitioners taking bold risks. - [10:24](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=624s) Current AI coding workflows are overly fragmented in siloed chat windows and terminals, necessitating collaborative, spatial tools to explore code together on a shared canvas. - [15:09](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=909s) Code Layers allow users to run multiple interactive code frames concurrently, branch codebases visually via Option-drag, and extract live application flows into static canvas screens. - [18:19](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1099s) Visual design edits on canvas can be pushed directly back to GitHub repositories through delta-analysis agents powered by Make. - [21:44](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1304s) Figma Weave introduces an open, node-based workspace to build reliable, multi-step production pipelines that solve the consistency limitations of one-shot AI generation. - [26:10](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1570s) Complex Weave node graphs can be packaged into modular canvas tools and shared across internal design teams via the Figma tools panel. - [29:05](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1745s) Generative plugins can now be authored instantly in natural language via the Figma Agent, bypassing code editors and public app store review processes. - [32:26](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1946s) Bespoke agency tooling shifts the client delivery model from static deliverables to custom, reusable generative software assets. - [36:29](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2189s) Native GPU shaders arrive in Figma, letting designers prompt the Figma Agent to generate parametric Shader Fills and pixel-distorting Shader Effects without graphics programming. - [46:42](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2802s) Figma Motion incorporates timeline animation directly into core design system primitives, enabling keyframing of styles, components, and variables alongside spatial 2D vectors. - [54:54](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3294s) A sneak peek revealed native 3D transforms under development by the Vectors team, enabling animatable X, Y, and Z properties across canvas elements. - [55:51](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3351s) Shader parameters can be mapped to and keyframed along the Motion timeline, allowing dynamic, interactive visual effects to loop during live canvas editing. - [01:01:26](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3686s) Motion designs can be extracted natively into production code via Dev Mode, Figma MCP, or Figma Make, as well as rendered to MP4, WebM, GIF, and Animated SVG. - [01:04:56](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3896s) Figma Agent is expanding beyond the design file through external connectors (such as Notion, GitHub, and Slack), custom slash-command skills, and dedicated FigJam and Slides agents.

## Detailed walkthrough ### [01:57](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=117s) Opening: Code as a Material and the Evolution of Config

The keynote opens with an introductory video reflecting on the changing nature of creation. Growing up, people were told that the future belonged exclusively to those who knew how to code, meaning an intuition for look and feel had to be paired with technical engineering. Today, that relationship has fundamentally flipped: code is no longer a barrier or a separate domain, but a moldable material just like color or texture, freeing people to ask what they would build if they could build anything. The focus shifts from merely building things faster to pushing ideas further together.

Dylan Field takes the stage to welcome the audience to Config 2026, marking Figma’s tenth Config conference. He expresses deep gratitude to everyone attending in person—especially those who traveled long distances—as well as remote attendees joining individually or at Friends of Figma watch parties. Looking back, Field recalls that during the very first Config in 2020, Figma was celebrating the addition of simple hyperlinks to the canvas. While life and software felt simpler back then, the current era of rapid technological acceleration demands questioning assumptions from first principles.

Field emphasizes that navigating existential industry questions about the future of creativity requires a resilient community. He challenges the audience to push past their comfort zones over the course of the conference by introducing themselves to strangers, greeting people whose work they admire, and making new connections rather than sticking strictly with existing friend groups. Field characterizes Config as a uniquely kind space anchored by people who care deeply about craft:

> “And everyone here viscerally understands, appreciates the value and the importance of design.”

[06:59](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=419s) Raising the Ceiling: Reframing the "Design vs. Code" Debate

Reflecting on statements he made at earlier conferences, Field revisits the adage that AI will lower the floor and raise the ceiling. While AI has demonstrably lowered the barrier to entry for building things, he argues that technology alone has not yet elevated the ceiling of what is possible. Instead, raising the ceiling is the responsibility of the creative practitioners in the room through bold risk-taking, experimentation, and unbounded expression. Figma's mission, he explains, is to build the next generation of tools and workflows so software never constrains creative ambition. For Config 2026, Figma is focusing its product launches on two primary pillars:

1. **New materials** to express anything a designer can imagine. 2. **New tools** to shape these materials and push them further than ever before.

Field tackles the historic, persistent industry debate over whether and when designers should work in code. Dismissing the traditional divide, he insists that forcing creators to choose between visual design environments and code-based environments is an outdated dichotomy that tools should no longer impose:

> “Code is not the opposite of design. Code is material for design.”

```mermaid flowchart TD accTitle: Paradigm shift from design versus code to code as material accDescr: Diagram contrasting the historical binary separation of design and code against the new unified paradigm where code is treated as design material on canvas.

subgraph Old["Historical Paradigm"] direction LR D1["Visual Design<br/>(Figma Canvas)"] -. "False Debate / Hand-off Silos".- C1["Code<br/>(Engineering / IDEs)"] end

subgraph New["Unified Canvas Paradigm"] direction TB M["Design Materials"] M --> V["Vectors & Graphics"] M --> T["Typography & Color"] M --> C2["Code Layers<br/>(Interactive & Agent-Driven)"] end ```

[10:24](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=624s) Introducing Code Layers on the Figma Canvas

To demonstrate how Figma is operationalizing code as a design material, Field invites Nico to the stage. Nico shares his journey as an interaction design student at Hochschule für Gestaltung Schwäbisch Gmünd in Germany, where he spent sleepless nights writing thousands of lines of code to simulate sunset and sunrise gradients. When Nico interned at Figma eight years ago—back when skeptics on Reddit likened an in-browser design tool to “a car with three steering wheels”—he realized that visual design transformed completely once designers like Noah, Brady, Peter, and Sho could jam collaboratively on the same canvas in real time.

Nico argues that software creation is suffering from a new kind of fragmentation. While modern AI coding agents allow individuals to spin up thousands of lines of code effortlessly, those workflows remain isolated in single-user chat prompts and siloed terminals. Designers often find themselves deep in personal prompt threads, emerging only to lob prototype screen recordings over the wall at colleagues instead of genuinely exploring alongside them:

> “I believe that we will be experiencing the same shift with code. And it is a wonderful material, but while agents have made it so much easier to write thousands of lines of code, the workflows around code are not built for exploring together at all.”

To bring collaborative fluidity to code, Nico unveils **Code Layers** directly on the Figma canvas: - **Direct Canvas Interaction**: Live code executes right inside canvas frames. Users can pan, zoom, drag elements, and interact directly with dynamic weather widgets or live components without launching external preview windows. - **Creation Methods**: Users can convert a standard design layer into code by clicking "Build this with code", or invoke the new dedicated Code tool straight from the bottom toolbar to drop a fresh code frame onto the canvas. - **External Imports**: Designers and developers can bring existing projects into Figma by importing GitHub repositories or uploading local project folders directly onto the canvas.

[15:09](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=909s) Multi-Instance Execution, Visual Branching, and Flow Extraction

Nico highlights the challenge of evaluating interactive software: static mocks fail to convey feel, while single-pane code editors prevent holistic comparison. On the Figma canvas, users can select multiple separate code frames simultaneously and press `Enter` to run them concurrently. Nico showcases this by running three distinct interactive concepts side-by-side—a glitch effect, an interactive 3D cube, and an interactive S-curve card animation.

Because code layers live natively on the canvas, contextual history and AI generation threads are shared across the team. Nico opens the inspector on the S-curve animation to review the prompt history, showing how teammates (such as Pete) collaborated with agents to construct the math behind the curve.

Branching code explorations adopts standard canvas muscle memory: - **Instant Branching**: Duplicating a code layer requires only holding down `Option` and dragging the frame across the canvas, instantly spinning up an independent, editable fork of the codebase. - **Agent Modification**: Designers prompt the duplicated layer in natural language (e.g., asking the agent to adapt the background color dynamically to match the focused card in the center).

```mermaid flowchart LR accTitle: Workflow of code layers on the Figma canvas accDescr: Steps showing how code layers are created, branched via Option-drag, inspected, and extracted into exploded design flows.

subgraph Canvas["Figma Canvas Workflow"] A["Create Code Layer<br/>(Toolbar, Design Conversion, or Repo Import)"] B["Multi-Run & Inspect<br/>(Select multiple, hit Enter, shared prompt logs)"] C["Branch by Dragging<br/>(Hold Option + Drag to fork codebase)"] D["Extract Design Flow<br/>(Record interactions to explode states)"]

A --> B --> C --> D end ```

Addressing the need for spatial context, Nico demonstrates **Extract Design**. Because humans think spatially and need to view full application flows at a glance, users can select a code layer, click "Record Flow," and interact with the application—such as navigating to a user profile, opening events, and encountering an empty state for biking events. Upon hitting "Stop," Figma extracts every rendered state into a structured, bird's-eye flow of static screens across the canvas, giving teams a full spatial overview of code-driven states to inspect and refine.

[18:19](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1099s) Updating Code Layers and Git Sync on the Canvas

Collaborating directly on the canvas alongside colleagues Tammy and Peter, the presenter dives into riffing on design layers to refine an empty-state screen. Bringing in components from the asset library and snapping them into alignment with keyboard shortcuts, they notice that the initial placeholder state feels somewhat disheartening. Rather than showing a frowning illustration when no events are scheduled, the design is rewritten to read "find events" with the expression turned into a smile. Looking across the shared workspace at what Tammy and Peter have spun up in parallel, the presenter jokes that their peers naturally designed something much sharper.

When elements are broken out from live code into static design representations on the canvas, designers can modify them visually and immediately hit the "Update code layers" button. This action triggers an automated analysis that isolates exactly what visual and structural properties changed, minimizing the surface area of work required by the underlying coding agent. Because these code layers remain directly connected to GitHub, designers can push their modifications straight back into their team's source repository, allowing engineers to pull the latest changes into their local environments from anywhere. As dozens of multiplayer avatars flood into the shared file, the presenter reflects on what this bridging of disciplines represents: “Personally, I do really hope that you'll make a mess, like a beautiful mess, because this right here really is what enables collaborative creativity.”

```mermaid flowchart LR accTitle: Code Layers to GitHub Sync Architecture accDescr: Visual flow showing how static canvas edits update code layers, get processed by an AI agent, and sync to GitHub. subgraph Canvas["Figma Canvas"] A["Static Design Layer"] -->|"Edit & Align"| B["Update Code Layers"] end subgraph Engine["Figma Agent & Make"] B --> C["Delta Analysis Engine"] C --> D["Coding Agent"] end subgraph Git["Version Control"] D --> E["GitHub Repository"] E --> F["Local Production Codebase"] end ```

- Code layers are powered under the hood by Make, which recently added plan mode, voice-to-text, web search capabilities, and native npm support. - A recent update allows users to run Make locally on their machines against their live production codebases, bridging open-ended design exploration and production implementation. - Code layers are launching into a closed beta with waitlist onboarding beginning in July, accessible to full-seat users across all plan tiers.

---

[21:44](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1304s) Introducing Figma Weave: Node-Based AI Workflows

To showcase spatial computation beyond raw code, Itai Schiff—co-founder of Weavey (now Figma Weave)—takes the stage for his first Config since his company joined Figma the previous autumn. Drawing on a 25-year career in post-production as a visual effects artist and creative director, Schiff shares how his early infatuation with AI generation hit a familiar creative wall. While text prompting was entertaining, professional production demanded rigid consistency, rich contextual references, iterative cycles, and direct feedback loops rather than isolated one-shot outputs. Schiff explains the core frustration that sparked Weave: “Making something interesting was easy, making something usable for real projects was hard.”

To solve this, Weave was constructed as an open, node-based canvas where creators string together visual logic to build custom production pipelines. Nodes either house assets (such as bitmaps, video plates, or 3D models) or execute transformations ranging from multi-modal AI generation to deterministic controls like timelines and color grading. Schiff demonstrates three distinct pipelines: 1. **360-Degree Product Video Generation:** Starting from isolated front and back product shots, an automated sequence preserves geometric and texture consistency across frames to output a seamless rotating product video. 2. **Lo-Fi Style Rendering Engine:** Creators feed rough wireframe animations or 2D logo marks alongside a curated style reference, allowing the engine to synthesize fully shaded, stylized renders in seconds without waiting on manual 3D lighting and shader setups. 3. **Vendor Asset Harmonization:** E-commerce teams often receive catalog assets shot under wildly inconsistent studio lighting and resolutions. Instead of flattening them to grayscale to hide discrepancies, a Weave style-transfer graph evaluates each article of clothing—such as a hat, shoes, and a shirt—and applies a shared visual language so all products appear as if they were shot in the exact same campaign.

---

[26:10](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1570s) Bringing Weave Workflows into the Figma Tools Panel

Rather than forcing every designer to inspect complex node graphs, Figma is embedding Weave workflows directly into the native canvas as reusable tools. By collapsing the intermediate graph "noodles" and surfacing only the exposed inputs and outputs in a streamlined sidebar, anyone on a design team can invoke powerful multi-step AI pipelines without leaving their layout. In a live test on stage, Schiff selects the Bulk Style Transfer tool, selects raw product shots, assigns a reference aesthetic, and generates a unified collection of catalog assets with a single click.

Schiff previews a suite of out-of-the-box canvas tools derived from the most popular community graphs. These include automated background replacement, an intelligent texturizer that projects tactile surfaces onto raw vector shapes, a logo-to-product mapping utility, and a one-click kawaii sticker pack generator (which Schiff humorously cautions will only work properly on his own face). Moving forward, teams will not be confined to prepackaged presets: creators will be able to construct their own bespoke node graphs in Weave, package them into modular tools, and distribute them internally to their colleagues directly inside Figma's tools panel. To accelerate adoption, all Config attendees receive bonus Weave compute credits upon signing into their accounts.

---

[29:05](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1745s) Generative Plugins Powered by the Figma Agent

Following Weave's demonstration, product leader Georgia Rust and designer Raji King step onto the stage to reveal what else is arriving inside the tools drawer. While Figma's developer community has published thousands of utilities over the years, discovering or authoring a hyper-specific utility mid-workflow remains a friction point. To eliminate the barrier between identifying a repetitive layout chore and solving it, Rust announces a fundamental evolution for the canvas: “So, starting today, you can generate plugins with the Figma agent.”

Boarding what King playfully dubs the "Agent Express," the duo demonstrates generating a custom utility on the fly for an audio application layout. Facing a row of flat, uniform rectangles, Rust prompts the Figma agent to write a plugin that randomizes the height of all selected frames to emulate an organic audio waveform, instructing the agent to build and execute immediately without pausing for conversational clarification. Generative plugins differ fundamentally from legacy extensions: - They require no local desktop app runtime or external code editor. - They are generated via natural language prompts without writing JavaScript or TypeScript. - They execute and reside locally inside the file's properties panel, bypassing manual app store publishing and approval flows. - They can be used, iterated on, and shared frictionlessly among all collaborators invited to the file.

Highlighting how this empowers hyper-tailored design workflows, King highlights community designer Miggy, who frequently constructs complex bento-box marketing grids. Instead of manually recalibrating spacing, borders, grids, and typography every time he establishes a layout, Miggy used the agent to construct a bespoke "Bento Grid Builder" plugin that instantly reorganizes highlighted layers into his signature personal aesthetic with a single click.

[32:26](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1946s) Custom Agency Plugins: Alba Racing and Track Visualization

The demonstration highlights how plugins can move beyond one-size-fits-all utilities to serve personal needs, brand-specific workflows, or unique daily datasets. As a prime example of bespoke tooling, the presenter points to work done by Athletics Agency for their client Alba Racing. Designed specifically for Formula 1 fans and racing enthusiasts, the custom plugin pulls in real-world data to chart out accurate racecourse layouts from across the globe.

On stage, the presenter interacts with the plugin directly inside Figma. Selecting the Monaco circuit, they adjust specific parameters—toggling off particular turns and refining the aesthetic controls to tailor the visual vibe while maintaining fidelity to the true geometry of the track. Because the plugin is powered by actual track data under the hood, the resulting visuals remain faithful to the real layouts. Crucially, this shifts the entire client handoff paradigm: when Athletics Agency delivers the project, they do not merely hand over static canvas files; the client receives both the finished design assets and the custom software tooling used to construct them.

- **Athletics Agency & Alba Racing**: Created a plugin utilizing real-world track coordinate data to generate accurate racing circuits (such as Monaco). - **Tooling as Deliverable**: Clients receive the generative plugin alongside design files, enabling ongoing updates within the client's internal workflow.

---

[33:30](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2010s) Building Generative Plugins with the Figma Agent

Checking back in on the Figma Agent, the presenters review a newly generated plugin built to solve a repetitive design problem: creating and styling waveform visualizers. Instead of manually adjusting individual vector rectangles on the canvas, the presenter opens the freshly generated "waveform randomizer" plugin and triggers it on a selected layer. Although the initial output proves slightly taller than desired, a quick tweak to the height input—setting it to 50—produces an immediate, perfectly balanced result directly on the canvas.

```mermaid flowchart TD accTitle: Generative Plugin Workflow accDescr: Flow diagram showing how a user prompts the Figma Agent, iterates on a plugin draft, and adds advanced logic. subgraph Ideation ["Agent Creation"] A["Natural Language Prompt / Workflow Need"] --> B["Figma Agent Generates Plugin Draft"] end subgraph Iteration ["Canvas Testing & Refinement"] B --> C["Run Plugin on Layer Selection"] C --> D{"Review Output"} D -->|"Adjust UI / Controls"| B D -->|"Expand Logic (e.g. MP3 Audio Input)"| E["Advanced Production Tool"] end ```

Having a functional first draft opens up instant opportunities for rapid iteration. The presenter notes that they can easily reopen the agent chat to rev the plugin further—such as wiring it to ingest a real MP3 audio file so the waveforms reflect authentic track dynamics. The broader takeaway centers on eliminating the friction that keeps designers from writing code. Speaking to the psychology of designers, the presenter emphasizes: “Building generative plugins makes it possible for you all to say yes to building the tools that you wish existed in Figma.”

- **Waveform Randomizer**: Generates dynamic audio waveforms automatically, replacing tedious manual rectangle resizing. - **Iterative Logic**: Plugins can be conversational stepping stones; users can re-prompt the agent to add real data inputs like MP3 parsing. - **Democratizing Tool-Building**: Lowers development barriers for niche workflows, small team efficiencies, or experimental one-off concepts.

---

[34:57](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2097s) Community Creations and Learning from Agent Conversations

To illustrate how playful personal projects can yield sophisticated internal tools, the presenters spotlight Lauren, an engineer on the Figma team who channeled her passion for nail art into a dedicated Config nail design plugin. The tool lets users customize styles, choose tip contours like oval shapes, set nail length to medium, and apply Config's distinct aesthetic motifs to generate bespoke nail art concepts for manicurists.

Beyond generating fun visuals, the system introduces a transparent learning model. Anyone inspecting a plugin generated with the agent can view the underlying conversational prompt history. By reviewing the exact prompts and iterative back-and-forth Lauren used to define her UI controls and styling logic, other team members can inspect the architectural reasoning, fork the conversation, and customize the tool for their own purposes. As the presenter reflects on seeing colleagues build creative utilities: “The best part about these is that you can build these with any idea that you on the top of your head.”

---

[36:29](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2189s) Unveiling Shaders in Figma

Transitioning from plugins to rendering capabilities, Raji and Georgia introduce a feature that has been in development and debate inside Figma for four and a half years: native shaders. While the word "shader" can sound intimidating to non-technical designers, Raji reminds the audience that shaders already underpin modern digital interfaces. Familiar effects across Figma—such as progressive blurs, glass refraction effects, and smooth complex gradients—are all calculated through shaders operating deep within the canvas rendering pipeline.

Historically, crafting custom shaders required deep mastery of mathematical equations and graphics programming, leaving them inaccessible to most product designers. Figma changes this paradigm by integrating shader generation directly into its AI agent workflow. Announcing the launch to widespread applause, Raji declares: “Starting today, you can create your own shaders with the Figma agent.”

- **Development Timeline**: A long-standing internal goal championed by Raji for over 4.5 years. - **Core Canvas Engine**: Explains that everyday UI treatments like progressive blurs and glass effects are built on GPU shaders. - **AI Accessibility**: Removes the high mathematical barrier of writing raw shader code by handing code synthesis over to natural-language prompts and visual references.

---

[38:18](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2298s) Generating Shaders from Reference Images and Shader Fills

Demonstrating the new capability, Raji attempts a live-prompting session on stage. Wanting a specific visual effect applied to a photographic composition but lacking the exact terminology to describe the algorithm, Raji uploads a reference image directly into the Figma Agent chat. They instruct the agent to analyze the image and generate a static shader effect matching its aesthetic qualities, intentionally asking the agent not to interrupt with clarifying questions during the live stage demo—though Raji notes that in everyday use, the agent's interactive questions serve as a helpful tutorial on graphics concepts.

```mermaid flowchart LR accTitle: Shader Types in Figma accDescr: Diagram distinguishing Shader Fills from Shader Effects. subgraph Shaders ["Figma Shaders"] direction TB subgraph Fills ["Shader Fills (Materials)"] F1["Base Color / Generative Pattern"] F2["Interactive Canvas Handles"] F3["Standard Blend Modes (e.g. Plus Lighter)"] end subgraph Effects ["Shader Effects (Transforms)"] E1["Sits on Top of Vector/Video Layers"] E2["Bends, Warps, & Distorts Pixels"] E3["Real-Time Parametric Controls"] end end ```

Raji then breaks down the distinction between two primary shader types: **Shader Fills** and **Shader Effects**. Shader fills act as the underlying material, supplying generative color, noise, or patterns akin to standard solid fills, gradients, or images: - **Water Caustic Material**: Demonstrating an aquatic caustic shader fill created by Ellie Lin, Raji manipulates numerical sliders alongside interactive on-canvas handles to reposition the caustic light points directly on the artwork. - **Material Controls**: Sliders provide granular control over scale and intensity, allowing the user to dial in a moody aesthetic. - **Layer Composition**: Because it behaves like any native Figma fill, designers can combine it with standard blend modes like Plus Lighter.

---

[40:49](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2449s) Mesh Gradients and Dynamic Shader Effects

Continuing the exploration of shader fills, Raji showcases a complex mesh gradient. Rather than a flat, static bitmap, the mesh gradient exposes interactive on-canvas control points driven by real-time 3D mathematics and geometry. Reflecting on past user requests from their time on Figma’s Draw team, Raji shares how mesh gradients were perpetually deferred on the product roadmap: “What I love about this work stream is that we're building the tools to help you make whatever you want and have your own tools.”

Raji then transitions to **Shader Effects**, which sit on top of underlying materials to bend, distort, and morph pixel data: - **Carousel Perspective Warp**: Applied over live Figma vector layers rather than a flattened raster image, the shader lets the user freely warp perspective and distort layer geometry using sliders and canvas handles. - **Full Layer Interactivity**: Elements underneath the shader effect remain completely editable as native Figma components and typography.

---

[42:18](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2538s) Real-Time Video Distortion and Interactive Page Curl

The presentation pushes shader effects further by showcasing real-time manipulation of dynamic media. Raji selects a sci-fi hero card running an active, looping video layer and applies a lens distortion shader effect. Pushing the distortion and chromatic aberration controls creates a glass-bubble refraction that refracts the video frame in real time as it plays. Manipulating the on-canvas handle warps the playback dynamically across the viewport.

To conclude the live shader walkthrough, Georgia and Raji examine a boarding pass mock-up destined for "Shader City." Demonstrating that the design consists of real Figma layers, Raji switches Georgia’s assigned seat from a middle seat to a window seat in the design. They then inspect a subtle effect titled "page curl." Opening the effect reveals a fully interactive curl that rolls and unrolls the pass across the screen. The shader incorporates physical parameters like texture bleed, allowing the graphic on the back of the card to subtly show through as the paper peels away. Returning to the agent interface, Raji prepares to apply the newly generated shader to complete the live demonstration.

[44:07](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2647s) Shader Stacking, Interactive Effects, and Availability

Building custom shaders often requires an iterative creative loop rather than getting everything right in a single prompt. Recognizing that one-shot prompting can be difficult when searching for the exact descriptive words, the editor allows designers to return to their prompts, refine parameters, and immediately see their shader effects update. Shaders can also be stacked directly on top of brand assets. In a demonstration of stacked effects, a "gooey merge" effect is applied to blend distinct characters together, layered alongside a lens distortion effect. Because these effects are completely reorderable, moving the gooey merge above the lens distortion causes the gooey merge algorithm to evaluate the distorted output itself, demonstrating how simple re-stacking unlocks wildly diverse visual combinations.

The presentation peaks with a showcase of interactive shaders that dynamically respond to live mouse input. An "Interactive Particles" shader actively tracks the cursor across the canvas, scattering and swirling elements in real time. Emphasizing the limitless creative headroom of the feature, the presenter notes: “The best shaders are going to be the ones that you dream up on your own.”

- **Agent Integration & Availability:** Starting today, all users with full seats on paid plans can generate custom plugins, shader effects, and shader fills directly using Figma Agent. - **Interactive Shaders:** Real-time interactive shaders (such as mouse-tracking particle simulations) are slated for release soon while the team optimizes their performance. - **Community & Org Sharing:** The ability to publish custom shaders to internal organization libraries and the wider Figma Community is coming soon, alongside a curated starter pack available directly in the canvas tools panel.

---

[46:42](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2802s) The Modify Team and the Unveiling of Figma Motion

The keynote shifts from static visual effects to the realm of time-based design. The presenter explains that evocative product experiences must not only be seen, but felt and emotionally experienced—a vision that led Figma to acquire the startup Modify a year prior. Piers and Dave, founders from Modify, take the stage to share what their team has been building since joining Figma. Their background spans visual design, music, sound, and real-time graphics, all united by an obsession with creating collaborative, highly expressive browser-based creative tools.

Addressing long-standing curiosity from the design community on social media about their work over the past year, the duo breaks the news with playful wordplay around time, easing, and keyframing. They explain that rather than bolting on an isolated motion tool, Figma's infinite canvas needed a fundamental new dimension. Piers and Dave then formally introduce **Figma Motion**, embedding a professional timeline primitive directly into Figma Design. Keyframes, easing curves, presets, and animation data now live natively inside the canvas, integrating with styles, components, and design systems.

> “Today, we get to show you something that we've been working on since we joined Figma from Modify a year ago.” — Dave

```mermaid flowchart TD accTitle: Figma Motion Architecture accDescr: Diagram showing how Figma Motion integrates with design systems, AI Agent, shaders, and real-time multiplayer features.

subgraph CorePlatform["Figma Platform & Design System"] DS["Components & Variables"] Canvas["Infinite Canvas"] end

subgraph MotionPrimitive["Figma Motion Engine"] Timeline["Timeline Primitive"] AutoKey["Auto Keyframe (Shift + K)"] Easing["Live Easing Controls"] Transforms3D["3D Transforms (X, Y, Z)"] end

subgraph Extensions["AI & Effects Integration"] Agent["Figma Agent Prompting"] Plugins["Custom Timeline Plugins"] Shaders["Dynamic Shader Effects"] end

CorePlatform --> MotionPrimitive MotionPrimitive --> Extensions Extensions --> Canvas ```

---

[49:38](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=2978s) Timeline Fundamentals: Keyframing, Easing, and Canvas Feel

Entering motion mode is frictionless: designers simply toggle a control at the bottom of the Figma interface, press the spacebar, and watch their static mockups spring into life. Available in public beta starting today, Figma Motion incorporates familiar primitives—styles, variables, and components—into an interactive timeline. To animate any layer, users position their timeline playhead, hit Shift + K to activate Auto Key, and then move, rotate, or scale the asset directly on canvas. Keyframes are placed automatically, allowing instant previewing.

A standout capability of the timeline is the ability to adjust easing curves and spatial properties in real time while the animation is actively looping. Because motion requires intuitive, tactile exploration rather than abstract numerical adjustments, the team prioritized canvas interaction fidelity. Canvas staples like snapping, multi-selection, dragging, panning, zooming, and direct manipulation were meticulously refined so motion designers can duplicate frames, sequence events, and compare timing variations side by side.

> “And this is really important because animation is one of those things that you really have to feel your way through.” — Piers

---

[52:00](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3120s) Accelerating Motion with Figma Agent and Custom Plugins

Manual keyframing across complex, multi-frame layouts can quickly become tedious. To bypass repetitive timeline setup, designers can delegate animation choreography to Figma Agent. In a live example, Dave selects three distinct artboards simultaneously and issues a single plain-English prompt: *"fade in all images, slide and fade in text, concurrently... and then fade out again to create a perfect loop."* Agent generates complete keyframe sequences across all selected frames in seconds. Crucially, the resulting animations are not baked video files or rigid presets; every keyframe and easing curve remains completely exposed on the timeline for manual fine-tuning.

In addition to sequencing choreography directly, Figma Agent can build bespoke workflow plugins tailored to timeline manipulation: - **Keyframe Staggering:** Dave showcases a custom-built plugin, "Timeline Keyframe Stagger," created via Agent in just four or five prompts. - **Automated Sequencing:** After selecting layers with Shift-Cmd-A, the plugin offsets their timeline start points to prevent elements from entering the screen in a boring, uniform block. - **Bézier-Curved Offsets:** The plugin can even read a custom Bézier curve drawn on the canvas and map its easing shape directly onto layer entry timings across the timeline.

> “Once a tool is created, those workflows become fast and repeatable.” — Dave

---

[54:54](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3294s) Sneak Peek: 3D Transforms in Figma

Pushing canvas expression further, Dave and Piers offer a preview of an upcoming feature currently under development: native 3D transforms within Figma. Spearheaded by the Vectors engineering team—the same group responsible for launching Figma Draw the previous year—this engine adds full Z-axis manipulation alongside conventional X and Y coordinates.

Live on stage, Dave manipulates interactive 3D rotation gyros directly on canvas elements, demonstrating smooth perspective distortion and rotational depth. Because spatial attributes plug directly into the timeline engine, designers will be able to keyframe, interpolate, and loop 3D rotations alongside standard 2D vector shapes, introducing true dimensional depth to Figma compositions.

> “We're building 3D transforms in Figma. X, Y, and Z properties can all be animated.” — Dave

---

[55:51](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3351s) Multiplayer Motion Design and Animating Shaders

The true strength of Figma Motion lies in its integration with Figma's real-time multiplayer architecture. Motion is no longer an isolated, single-player export process relegated to external video editing suites. On the collaborative canvas: - **Collaborative Timelines:** Comments left on the canvas appear anchored directly at their corresponding timecodes on the motion timeline. - **Component Propagations:** Animated components nested within master scenes automatically inherit live updates across the team in real time. When another designer edits an embedded component, the overarching animation updates immediately. - **Multiplayer Playheads:** Spotlighting a team member displays their exact cursor and timeline playhead position, allowing teammates to follow along remotely as an animator explains timing decisions.

> “This level of real-time creative control, collaboration, and flexibility hasn't existed in motion design before.” — Dave

The presentation concludes by merging the keynote's two major announcements: Shaders and Motion. Because every shader effect and fill exposes tweakable numerical parameters, every single one of those parameters can be keyframed on the Motion timeline. Applying an Outlines shader on top of an animated composition dynamically calculates vector outlines around moving geometry in real time. Dave sets an initial keyframe for outline spacing at the start of the timeline, tweaks the value midway, and pastes the first keyframe at the end, producing a seamlessly looping, reactive shader-motion hybrid in seconds.

[59:01](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3541s) Combining Effects, Shaders, and Figma Motion

Demonstrating the raw creative power of stacking dynamic effects on top of foundational motion tools, the presenters show how sliders react and animate in real time directly on the canvas. Building on techniques shared earlier, the presenter highlights a stylized typography piece that leverages path trimming alongside textured brush strokes created with Figma Draw. By stepping into the container, they turn on layered procedural effects: first, a noise displacement effect that introduces a subtle, organic wobble, followed by a chromatic aberration effect that injects vivid color bleed at the boundaries of the timeline. The audience reacts enthusiastically, with the co-presenter affirming, “Yes, that is dope.”

```mermaid flowchart TD accTitle: Figma Motion Layering Architecture accDescr: Diagram showing how vector graphics are layered with procedural effects and live-rendered.

subgraph Base["1. Base Design & Motion"] A["Figma Draw Vectors"] B["Path Trimming"] C["Timeline Keyframes"] end

subgraph Effects["2. Procedural Shaders"] D["Noise Displacement (Organic Wobble)"] E["Chromatic Aberration (Color Bleed)"] end

subgraph LiveOutput["3. Dynamic Output"] F["Real-Time Live Canvas Rendering"] G["Editable Text & Vectors During Playback"] end

A --> C B --> C C --> D D --> E E --> F F --> G ```

Moving into product UI, the presenter reveals a "goal reached" celebration screen designed to heighten user delight upon unlocking a reward. This interface merges procedural shaders with timeline animation. As the presenter slowly scrubs the timeline, the shader effect visibly distorts elements of the composition while Figma Motion concurrently drives other UI components. Crucially, this output is not a pre-rendered video; changing text or layout immediately updates the visuals in real time mid-playback. Reflecting on this depth, the presenter remarks: “It is genuinely hard to believe I'm in Figma sometimes, and often the results that I end up with after spending a lot of time getting deep into exploration are really different from what I first had in mind.”

- **Real-time vector manipulation**: Combines path trimming, textured brush strokes, and live timeline adjustments. - **Shader effects**: Noise displacement provides organic movement; chromatic aberration adds color-fringing accents across start and end keyframes. - **Dynamic canvas editing**: Text, vector shapes, and properties remain completely editable and update live while animations loop.

---

[01:01:26](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3686s) Dev Handoff, Export Workflows, and Launch Film

Translating animated canvas work into production code is supported natively. Designers can jump into Dev Mode to extract motion specs and code directly, or transmit the assets to an LLM via the Figma MCP (Model Context Protocol), or pipe them into Figma Make. To illustrate this, the team displays a live design system guide website whose animations were produced in Figma, passed through the Figma MCP, and shipped straight into code. For workflows that do not require live code implementation, traditional render exports are fully supported.

- **Developer integration**: Direct code extraction via Dev Mode, Figma MCP pipeline, or Figma Make. - **Static and raster export formats**: MP4, WebM, Animated SVG, and GIF, with additional export formats currently under development. - **Availability**: Figma Motion enters open beta immediately on all plans and full seats.

To demonstrate the engine's real-world ceiling, Figma’s internal brand team used the combination of procedural shaders and Figma Motion to animate their official launch film entirely inside Figma. Showing the behind-the-scenes master file with its sprawling canvases and timeline setups, the presenter notes the disbelief among internal teams when opening the project, emphasizing that the finished film demonstrates the sheer range of production-ready motion graphics achievable without external specialized suites.

---

[01:04:56](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=3896s) Dylan Field on Figma Motion and the Expanding Figma Agent

Dylan Field returns to the stage following the brand film, reflecting on the artistry of motion designers: “They are able to create things that others cannot even articulate or explain, let alone replicate.” He acknowledges that while many product builders have wanted to produce high-caliber motion, the barrier to entry has historically felt insurmountable. Field highlights that Figma Motion was deliberately engineered to remain intuitive without sacrificing mechanical depth, hoping it democratizes motion across product teams.

Field then pivots to the Figma Agent, which rolled out globally the day prior and is rapidly expanding its ecosystem footprint through attachments and external connectors:

```mermaid flowchart LR accTitle: Figma Agent Integrations and Extensibility accDescr: Overview of external context connectors feeding into the Figma Agent and outputting to design actions and skills.

subgraph Sources["Context Connectors"] A["Notion"] B["Slack"] C["Granola"] D["Hex"] E["GitHub"] F["Atlassian"] end

subgraph AgentEngine["Figma Agent"] G["Context Parsing Engine"] H["Custom Skills (/commands)"] end

subgraph Automation["Workflows"] I["Compliance Audits"] J["Synthetic User Testing"] K["Repetitive Team Tasks"] end

Sources --> G G --> H H --> I H --> J H --> K ```

Field expresses immense excitement for custom skills, calling them a productivity game-changer: “Honestly, I think we could have done an entire keynote just on skills.” Skills enable users to convert frequent prompts into reusable, slash-command automations—such as running design compliance checks, conducting synthetic user tests, or scripting complex internal workflows. Furthermore, Field announces that the agent framework will extend beyond standard canvas boundaries with upcoming dedicated agents: the FigJam Agent (to parse codebases into system diagrams and organize raw brainstorming notes into timelines and prioritization matrices) and the Slides Agent (to transform customer briefs into branded presentation decks).

---

[01:08:09](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=4089s) Beta Availability, Product Roadmap, and Config Bangalore

Summarizing the major announcements of the keynote, Dylan Field outlines what is available immediately in open beta and what is slated for upcoming closed beta releases:

| Feature / Surface | Release Status | AI Credit Consumption | |:--- |:--- |:--- | | **Figma Motion** | Open Beta (All plans & full seats) | No AI credits consumed during beta | | **Generative Plugins** | Open Beta | No AI credits consumed during beta | | **Shaders** | Open Beta | No AI credits consumed during beta | | **Weave Tools** | Open Beta | No AI credits consumed during beta | | **Code Layers** | Closed Beta (Early access via `figma.com/config-betas`) | TBD | | **FigJam Agent** | Closed Beta (Early access via `figma.com/config-betas`) | TBD | | **Slides Agent** | Closed Beta (Early access via `figma.com/config-betas`) | TBD |

Field urges attendees to visit the Product Studio just outside the main hall to share feedback directly with the engineers and product managers who built these tools, or to attend the upcoming agenda deep dives. He articulates Figma’s product thesis regarding AI and creative craftsmanship: “Like I said earlier, AI, it can lower the floor. It's up to all of you to raise the ceiling. And our goal is to give you all the power you need to push that ceiling right to the stratosphere.”

Before wrapping up, Field thanks the Figmates who organized the company’s 10th Config conference and mentions ongoing hiring efforts across teams. To close the keynote, he announces that Figma will take Config on tour later in the year, hosting its 11th Config in Bangalore, India, on October 15, 2026.

## Notable quotes > [06:59](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=419s) Code is not the opposite of design. Code is material for design. — Dylan Field

> [01:08:09](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=4089s) AI, it can lower the floor. It's up to all of you to raise the ceiling. — Dylan Field

> [21:44](https://www.youtube.com/watch?v=2ZCc4k_IV5w&t=1304s) Making something interesting was easy, making something usable for real projects was hard. — Itai Schiff

## Mentioned Figma, Dylan Field, Config 2026, Code Layers, Figma Weave, Figma Agent, Figma Motion, Modify, Figma Draw, Figma Make, FigJam Agent, Slides Agent, Dev Mode, Figma MCP, Nico, Itai Schiff, Georgia Rust, Raji King, Piers, Dave, Athletics Agency, Alba Racing, GitHub, Notion, Slack, Granola, Hex, Atlassian, Hochschule für Gestaltung Schwäbisch Gmünd, Config Bangalore

## Video description Design and product-building are changing, and so are the roles we play in the process. This means rethinking product development from the ground up—shifting mindsets and methods to make great work. Figma’s biggest product launch of the year kicks off Config.

Read the Full Recap: https://www.figma.com/blog/config-2026-recap/

Disclaimer: This presentation contains certain forward-looking information, such as that relating to the expected development of features and functionality that are currently in development or otherwise under consideration. Launch dates and designs are estimates and subject to change. Features and functionality presented are not considered binding commitments and are subject to change at the discretion of Figma at any time for any reason without notice.This presentation is provided to allow individuals the opportunity to understand Figma's vision, but should not be relied upon in making purchasing decisions. This presentation does not contain any guarantee of future performance and undue reliance should not be placed on it.

____________________________________________________

Find us on ⬇️ X (formerly Twitter): https://x.com/figma Instagram: https://www.instagram.com/figma LinkedIn: https://www.linkedin.com/company/figma TikTok: https://tiktok.com/@figma Figma forum: https://forum.figma.com/

[Source](https://www.youtube.com/watch?v=2ZCc4k_IV5w)

Reading summary

At Config 2026, Figma CEO Dylan Field argued that while generative AI lowers the barrier to software creation, designers must take responsibility for raising the ceiling of creative expression. To achieve this, Figma introduced unified canvas tools that treat live code, node-based generation, procedural shaders, and timeline motion as native design materials. Code Layers and Bidirectional Canvas Workflows (10:24) Figma introduced Code Layers, allowing live, executable code to run natively inside canvas frames without external preview windows. Designers and developers can convert static design layers into code, drop new code frames from the toolbar, or import existing GitHub repositories and local folders. The canvas preserves familiar spatial interactions: holding Option and dragging duplicates a code layer into an independent, promptable fork, while selecting multiple frames and pressing Enter executes distinct interactive prototypes concurrently. Teams can also use "Extract Design" to record user interactions across a live application and explode dynamic states into static screens for inspection. Edits made to these extracted designs can be analyzed via an automated delta engine and written back into the code layer using Figma's Make engine. Because Code Layers maintain an active link to GitHub, designers can push visual updates directly back to production repositories, allowing engineers to pull changes into their local environments. Code Layers are scheduled to enter a closed beta in July 2026 for full-seat users across all plan tiers. Node-Based Pipelines and On-Demand Plugins (21:44) Following its acquisition of Weavey, Figma unveiled Figma Weave, an open, node-based canvas for constructing multi-step generative AI pipelines. Addressing the inconsistency of one-shot text prompting, Weave connects media assets and deterministic controls for complex tasks such as 360-degree product video generation, lo-fi wireframe style rendering, and catalog asset harmonization under uniform lighting. Rather than requiring every team member to inspect complex node graphs, creators can collapse these workflows into simplified sidebar tools—such as bulk style transfer or background replacement—for broader team use. Concurrently, the platform integrated generative plugins powered by Figma Agent directly into the canvas. Operating within a file's properties panel without requiring local desktop runtimes, TypeScript authoring, or app store approval, these tools allow designers to generate custom utilities through natural language. Demonstrated use cases include automatic audio waveform randomizers, personalized bento-box grid builders, and client deliverables like Athletics Agency's plugin that renders accurate Formula 1 racecourse geometries from live telemetry data. GPU Shaders for Generative Materials and Effects (36:29) After four and a half years of internal development, Figma added native GPU shader creation to its design engine, leveraging Figma Agent to synthesize graphics code from text prompts or uploaded reference images. Shaders operate in two primary modes: Shader Fills, which serve as base materials like animated water caustics or real-time 3D mesh gradients with on-canvas handles, and Shader Effects, which dynamically warp and distort vector layers or video elements positioned underneath them. Unlike flattened raster filters, Shader Effects preserve the live editability of underlying typography, layout components, and video playback during active rendering. Effects can be stacked and reordered—such as combining a gooey merge with lens distortion—to produce compounding visual transformations. Real-time interactive shaders that respond directly to cursor tracking are planned for release once performance optimization is complete. Native Timeline Animation with Figma Motion (46:42) Developed by the acquired Modify team, Figma Motion embeds a professional timeline primitive directly into the canvas. Designers can toggle into motion mode, activate Auto Key (Shift + K), and manipulate assets on canvas to set keyframes and adjust easing curves in real time while an animation loops. Figma Agent can choreograph multi-frame layouts from natural language prompts or generate custom sequencing plugins, such as offsetting timeline layer entries along custom Bézier curves. The engine also previewed native 3D transforms, introducing keyframeable Z-axis rotation alongside standard X and Y vectors. Motion integrates with Figma's multiplayer architecture by anchoring comments to specific timecodes, propagating nested component edits across active scenes, and broadcasting playhead positions. Furthermore, numeric parameters from native shaders can be keyframed directly on the timeline to generate procedural animations. Handoff to engineering is supported natively via Dev Mode, the Figma Model Context Protocol (MCP), Figma Make, or direct rendering to MP4, WebM, animated SVG, and GIF. Figma Motion, Generative Plugins, Shaders, and Weave tools launched immediately into open beta without consuming AI credits, while Code Layers and forthcoming FigJam and Slides agents entered closed beta waitlists. Field concluded the keynote by announcing that Figma will host its 11th Config conference in Bangalore, India, on October 15, 2026.

Source quotes

[6:59] Dylan Field: Code is not the opposite of design. Code is material for design. [68:09] Dylan Field: AI, it can lower the floor. It's up to all of you to raise the ceiling. [21:44] Itai Schiff: Making something interesting was easy, making something usable for real projects was hard.

Original transcript

[1:57] We grew up in a world that told us, "The future belonged to those who could code." [2:03] Knowing how something should look and feel wasn't enough. [2:07] You had to know how to build it too. [2:10] But now, everything's shifted. [2:14] Code is a material, as shapeable as texture or color. [2:20] And ideas no longer have to wait their turn. [2:24] So now, the question isn't, can it be made? [2:28] it's what would you make if you could make anything? [2:32] You'd probably start by following your curiosity, going wide before going deep, making and remaking until it feels right. [2:44] The point isn't just to make it faster, it's to take it further together. [2:51] The future doesn't just happen, it's built by design. [2:56] together. [2:59] Please welcome to 2026. [3:22] I am so so excited to be here with all of you today and this I don't have to tell you but this is an incredibly special group. [3:33] Truly we have some of the greatest design and creative minds in the world gathered here today. [3:46] And I want to give a special shout out and thank you to everybody who flew in from far away. [3:52] We are honored you're here. [3:53] Thank you. [4:00] Also for those remote, a huge thank you to you as well, whether you're at a Friends of Figma watch party or tuning in remotely, thank you for joining us. [4:10] We know you're here in spirit. [4:17] This is our 10th config and reflecting on how this community has grown, has evolved over the years, honestly just makes me quite emotional. [4:33] and it honestly feels like yesterday that we were introducing hyperlinks to the canvas at our first config in 2020. [4:48] Things felt simpler back then. [4:52] Because Because today, technology is moving faster than ever. [4:58] And as designers, we always question things from first principles, it's how we work. [5:05] And this moment of acceleration, that's no different. [5:10] This is also, though, it's also a time of exploration, new workflows. [5:17] And let's be real, it's a time for some big existential questions. [5:22] design, about creativity, about the world. [5:27] In a moment of such change, community is more important than ever. [5:41] So here's my ask of all of you. [5:46] Go outside of your comfort zone today and tomorrow. [5:52] If you see someone standing alone, not knowing what to do at config, just introduce yourself. [6:00] If you see someone that you really respect, that you know their work, you're a fan, go say hi. [6:06] Ask them, what are you thinking about? [6:09] Don't just catch up with your old friends, make some new ones as well. [6:15] I like that you started the applause there, whoever did that. [6:18] Thank you. [6:20] Config is a unique place, and it's a unique place for so many reasons, but one of them is because everyone here is fundamentally kind. [6:31] This is a community defined by connection and curiosity and care. [6:38] And everyone here viscerally understands, appreciates the value and the importance of design. [6:48] We're all in this together. [6:50] And even if you see someone wearing a design is dead hat, like, they get it too. [6:55] Trust me. [6:59] A few years back, I said, maybe some of you were there, I config that AI will lower the floor and raise the ceiling. [7:10] And I think it's been true, definitely, that AI has lowered the floor. [7:15] Not so sure about raising the ceiling yet. [7:19] So how do we raise the ceiling? [7:22] I look out at all of you. [7:24] You all raised the ceiling. [7:31] And I deeply believe that in the months, the years ahead, there will be an absolute explosion of creativity, risk-taking, and bold expression. [7:45] Much of this creativity will come from all of us assembled here. [7:57] No tool, Figma included, should limit your ability to push your creativity further and bring your ideas to life. [8:08] And here at Figma, we wake up every single day motivated to build the next generation of tools and workflows to enable all you to design to create in a totally unbounded way and that brings us to some very exciting product updates for config 2026 we have focused on two things first First, new materials to express anything you can imagine. [8:48] Second, new tools to shape these materials and to push them further than ever. [8:55] So what do you say? [8:56] Let's get into it, yeah? [9:02] The first material, we got this. [9:09] The first material that we're going to discuss today is one that you all know very well, code. [9:16] One question that has kept coming up throughout the history of Figma, and I think across design community, is when should you work in code? [9:29] For years, the design industry has endlessly discussed this topic of design versus code, And I will just say it flat out right now. [9:39] This is a false debate. [9:43] Code is not the opposite of design. [9:47] Code is material for design. [9:53] For too long, tools have forced a choice. [9:58] And they shouldn't. [10:00] Figma shouldn't anymore either. [10:02] So, to share more about what we mean here, I'd like to please welcome Nico to the stage. [10:24] Thank you, Dylan, and holy shit, hello, config. [10:25] Thank you, Dylan, and holy shit, hello, Config. [10:30] I'm so excited to be here. [10:33] When I was in university in Germany, shout out to Hochschule für Gestaltung Schwäbisch Say it with me, Hochschule für Gescheite, no, just kidding, you don't have to. [10:45] I studied interaction design and code was one of my favorite materials. [10:52] Like I had this one solo project that I really, really fell in love with, I was trying to visualize the gradients of sunrises and sunsets. [11:00] I stayed up multiple nights in a row writing thousands of lines of code to get these effects working. [11:08] What's wonderful to go deep into a rabbit hole with me? [11:13] Fast forward a few years who here remembers this UI Let's go let's go. [11:20] This is Figma when I joined as an intern eight years ago and A couple weeks after don't took me for a walk out here in the other buena actually and asked me to join full-time. [11:32] I call some old colleagues and they were like like, yeah, design tool in the browser, like, and then on Reddit it said, like, oh, that's like a car with three steering wheels. [11:44] And so I was like, I don't know. [11:46] But I actually already was sold, because I had experienced a shift. [11:51] Instead of working alone, I got to jam with amazing designers like Noah, Brady, Peter, and Sho, so, so many side by side. [12:00] with vectors and graphics has moved away from being done in isolation and became this beautiful collaborative activity. [12:11] I believe that we will be experiencing the same shift with code. [12:16] And it is a wonderful material, but while agents have made it so much easier to write thousands of lines of code, the workflows around code are not built for exploring together at all. [12:31] We're working in silos. [12:33] Each one of us is like hundreds of prompts deep with our own agents and then like at some point we look up and we kind of like throw prototype recordings at each other hoping that they'll inspire us only to realize that we're not working together anymore. [12:49] At Figma we know that there's a better way to design and build. [12:54] One in which we can work side-by-side in whatever material we choose, including code. [13:02] So let's take a look at what we've been working on. [13:08] So over here you're probably familiar with an editor like this, right? [13:13] Like you have a prompt box, you have a preview, and you can go pretty deep. [13:17] It's amazing. [13:18] I've I've lost hours in this. [13:19] But you need more space to explore and to compare, to get the bad ideas out so you can find the great ones. [13:27] So we're very, very, very excited to announce that code now lives on the Figma canvas. [13:42] Woo. [13:48] with them. [13:48] Just zoom in, as I'm in right here, and I could just drag around, or over here, I can like interact, see a couple of different weathers. [13:57] Yeah, of course Miami's nice, and welcome to San Francisco, it was foggy this morning. [14:02] So don't forget to bring your layers. [14:08] Ah, see, see, see, yeah, yeah, yeah, I get it, yeah, I get it. [14:12] And it's incredibly easy to create code layers. [14:16] So here I have a design file, a design layer, right? [14:19] And what I can do is I can just click here, and I can click this button, and I can say build this with code. [14:23] That's one way. [14:25] The other way is if you zoom down here, you see there's a new button in the toolbar, right? [14:31] It's the code tool, and it's going to create a code layer for you. [14:36] And just like that, you can start prompting. [14:39] And it's easy, but we know that many of you have existing code bases as well, like prototyping playgrounds. [14:46] And if we zoom over here, select this layer, we can be very excited to announce that we will allow you to import repositories from GitHub or upload local folders directly onto the Figma canvas. [15:04] I'm so excited about that one. [15:08] I am so excited. [15:09] Anyway, anyway, but how do you know that if you have something working, that it's good. [15:16] You need to be able to easily compare, see things side by side. [15:20] We've made that easy, too. [15:22] So we have a couple different explorations. [15:24] And if I wanted to play them all, you can select one and hit Play, select the next one. [15:31] No, just kidding. [15:31] You can select them all and hit Enter. [15:33] And instantly, you have multiple separate code bases running right in front of you. [15:38] Let's interact with a couple of them. [15:40] So over here, we get this nice little glitchy effect. [15:44] Oh, I like the 3D cube. [15:47] Drag some cards around. [15:50] I think my favorite actually is this S-curve. [15:53] Actually, I'm curious now, how did this S-curve was created? [15:58] So when I go in here and I open this, the cool thing now is that because it's in the Figma Canvas, the chat is shared. [16:06] So for example, I can see, oh, Pete was asking what's changed yesterday. [16:11] And oh yeah, nice, Guy explained this S-curve to me. [16:14] This is cool, so I can just catch up too, and I can understand how my colleagues use code and agents to create. [16:22] But I wanna make a riff now. [16:24] Okay, let's go back here. [16:26] Let me show you how you create a branch with code layers. [16:32] You just hold down the Option key and drag the layer. [16:35] That's it. [16:37] This is an interaction you all have done millions of times. [16:44] And so now let's make the change. [16:46] The thing I want to do here is actually... [16:48] Let me just click here. [16:51] Yeah, what should I say? [16:53] Now, when a card is in the center, make the background color fit to the focused card. [16:57] Thank you. [16:59] I like talking to agents because it's just so simple. [17:04] But it'll probably get it. [17:08] OK, but last though, while code layers can be so beautifully deep, we as humans think spatially, right? [17:20] We need to see things side by side. [17:22] We need to see the whole flow at a glance to make the right decisions about what our users should experience. [17:27] So let's take a look at how we can explode this layer. [17:32] So here, I'm going to zoom in and turn the UI on again. [17:36] And what we've done here is we've built this feature extract design, and then I can click on record flow. [17:43] And now, as I'm interacting with this, I can just click over here, go to the profile page, and let's go to the events, and let's click on biking. [17:55] Oh, there's no events found. [17:56] That's a good state. [17:57] Let me work on those. [17:58] And when I click Stop, we will extract all of the states and give you a bird's eye view. [18:13] And so seeing this overview makes it easy for others to understand and help. [18:19] Oh, hi, as if we planned this. [18:21] Hi, Tammy and Peter. [18:23] What's up? [18:24] OK, yeah, you want to help me make some riffs? [18:26] Let's go. [18:28] I'm gonna actually like work down here on this one because the cool thing is like it's just design It's just a design layer So what I can do now is like go to assets click on create it in this library I kind of like want to fix this empty state up. [18:40] So let me drag in this one here to me option H and V To align this but I don't know I don't love this It's a little sad like if there's no events that should be happier that like I can find events, right? [18:53] So let me change this to What did I say? [18:57] I think it was like, oh, yeah find events and let's change the smile Turn the smile frown upside down But this is what I created let me see damn of course they created better things than me But okay, I'll select this one over here and I'll select this one I like these updates and so the cool thing is as you can see down here when we've broken something out from code to static design We can now click update code layers And what this is going to do is it's going to analyze what has changed so our coding agent has the least amount of work to do and Since code layers are connected to github you can push those updates back and And once those updates are in your repository, you can pull those updates from wherever you are. [19:56] Let me see. [19:57] Damn, lots of people in here. [20:01] Nice. [20:02] Okay. [20:03] Because code is now an intuitive material for you all to work with. [20:10] We cannot wait to see what you'll create. [20:14] Personally, I do really hope that you'll make a mess, like a beautiful mess, because this right here really is what enables collaborative creativity. [20:29] This feeling that got me so excited about Figma in the first place. [20:34] And one more thing, these people here and many, many more behind the scenes have worked hard to make this a reality. [20:40] So please give them a big round of applause. [20:54] Every code layer you've seen is powered by Make, which we've been hard at work at improving as well. [21:02] Just in the last few months, we have shipped plan mode, voice-to-text, web search, npm and so much more and just recently we shipped a massive update enabling you to locally on your machine work directly on your production code base. [21:20] With this and code layers we will allow you to go from exploration all the way to implementation. [21:29] Code layers are launching in a closed beta, you can sign up for the waitlist and will start onboarding users in July. [21:37] It'll be available on full seed on all plans, full seed users on all plans. [21:44] Exploring code spatially isn't the only workflow that is coming to the canvas today. [21:51] To tell you about the next one, I'm incredibly excited to introduce Itai Schiff. [21:58] Thank you so much. [22:11] Hello, Config. [22:15] Wow. [22:16] I'm one of the co-founders of Weavey, now Figma Weave. [22:21] We've joined Figma last fall, so it's my first time at Config. [22:27] I'm so excited. [22:28] Before Weave, I've spent 25 years in post-production, first as a VFX artist and then as a creative director. [22:36] I became obviously obsessed with AI, the moment that it could generate my face. [22:43] Well, I was generating like crazy, and I kept running into the same problem, you know it. [22:49] Making something interesting was easy, making something usable for real projects was hard. [22:56] That's because creative work isn't about single prompting, it needs references, iterations, consistency, feedback, and that's why we built Weave, a platform where professionals can build their own creative workflows, their own tools. [23:12] And now it's becoming integrated into the Figma platform. [23:21] Let me show you. [23:31] So this is what creative workflows usually look like. [23:36] Wait. [23:37] Who here worked with node-based interfaces before? [23:40] Raise a hand. [23:41] Whoa. [23:41] Quite a few. [23:42] That's nice. [23:43] Okay. [23:44] For those of you who didn't, nodes in Weave can either hold information, like images, videos, 3D models, or perform an action through AI models, but also through more manual controls, like color grading, timelines, et cetera. [24:02] Let's dive into some examples. [24:04] This simple use case is for generating 360 product videos. [24:09] We start with back and front images of our product. [24:13] We go through a sequence to provide consistency, and we get a smooth 360 video. [24:21] The interesting part, I think, about it is that once you build a workflow like this, you can run it once across all your product and get consistent results. [24:33] Let's look at another one of my favorites. [24:37] It's a fast rendering engine, right? [24:40] Sometimes you want to examine concepts without going through the laborious shading and rendering processes. [24:47] So you add your lo-fi animation here, maybe your logo mark animation and the style reference. [24:54] This is the style reference and quickly you get a stylized render. [25:00] Same animation, new style. [25:04] And if you change the style reference over here and run the flow, you'll get a newly stylized render, right? [25:15] So you can iterate on ideas really, really fast. [25:20] Let's look at one last workflow. [25:23] Imagine a scenario where you get product photos from different vendors, different lighting, different quality. [25:32] It's a mess. [25:33] Normally, you'd make them black and white and try not to think about it, right? [25:38] But with Weave, you can build a workflow, something that looks about like this. [25:46] You can build a workflow for style transfer that analyzes each product and applies the same visual language. [25:52] This is the outcome. [25:53] Look at this. [25:54] The hat, the shoes, the shirt, they now look like they belong together, right, finally. [25:59] And if you change your reference image, you'll get the same set, but rendered with a different style, obviously. [26:08] And I have great news Today we're bringing these weave workflows as tools to the figma canvas Yes, yes Okay, let's see how it looks so in This is the exact style transfer workflow. [26:28] We just saw let's go to the tools and select the bulk trance style transfer We click on the images. [26:34] We want to input into the style transfer We select the style we want to use and we click generate up Shift a okay. [26:46] Okay. [26:46] Let's just put this in place While they render we can examine other workflows or maybe Let me tell you that we took the most popular We've workflows and exposed the inputs and the outputs only right so the same workflow runs in the background You don't have to worry about the noodles anymore. [27:10] You can use them right here on the tools list. [27:13] Oh, this got updated. [27:14] We can see we have our cohesive bunch rendered. [27:18] Let's go quickly over some other tools we have. [27:21] This is the sticker pack. [27:23] It's here. [27:25] You just upload my image. [27:27] You select kawaii, render, and generate, and you'll get my stickers. [27:33] This will work only with my image. [27:35] Don't try it with your own. [27:37] Alright guys Some other tools we have the replace background which performs amazingly you just Upload an image select whatever you want for the background. [27:48] It renders it immediately The texturized one of my favorites anything you upload write whatever texture you want implemented to it and you get it At logo to product you have your logo you can get it rendered on a product simple tools to do simple tasks, or generate mockups from whatever design asset you have. [28:14] But the best workflows, obviously, are the one you build yourselves, tailored exactly to your team's unique creative vision. [28:23] For me this is the most exciting. [28:25] You aren't limited to just the tools we ship. [28:27] Soon you'll be able to package your own creative workflows as tools and share them with your team right here in the tools panel. [28:37] To help you get started, all config attendees will see some extra Weave credits when you sign up. [28:43] Now, some of you may have noticed, yes, it is fun, some of you may have noticed other tools in the list besides Weaves. [28:50] That's interesting. [28:52] To tell you more about them, please welcome Georgia and Raji. [29:06] Hello, Config. [29:07] Let's make some noise. [29:10] Yeah. [29:15] It's super cool being on stage with this queen today. [29:18] This is Georgia Rust, no, not the Rust programming language, but equally as badass. [29:23] She's a product leader at Figma and an amazing friend. [29:26] But this king next to me literally is a king. [29:29] This is Raji King. [29:30] He is an incredible designer and one of my favorite people to build with. [29:35] Georgia, let's not leave these folks on a cliffhanger too long, and let's show them what other tools are in this panel. [29:41] Let's do it. [29:42] If I come over to this tools panel, you'll see some of those new tools that Itai was talking about. [29:46] You'll see Weave tools here, and you'll see a few other tools in here, like plugins. [29:51] It has been so amazing to see the plugins that our community has made over the years. [29:56] But sometimes, it can be hard to find the plugin that you need in the moment, when you need it. [30:01] I just wish it was a little bit easier for me to build the plugin that I need right now. [30:07] So, starting today, you can generate plugins with the Figma agent. [30:12] Now, we all have our own unique workflows, and And we wanted to make it possible for anyone to build the tool they need in the moment, no coding required. [30:21] All right, friends, let's hop on board the Agent Express. [30:26] First destination, plug-in town. [30:30] So Georgia and I are working on an audio app design. [30:34] Georgia, what are you up to? [30:36] Yeah, so I've been working on this design, and you can see I have some cool rectangles here that I've been drawing. [30:42] But I really want them to have that organic look and feel. [30:45] Right now, they're just a little bit flat. [30:47] So I'm going to ask the agent to create a plugin to randomize the height of all frame content so it looks like a real audio waveform. [30:54] And I'm on stage at config, so I don't want it to ask me any questions. [30:58] I just want it to send it and see what it makes. [31:01] I'll send the agent off on its journey. [31:03] And while I do that, I want to tell you a little bit about these plugins. [31:07] Generative plugins are a little bit different than the plugins that you know and love. [31:11] They don't require the desktop app. [31:13] You don't have to write a single line of code, and they can be made with just a few prompts. [31:18] And they live in your file in the properties panel that you can see here. [31:24] You can discover, use, and share these plugins directly in the file, no publishing required. [31:30] Some of the ones you see here were built by me, but some of them were built by my friends. [31:36] A lot of us have our favorite plugins that really help us with our day-to-day productivity. [31:41] And generative plugins are perfect to build for your specific workflows. [31:45] Let's see an example. [31:48] My friend, Miggy, who maybe some of you know, shout out, Miggy. [31:53] He is an amazing designer and a lover of all things layouts. [31:57] And he's building dozens of bentos every day for his specific style. [32:01] To recreate it, he normally has to make a bunch of manual adjustments, tweaking grids, color, spacing, and making sure he's adding the right content. [32:09] So to do this over and over again, he built a new plugin. [32:13] Miggy built this Bento Grid Builder plugin so that if he selects these layers, he can instantly generate a Bento that looks just like the Miggy look and feel. [32:23] Thank you. [32:24] Shout out Miggy. [32:26] He can randomize the layout, reshuffle the images until he gets something that he's happy with. [32:32] Plugins can also be built for your personal needs, for your brand, your workflows, or the data sets that you're using day in day. [32:41] Our friends at Athletics Agency built a plug-in for their client, Alba Racing, to create real-looking racetracks all around the world. [32:51] If you're a big F1 fan, this one's for you. [32:55] Okay. [32:56] They created this plug-in using real data that charts out racetracks around the world. [33:02] I can update the racetrack. [33:04] Let's go to Monaco. [33:06] Change some of the controls. [33:07] Maybe I don't want to have those turns on there. [33:10] and I can adjust the aesthetic to be a bit more of the vibe that I'm looking for. [33:15] Again, this is all built with real data under the hood, so those visuals are staying true to the actual layouts. [33:21] And when this project is handed off, the plugin will go with it. [33:25] Their client gets not only the design file, but the tools that they use to build it. [33:30] Let's check in on our agent. [33:31] It looks like it has something for us. [33:34] If I'm gonna go grab my waveform and open my new plugin. [33:38] Okay, OK, let's see what it made. [33:40] It made me this little waveform randomizer. [33:42] Let's just send it and see what it does. [33:45] OK. Oh, you smashed that button. [33:47] I love that. [33:47] It's a little bit bigger than I'd like. [33:49] So maybe I'll try this on another layer and adjust the height a bit. [33:53] Let's do 50. [33:56] I'll send it one more time. [33:58] All right. [33:59] That's looking way better than what I could do on my own. [34:02] And now I don't have to go and update all of those rectangles by myself. [34:06] There's something here that I love, but I feel like I could take it a little bit further now that I have my first draft. [34:11] So if I wanted to, I could edit this plugin and go back to the agent and continue to rev. [34:16] Let's say I wanted to do something like maybe have a real song that powers this. [34:21] So I could update this to take a real MP3 and make this even more lifelike. [34:27] A lot of us have ideas like this that we would love to have, but we talk ourselves out of building the plugins because it just feels like too much work. [34:34] Building generative plugins makes it possible for you all to say yes to building the tools that you wish existed in Figma. [34:41] That random idea that's specific to only your workflow, you can build it. [34:46] That workflow that might help your co-worker spend five minutes less doing something in their week, just build it. [34:52] Or that idea that sounds too silly to actually create, just try it out, see what happens. [34:57] I wanna show you one more that's one of my favorites. [35:00] I work with this woman, Lauren, who is an incredible engineer. [35:03] She's somewhere here in the audience today. [35:05] And she is an engineer on our team, but is also obsessed with her nail design. [35:10] So for Config, she built a nail design plugin that can generate different nails in the Config aesthetic. [35:17] Let's check it out. [35:19] I can update the style of the nails in this tool. [35:23] Ooh, I like that spiral. [35:25] But I think I want more of like an oval shape. [35:28] I like that. [35:29] And yeah, I can't do long, so let's just generate the medium size. [35:32] All right. [35:34] I can play around with this, maybe take it to my artist and get something amazing that's on brand for config. [35:41] The other thing is, if I want to understand how Lauren built this plugin, I can go back into the agent chat and find the conversation she had to learn how she built this tool. [35:50] I can get an understanding of how she got to the controls she wanted, and I could take it from here to either make it my own. [36:00] The best part about these is that you can build these with any idea that you on the top of your head. [36:05] It can be something unique to you, or it can be something that helps out a friend. [36:10] This is so rad, it's actually one of the coolest ones I've seen, but I get so jazzed when I see my friends making cool stuff with this. [36:17] I love it too, and we have had a wild ride building together the last few months. [36:22] We have had so much fun building generative plugins, it's been amazing to see what our team has done with this, but we didn't want to stop here. [36:29] Yeah, we've been building something else. [36:33] Something that I've wanted in Figma for ages Y'all I can't you. [36:39] Oh, yeah, give it up. [36:43] I Can't even tell you all how long Raji has been talking about this. [36:46] I swear I have been hearing it for months. [36:49] Ah Years. [36:50] Okay. [36:50] I'm sorry years. [36:51] I actually clocked it at about four and a half years And we finally get to talk about it today Does anybody know what it is Nobody. [37:04] Perfect. [37:05] Okay, friends, the next stop on our little journey is shader time. [37:12] Yeah. [37:15] Starting today, shaders are in Figma. [37:18] Now, if you've never heard the word shader before, don't freak out. [37:24] Well, you've definitely seen them. [37:26] Like, this might seem like a simple gradient, but guess how it's made? [37:31] Shaders, progressive blur, that's a shader. [37:37] Our glass effect, shaders. [37:39] I think you're getting the picture here. [37:41] They're wildly powerful at bending pixels to your will, if you know how to wield them. [37:48] And shaders have existed in Figma, living in the shadows of our core canvas rendering. [37:54] Are there shaders in the room with us? [37:57] The catch is that they've been kind of difficult to make. [38:00] Yeah, like geek out on math for four years, difficult? [38:03] I would know. [38:04] If only there was a way to make them yourself. [38:08] Starting today, you can create your own shaders with the Figma agent. [38:16] All right, let's go. [38:18] OK, this is an image. [38:20] All right, so I had this idea for an effect that I want to put on this image in this composition. [38:28] But I don't really know the words to describe it, but I kind of know what it looks like. [38:33] I've seen pictures of it on the internet. [38:35] So I'm going to go ahead and go to my agent, click plus, and I'm going to add images and files. [38:41] And I'm going to grab this here. [38:44] Oop, not that one. [38:46] This one here. [38:47] This is kind of the style I'm hoping for. [38:50] So I'm going to add this into the agent, and I think agents are pretty good at picking up on these kinds of things. [38:55] All right. [38:55] And now I'm going to prompt live on stage. [38:57] so wish me well. [38:58] All right. [38:59] So I'm going to say, create me a, I just want a static effect that looks like the effect in this image. [39:11] I know you love it when I talk out loud like this, it's so cool. [39:15] I'm a bit busy right now. [39:17] Yeah. [39:19] So don't ask me any questions. [39:23] Be nice to your agents guys. [39:24] All right. [39:25] Our UI will ask you questions, and I've actually found it to be amazing. [39:28] Like, it'll ask you and teach you things about shaders. [39:32] And so I love it, but, you know, for now, for now. [39:34] All right, so we're gonna kick this off. [39:36] We'll come back to it. [39:37] All right, so let's talk about the two different kinds of shaders. [39:42] There's shader fills, and fills are like the material. [39:46] They're the actual source coloring and things like that. [39:48] And just think of fills in the same way that you think of fills in Figma. [39:52] Solid colors, gradients, images, stuff like that. [39:54] That's a shader fill. [39:56] now, they're shaders, so a little bit different. [39:58] So we're gonna come into this fill panel here, and I've already added one, this water caustic by Ellie Lin. [40:04] Now, if I open it up, we're gonna see that we have a bunch of different handles to play with, and I do love to slide a slider. [40:12] So what I'm gonna do is just slide away, and I can see different phases of this. [40:18] Not only that, you may have noticed this little thing in the middle, and that's our new on canvas handles, so I can move it around, so you can directly manipulate and play with this stuff. [40:28] We're designers, we want to touch it. [40:30] So what I'm going to do is I'm going to bring up the scale a little bit. [40:33] That was a little much, and I want to do this. [40:36] Maybe bring the intensity down, yeah, a little moody here. [40:40] And of course, it's a fill, so I can add every designer's favorite blend mode, plus slider. [40:46] There we go, and on to the next. [40:49] Now, this may look like just an image to you, but I'm guessing you're smart, and you know it's a shader. [40:55] Now, this is a mesh gradient. [40:57] So when I open this, you'll see all of these color points. [41:00] These are also another kind of on-canvas handle. [41:03] And so if I move this around, it's using 3D math and geometry to create this thing that is not just your grandma's shader. [41:12] It's pretty cool. [41:13] So what I love about this is, when I worked on the Draw team, We used to get a lot of requests for mesh gradients. [41:21] And we wanted to build it, but we just kept pushing it out. [41:24] We're like, we gotta get to it, we gotta get to it. [41:26] What I love about this work stream is that we're building the tools to help you make whatever you want and have your own tools. [41:33] All right, let's talk about effects. [41:36] Now, effects sit on top of the materials. [41:40] And they pull the colors out of it and they transform them. [41:43] They can bend them, shape them, morph them. [41:45] And I'll give you an example of this. [41:47] So let's say I'm working on this carousel. [41:50] I've already added a shader effect here on top of these real Figma layers. [41:57] This isn't an image. [41:58] And you'll notice as I play with the sliders, I can actually warp this. [42:03] And you can actually ask Agent to do whatever you want. [42:06] So I can change the perspective. [42:08] I can also change handle, slide this over and over. [42:13] And I could do this all day. [42:17] All right. [42:18] Moving on, let's move on to the next one. [42:21] Let's say I've got this hero card, and I'm using a lens distortion shader effect. [42:28] Now, what's cool about this is it kind of creates that sci-fi feel, I'm like in a bubble looking through glass, and maybe I just want to take it and really amp it, and then I want to take aberration because I will aberrate the world, and so, oh, woo, all right. [42:42] But you may have noticed that this is a video layer. [42:45] So, let's click Play, and I'm gonna open this effect again, and as an on-canvas handle, and as, oh no, this is better. [42:53] Look at this. [42:55] Pretty, pretty rad. [42:57] All right, now, Georgia is heading to Shader City, and this is her boarding pass. [43:01] Wait, but Raji, can I have first class? [43:04] Oh, yeah, I mean, it's easy, it's a real Figma layer. [43:07] So, but first of all, no middle seats, gotta go window. [43:12] Hey-o. [43:13] All right, so you'll notice this inconspicuous effect here that you would have no idea what it's doing. [43:19] But when I open it, it's called page curl. [43:23] And you can see, and actually, oh yeah, but let's just spin it. [43:30] But not only that, you can bake in the kinds of things or ask agent to do what you want. [43:36] So what if I did texture bleed and I could see the back side of it? [43:40] All right, wait, I think I'm going back to my agent, and let's see. [43:46] All right, we get it. [43:50] Oh, all right, it's asking me for, it's already, I've already got it, so let's find it. [43:55] All right. [43:57] I think it's looking for another one, so we'll see if we can just add another one here. [44:02] And we'll apply it. [44:07] All right, and so we've got a new effect here. [44:09] This one's a little bit different, but it's great. [44:11] Now, the cool thing about this, you know, one-shotting is a little bit difficult. [44:14] Sometimes you don't have the right words, and you can always click this here, go back and edit, and just create this edit loop and keep updating your shaders and your shader effects. [44:23] Now, I've got one last one for you before we're done. [44:28] We've got a bunch of different effects on this brand asset. [44:32] And we can see here that they're stacked. [44:34] And so I'm gonna turn off one of them. [44:36] And we've got this one called GUI Merge. [44:38] And I know how much designers love this. [44:40] We can take these characters and we can blend them together and GUI merge them. [44:44] So we'll do a little bit here. [44:46] But also, we've thrown another lens distortion on there because apparently I'm addicted to that. [44:51] And then, one last one here. [44:54] Notice effects can be restackable. [44:56] So if I put the GUI merge on top, it's actually GUI merging the lens distortion effect. [45:04] And so effects are stackable and you can create incredible different combinations just by reordering. [45:09] Now, let's turn on this other one, Interactive Particles. [45:13] I wonder what this is. [45:16] So, this is tracking your mouse interactions, and it's incredible. [45:22] I love it so very much. [45:24] And if your mind, I do love it. [45:32] Well, if your mind is melted, you're not alone. [45:35] This is just scratching the surface. [45:39] The best shaders are going to be the ones that you dream up on your own. [45:42] And apparently I've loved shaders for years. [45:46] I can't wait to see what you all do with what we built for you, and how far you're going to push it, and how you're going to inspire us with your own creative genius and ideas. [45:55] So whether you've been shader maxing like Raji for years, or this is the first day you heard the word shaders, you can now build the visual effects and fills you've always wanted in Figma. [46:14] And rolling out today, you can now build plugins and shader effects and shader fills with the agent. [46:21] They're available on full seats and all paid plans. [46:24] The interactive shaders, like the one that I was like, whoo, that was fun. [46:28] Those are coming soon. [46:30] So we're going to take the time to get the performance right on those. [46:32] Also coming soon, we'll have publishing to your org and the Figma community. [46:37] And we've made a handful of these for you to try out, and they're going to be available in that tools panel. [46:42] But the most powerful experiences, they aren't just seen, they're felt, they move people. [46:48] That's what drew us to the team at Modify, a brilliant group of folks who have a deep creative passion and technical ambition. [46:56] To share what they've been up to since joining Figma, please help us welcome Piers and Dave. [47:16] We'll be right back. [47:16] Hey, Config. [47:17] I'm Pierce. [47:18] And I'm Dave. [47:20] We are really excited to be here. [47:23] It is exciting. [47:24] And when not one, but two British people tell you they're excited, It means it's really rather exciting. [47:34] It is. [47:36] Today, we get to show you something that we've been working on since we joined Figma from Modify a year ago. [47:43] At Modify, we were a small group of creatives and engineers coming from backgrounds like visual design, music and sound, and real-time graphics. [47:52] And we believe that the future of creative tools could look different. [47:57] A collaborative but highly visual canvas, capable of a whole new level of expression, one that didn't quite exist anywhere else. [48:06] We were obsessed with putting the fun back into design tools, real time and in the browser. [48:13] And that belief drove everything we built. [48:17] It's been a while since we joined Figma, and we've seen a few people on X wondering what's been happening. [48:24] I think we owe them an update. [48:26] I mean, it's about time. [48:29] Oh wait, it actually is about time. [48:34] I mean, quite literally, as we were easing our way into our first few months, we were trying to figure out what the key framing of our focus at Figma should be. [48:48] But then we realized the canvas needed a new dimension. [48:54] dimension. [48:55] Today, we're introducing Figma Motion. [49:12] Over the past year, we've worked with an incredible set of people to build motion directly into Figma. [49:20] The timeline is a new design primitive. [49:23] Key frames, presets, and much more are right at your fingertips. [49:28] And they flow right through design systems. [49:32] Let's jump into a demo. [49:38] Thank you. [49:41] Right, here we are in Figma Design. [49:44] And all I have to do to get into motion mode mode is come down here, toggle, and when I hit space, our designs spring into life. [50:00] Each animation you're seeing here has been made with Figma Motion. [50:06] And it's available to you in beta today. [50:13] From keyframes and easing controls to styles, variables, and components, all the stuff you already love about Figma now has motion. [50:25] Let me show you how easy it is to add animation. [50:30] All I have to do is click the object I want to animate, hit Shift and K to activate Auto key, drag my object. [50:40] Oh, after I've set my timeline, drag my object. [50:46] I can put a little bit of rotation, perhaps a little bit of scale. [50:51] And then, just put this back, when I hit play, place. [51:02] You're gonna find some really familiar controls on the canvas and I can even adjust easing controls as the object is playing. [51:19] And this is really important because animation is one of those things that you really have to feel your way through. [51:27] The timing, the sequencing, the finessing, being able to duplicate and iterate and compare visually right on the canvas really makes all the difference. [51:40] We spent a lot of time getting things like snapping, zooming, panning, drag to multi-select and transform, all behaving exactly as you would expect. [51:53] But we know that building up animations laboriously on the timeline can get kind of tedious sometimes. [51:59] So here, you can also lean on Agent to help. [52:03] I can just drag. [52:04] Whoops. [52:05] Let's say I'm working on animations for these three designs. [52:08] I can just drag to select all of the designs at the same time, jump into Agent, and say something like, fade in all images, slide and fade in text, Concurrently, nice. [52:25] Try and spell that in front of 10,000 people. [52:28] And then fade out again to create a perfect loop. [52:37] And just kick that off. [52:39] I ran this same one shot earlier, so I'll just pan over to the results that we got and take a look. [52:50] Nice. [52:51] That's already looking good. [52:53] OK, but something about it isn't quite right. [52:57] The transition out animation is a bit slow, especially in comparison to the transition in. [53:02] But that's OK, because everything that the agent generates for me is completely editable. [53:07] So I can jump into the timeline, yeah, jump into the timeline, drag to select my keyframes, just adjust that timing, and then take a look at my animation. [53:21] Nice, that's looking a lot snappier. [53:25] As you were watching a minute ago, Agent can also help you build plugins. [53:30] And these are also fully compatible with Figma Motion. [53:33] One of the things I find myself doing all the time is dragging objects on the timeline to adjust timing to bring things in one at a time. [53:41] When you bring everything in at once, it just looks really boring. [53:45] This is really tedious, trying to line all of the blocks up. [53:48] So I prompted a tool to help me with this. [53:50] Let's take a look. [53:52] So I can open the Timeline Keyframe Stagger plugin, Shift-Command-A to select all of my objects, and then I'll just choose a couple of options and click Apply Stagger. [54:06] And just like that, all of my objects are coming in one at a time. [54:14] I can flip the order, maybe, to have things come in from the other direction. [54:19] But if I want to get really fancy, I can also drag to create a shape with a Bezier curve and then apply that to the objects on the timeline. [54:28] So now I have everything coming in following a nice curve. [54:31] I honestly couldn't kind of believe it when I first got this working. [54:34] I think it took maybe four or five prompts to get this tool there. [54:38] So hyped that it worked. [54:39] You can create whatever you need to automate processes that you find yourself doing frequently. [54:45] And once a tool is created, those workflows become fast and repeatable. [54:54] So we've seen how to build motion from scratch and how agents can help along the way. [55:01] But what if I wanted my design to really stand out? [55:09] We're building 3D transforms in Figma. [55:17] X, Y, and Z properties can all be animated. [55:23] Our awesome Vectors team, the same team that bought you Figma Draw last year, are hard at work at this. [55:29] This is just a preview, but it was far too cool not to share with you. [55:35] This is so much fun to play with. [55:38] Look at these controls. [55:40] So much fun. [55:41] look at these controls. [55:42] So much fun. [55:51] Okay, what you've seen so far today is pretty powerful by itself. [56:00] But what makes this really cool is what's underpinning it. [56:05] That's the rest of Figma's platform, because it really does make it feel like a new way of working. [56:14] Let me show you. [56:16] This is a file from our team. [56:20] You can see that there's already some comments here on the canvas, and of course, they now appear on the timeline, too. [56:30] There's also components with animation, And these are nested inside this frame here. [56:40] It looks like we've got a couple of collaborators here. [56:43] I can see Tom. [56:47] Yeah, give it up for Tom. [56:50] And as edits are made in those components, they filter through into the scene in real time. [56:57] Now, let's see what happens if we spotlight Miggy. [57:05] I now see Miggy's position on the timeline, which is invaluable if he's trying to walk me through his motion. [57:16] Thank you, yeah. [57:21] This level of real-time creative control, collaboration, and flexibility hasn't existed in motion design before. [57:33] Another really exciting thing about building all of these capabilities on top of the rest of Figma is what it means for the combination of motion and effects. [57:42] Earlier, we showed you shader effects, which hugely expand the expressive range of Figma. [57:48] Every effect and fill provides a set of properties that you can tweak, and all of those can also be animated. [57:55] So let's take a look at creating a design which combines motion and shaders. [57:59] Here I have a design which animates these three objects. [58:03] I'm quite happy with the motion, but I want to kind of elevate it a bit. [58:08] So I'm going to jump in and just turn on the Outlines effect here. [58:13] As soon as I turn that on, it's applied in real time on top of the animation in my canvas and dynamically respects the motion of the objects underneath. [58:22] So this is the same shader effects you saw earlier, but applied on top of animated content. [58:33] There are properties that I can tweak, which I can do while it's playing. [58:36] But let's say that I want to animate one of those properties. [58:39] I'll go back to the beginning of the timeline, and let's just update key spacing. [58:46] I'll set an initial value. [58:48] Then I'll jump to the middle of the timeline, set a value for the middle. [58:52] And then I'll actually copy and paste that keyframe from the start to the end, just to create a perfect loop. [58:58] And just like that, the spacing is animated. [59:01] And you can even see the slider moving in real time as the animation plays. [59:13] We haven't got to the really cool bit yet. [59:15] All right. [59:17] As Roger was showing you earlier, it's by stacking and combining effects that you can create really next-level results. [59:24] So let's take a look at a couple of designs that take things a bit further. [59:28] This animation makes use of path trimming and Figma draw textured brush strokes to create this type animation. [59:37] It looks pretty great already. [59:38] But again, let's try and turn it up a bit. [59:41] So I'll go into this container and just turn on a couple of effects. [59:46] The noise displacement effect first gives it a bit of wobble, makes it feel a bit more organic. [59:52] And then if I turn on this chromatic aberration effect, we'll get some nice color bleed at the start and end of the timeline. [60:01] So just by turning on those two effects, I've really elevated this design and given it a whole new feel. [60:07] What do you think? [60:09] Yes, that is dope. [60:12] It is dope. [60:13] It is dope, I agree. [60:15] All right. [60:17] Now let's take a look at something a bit more product design oriented. [60:21] For this goal reach screen, we want to reinforce the feeling of really having unlocked this reward. [60:26] So we've combined motion and shaders to make it feel really compelling. [60:32] If I scrub the timeline slowly, you'll be able to get an idea of what's going on. [60:36] The effect can actually distort parts of the design, all while Figma Motion is animating other parts of the design. [60:43] And this is not a video. [60:44] If I jump in and make changes to the text, for example, then everything just updates in real time as it's playing. [60:59] Each of these takes a base design that is built with Figma Motion and combines effects on top, which are also animated with motion, to create expressive and differentiated results. [61:10] I've honestly been losing days just playing with this combination of features. [61:14] It is genuinely hard to believe I'm in Figma sometimes, and often the results that I end up with after spending a lot of time getting deep into exploration are really different from what I first had in mind. [61:26] Now, you're probably wondering, how do we get this motion into production? [61:33] When you're ready to build, switch to dev mode, extract that code directly, or send it via the Figma MCP to your LLM, or of course, Figma Make. [61:50] Here's a design guide site that we've been able to create with some of the tools you've seen here today and the Figma MCP. [61:56] And just to be clear, the animations here have been shipped in code. [62:10] But if shipping to code isn't quite your cup of tea, you can export as MP4, WebM, Animated SVG, or GIF. [62:22] Got to love those GIFs. [62:28] And we're already working on delivering more formats and export types. [62:35] All right, so Motion is rolling out today in beta on all plans and full seats. [62:42] We... [62:44] Obligatory phrase, we cannot wait to see what you do with it. [62:48] And before the end, we wanted to show you what's possible and just give you a little bit of inspiration. [62:54] So we gave our incredibly talented brand team the combination of shaders and Figma Motion, And they used them to animate the entire launch film. [63:04] What you're seeing on screen at the moment is kind of the behind the scenes, like inside the Figma file. [63:10] And we kind of couldn't believe it when we started looking inside this file and seeing what they'd created. [63:15] It's so cool to start to see these features being used in practice. [63:19] Making motion a reality has brought together a huge number of people from many different parts of Figma. [63:26] And we are so proud not only to be able to share all of this with you today, but also to see what our internal teams have been able to start doing with it. [63:35] Next up, you'll see the finished film. [63:37] Before Dylan comes back to the stage, we would love for you to watch it. [63:41] Thank you. [63:42] Thank you. [64:56] ♪ Wow, that was awesome. [65:01] Motion designers are just so talented. [65:04] I have always had the deepest respect for motion designers. [65:08] They are able to create things that others cannot even articulate or explain, let alone replicate. [65:16] And so many of us have always wanted to be able to also make that kind of magic, yet it's felt out of reach. [65:26] I've been amazed as we've developed Figma Motion, how intuitive it feels, and also how it feels intuitive despite how powerful it is. [65:37] So I really hope that Figma Motion can inspire all of you. [65:42] And I cannot wait to see what all of you make with Figma Motion. [65:55] So throughout all the demos, you may have noticed once or twice Figma Agent at work. [66:02] Yesterday, it rolled out to everyone. [66:06] And it's evolving really fast. [66:08] The Figma agent also supports attachments and connectors, as well as attachments. [66:17] Now, connectors let you pull in context from all sorts of other tools. [66:22] And we've launched them with Notion, Slack, Granola, Hex, GitHub, and Atlassian. [66:29] So now you can pull data from all those surfaces right into your designs. [66:36] Custom skills are also now a part of the agent. [66:40] And yes, I am so excited about skills. [66:45] Honestly, I think we could have done an entire keynote just on skills. [66:50] With skills, you can turn the prompts that you keep coming back to into reusable slash commands. [66:58] And whether that's checking for compliance or creating a synthetic user test, or capturing a workflow that you're doing all the time, and you want to automate for your team, this is such a booster. [67:10] And we've been using them all over Figma in our process. [67:13] I'm really excited for you all to try them out. [67:15] Woo. [67:21] But of course, we're not going to stop there. [67:26] What if the Figma agent wasn't just for Figma design? [67:31] What if it could translate your code base into structured diagrams? [67:35] That'd be cool. [67:36] Distill loose ideas into prioritization and next steps, timelines even, or turn customer briefs into on-brand pitch decks, or more. [67:49] So yes, coming soon, we will have the FigJam agent agent and the slide agent. [67:56] And I'm really, really excited to share more about this with you at a later date. [68:00] Woo. [68:07] All right. [68:09] Today, we introduced new materials and new tools to the Figma canvas. [68:15] To recap, Figma Motion, generative plugins, shaders, and Weave tools are now in open beta. [68:22] Go try them out. [68:23] check them out, give us all the feedback in the world. [68:26] None of these updates will consume AI credits while in beta. [68:31] Woo. [68:38] Coming soon. [68:39] Code layers, the FigJam agent, the Slides agent. [68:43] These are all coming soon in closed beta. [68:46] So if you're wanting to be first in line to try these out, Go sign up for early access, figma.com slash config dash betas with an S. I'll just give you all a second. [69:03] All right, you got it. [69:06] There's so, so much more to all the launches. [69:09] We could have gone endlessly deep on each one of them. [69:13] And so I hope you'll have a chance to talk more of the team. [69:17] Stop by the product studio. [69:19] It's right outside that way. [69:21] To talk with the Figmates who built these features, they would love to chat with y'all and get your thoughts, your feedback, your reactions. [69:28] It's what we live for is user feedback. [69:31] But also, check out the deep dives if you have something that you're really interested in checking out and learning more about. [69:37] And you can go deeper on everything we've covered. [69:39] We've got a bunch of them in the agenda. [69:43] Everything you saw today, code, motion, your own tools, your own materials, it all lives together in the canvas. [69:53] For the first time, it's in one place. [69:57] All of these materials, they compose together, and that allows you to riff and to play at the speed at which you think. [70:12] So now the canvas is more than where your work lives. [70:17] it's also where it all connects. [70:20] Like I said earlier, AI, it can lower the floor. [70:24] It's up to all of you to raise the ceiling. [70:27] And our goal is to give you all the power you need to push that ceiling right to the stratosphere. [70:37] So, go make something that only you can make. [70:44] And please join me also in thanking all the Figmates who made today's launch as possible and also config possible. [71:02] I have so much gratitude for our amazing team, and yes, we're hiring. [71:07] We also have so, so, so much incredible programming to come over the next today and tomorrow. [71:14] Really look forward to meeting many of you, and I can't wait to hear what you think of all the talks. [71:20] One last thing. [71:23] I talked about how this is our 10th config. [71:26] We're excited to go on the road later this year for our 11th config. [71:32] So if you want to join us, on October 15, Come to Bangalore, India. [71:46] All right, y'all, that's a wrap. [71:47] Thank you again, and happy config.