Figma introduced a native Motion Timeline directly inside the canvas, featuring in-context playback, auto-keyframing, Bezier easing curves, and pre-composed animation presets. (5:50)
Motion now integrates into Figma design systems via dedicated Timing and Easing variables, allowing animation curves to adapt dynamically across variable modes such as light and dark themes. (26:51)
Real-time multiplayer co-editing extends to animation timelines, featuring playhead-synchronized Spotlight mode and frame-accurate timeline commenting. (18:00)
Figma Agent and Model Context Protocol (MCP) integrations enable natural-language motion generation and direct export of timeline parameters into production codebases and external LLMs. (13:56)
Handoff workflows receive an overhaul with an Animated export tab supporting MP4, WebM, GIF, and animated SVG, alongside a dedicated read-only Dev Mode timeline displaying CSS and React Motion snippets. (38:59)
Detailed notes
## Background
Published by Figma on YouTube on June 26, 2026, this Config 2026 session explores Figma's native motion design tooling. According to the video description, the deep dive demonstrates how to create flexible, componentised, on-brand motion content inside Figma, covering the new Motion Timeline, agent-connected capabilities, production export options, and upcoming features.
## TL;DR
Figma motion team members Luca, Daniela, and Dave unveil Figma's built-in Motion tooling, introducing a bottom-docked Motion Timeline equipped with precise keyframing, custom easing, canvas-based motion handles, and pre-composed animation styles. They demonstrate collaborative workflows including real-time multiplayer editing with timeline-stamped comments, AI-assisted keyframing with Figma Agent, and motion variables for tokenizing easing and timing across appearance modes. The presentation highlights how motion integrates into nested components, shader fills, and prototype triggers without breaking upstream design tokens. Finally, the team showcases production exports across multiple video formats, Dev Mode inspections, and Model Context Protocol (MCP) code pipelines, followed by an upcoming roadmap featuring custom shareable motion styles and dedicated text animation.
## Atmosphere & style
The presentation carries the buoyant, celebratory momentum of a flagship Config session, blending high-fidelity live demos with casual, self-deprecating banter between Luca, Daniela, and Dave. Seamless moments of real-time multiplayer canvas manipulation and AI prompting generate spontaneous audience reactions, giving the technical walkthrough an accessible, workshop-style intimacy. Watching the presentation feels fast-paced and pragmatic, capturing the tangible excitement of designers and engineers seeing an integrated motion workflow come together live on stage.
## Bulletin
- [05:50](https://www.youtube.com/watch?v=3evAfmLVZK8&t=350s) Figma introduced a native Motion Timeline directly inside the canvas, featuring in-context playback, auto-keyframing, Bezier easing curves, and pre-composed animation presets.
- [26:51](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1611s) Motion now integrates into Figma design systems via dedicated Timing and Easing variables, allowing animation curves to adapt dynamically across variable modes such as light and dark themes.
- [18:00](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1080s) Real-time multiplayer co-editing extends to animation timelines, featuring playhead-synchronized Spotlight mode and frame-accurate timeline commenting.
- [13:56](https://www.youtube.com/watch?v=3evAfmLVZK8&t=836s) Figma Agent and Model Context Protocol (MCP) integrations enable natural-language motion generation and direct export of timeline parameters into production codebases and external LLMs.
- [38:59](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2339s) Handoff workflows receive an overhaul with an Animated export tab supporting MP4, WebM, GIF, and animated SVG, alongside a dedicated read-only Dev Mode timeline displaying CSS and React Motion snippets.
## Key takeaways
- [05:50](https://www.youtube.com/watch?v=3evAfmLVZK8&t=350s) The Motion Timeline lives directly below the main Figma canvas, enabling real-time manipulation, scrubbing, and looping without entering an isolated preview mode.
- [07:38](https://www.youtube.com/watch?v=3evAfmLVZK8&t=458s) Pre-composed animation styles allow designers to stack multiple transforms like position, scale, and opacity without duplicate tracks.
- [09:25](https://www.youtube.com/watch?v=3evAfmLVZK8&t=565s) Manual spatial choreography is governed on-canvas via the directional handle 'Mo' alongside Bezier smoothing handles triggered by Command-dragging keyframes.
- [13:56](https://www.youtube.com/watch?v=3evAfmLVZK8&t=836s) Figma Agent processes natural-language prompts to generate multi-layer keyframe sequences and can vectorize typography for automated staggered transitions.
- [18:00](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1080s) Timeline comments automatically inherit active playhead timestamps, establishing persistent visual markers on the timeline ruler for asynchronous feedback.
- [20:36](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1236s) Multiplayer Spotlight synchronizes timeline playheads across remote machines, maintaining native-resolution local playback during collaborative review calls.
- [22:03](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1323s) Auto-keying monitors property adjustments across color, stroke width, path trim, arc data, and shape point counts, committing keyframes automatically.
- [26:51](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1611s) New Timing and Easing variable types allow animation tokens to be managed centrally and mapped to appearance modes such as standard, expressive, or smooth.
- [28:36](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1716s) Component-based motion architecture ensures upstream token and style changes propagate down through complex nested compositions without resetting keyframes or easing curves.
- [31:20](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1880s) Native prototyping interactions hook directly into animated components, allowing clicks, hovers, and scrolls to trigger timeline play, pause, and playhead positioning.
- [33:17](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1997s) Figma shader effects expose procedural properties, such as cloud phase, as independently keyframable attributes in the Motion Timeline.
- [35:43](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2143s) Figma Make accepts pasted animated components as prompt attachments, generating matching production code for libraries like React motion.dev.
- [35:43](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2143s) Exported motion renders can feed into Figma Weave node graphs to execute AI image style transfer while locking down original timing vectors.
- [38:59](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2339s) The overhauled Animated export tab supports MP4, WebM, GIF, and animated SVG, with Pro Plus tiers unlocking up to 4K resolution at 60 FPS.
- [38:59](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2339s) Dev Mode features a dedicated, read-only inspection timeline that outputs production-ready CSS keyframe and React Motion code snippets.
- [40:57](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2457s) Model Context Protocol (MCP) templates permit direct handoff of timeline JSON—including precise timings, curves, and colors—to external LLMs to build functional web applications.
- [42:01](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2521s) Upcoming roadmap features include organization-wide shareable animation styles, fine-grained state transition controls, dedicated text motion tools, and native timeline video support.
## Detailed walkthrough
### [00:13](https://www.youtube.com/watch?v=3evAfmLVZK8&t=13s) Welcome to Config and Introducing the Motion Team
Config hosts George Rust from Figma’s product team and Meena Anand Seshadri from the research team take the stage to welcome attendees across global time zones and celebrate the energy following the morning keynote. Sensing the room’s creative excitement, Meena surveys the crowd to see who is already eager to try out or revisit features revealed just an hour prior. Before rolling into the afternoon lineup of artists, designers, engineers, and product teams, Meena reminds the audience to silence their mobile devices and lean into the collaborative community around them. As Meena points out, “Some of the best ideas that you have out coming out of the next 2 days might come from the person sitting right next to you.”
To kick off the afternoon track, George and Meena introduce the creators behind one of the morning's standout announcements: the Figma Motion team, comprising Dave, Daniela, and Luca.
[03:19](https://www.youtube.com/watch?v=3evAfmLVZK8&t=199s) Setting the Stage and Alpha Showcase
Luca, an engineering manager on Figma's motion and interaction design teams, and Daniela, a designer on the team, take the stage to rapturous applause following an animated intro reel created entirely inside Figma. Luca explains that team member Dave was unfortunately held up following the keynote and might join later, but he rallies the audience to dive straight in. Daniela outlines the session agenda, which spans simple animations, multiplayer collaboration and commenting in motion, complex multi-layered animations, brand-new motion workflows, production export options, and a sneak peek at upcoming features.
Before opening the software for a live demo, Luca showcases work created during the private alpha by the internal Figma team and external design partners to demonstrate the tool's versatility across product UI and visual design:
- **Fabian’s App Intros:** A suite of onboarding and micro-interaction animations combining auto layout, color styles, vector effects, and keyframes.
- **Component Compositions:** A layered motion scene demonstrating how nested Figma components can stack distinct animations together.
- **Fifi’s Product Animations:** In-product animations built natively in Motion that officially shipped inside Figma that very day.
- **Adonna’s Variable Icons:** An animated iconography set utilizing Figma variables and modes, allowing designers to toggle color themes dynamically while keeping motion sequences fully intact.
- **Character Animation:** A stylized, vectorized Frankenstein monster face pairing vector paths with layer effects for expressive, spooky motion.
- **Igor’s Motion Exploration:** A high-fidelity animation piece that arrived right before the presentation, highlighting the fidelity possible in the tool.
[05:50](https://www.youtube.com/watch?v=3evAfmLVZK8&t=350s) The Motion Timeline and Canvas Workspace
Daniela opens the live canvas to walk through the fundamental building blocks of motion, demonstrating how straightforward it is to bring static designs to life. As Daniela emphasizes, “Adding animation to existing designs is actually pretty easy.” Entering the mode is as simple as clicking the new motion icon located in the bottom toolbelt. Once toggled, the Motion Timeline appears directly below the canvas.
The timeline interface is designed for real-time manipulation directly on canvas without entering an external preview mode. On the left side of the timeline, users have instant playback controls and an auto-keyframing toggle. A numerical input displays the playhead's current time position alongside the composition's total duration, which designers can adjust by typing an exact timestamp or by dragging the duration handle directly. The time format is flexible and can be toggled between frames and seconds depending on user preference. Playback options also include looping modes, such as standard infinite looping or ping-pong. To optimize viewport real estate, layers in the timeline can be collapsed, the overall timeline height and zoom scale can be resized, or the entire tray can be minimized when designers need maximum canvas space.
```mermaid
flowchart LR
accTitle: Figma Motion Interface Architecture
accDescr: Diagram showing the layout of Figma Motion Mode, linking the toolbelt, canvas, properties panel, and the Motion Timeline controls.
subgraph Toolbelt["Figma Interface"]
ModeIcon["Motion Mode Icon"]
end
[07:38](https://www.youtube.com/watch?v=3evAfmLVZK8&t=458s) Animation Styles and Stacking Presets
The inspector panel on the right mirrors standard Figma design properties, purposefully minimizing context switching between static styling and animation. Every animatable design property—such as dimensions, position, and opacity—now features a diamond-shaped keyframe stamp adjacent to its input field. Below the standard attributes sits a dedicated section titled Animation Styles, which provides pre-built motion presets for rapid authoring.
Demonstrating on a static illustration, Daniela clicks the plus icon within Animation Styles to immediately apply a position animation. A flyout menu reveals fine-tuned controls for movement distance, delay, and duration, which can also be adjusted by dragging the timing handles directly within the timeline tracks. The system intelligently differentiates stacked styles: hitting the plus button repeatedly adds complementary transforms such as scale, rotation, and opacity fades rather than duplicate tracks. Once stacked, hitting spacebar or the play button executes the layered animation immediately on the design canvas.
[09:25](https://www.youtube.com/watch?v=3evAfmLVZK8&t=565s) Precise Keyframing, Easing, and "Mo"
While preset styles offer speed, Luca explains that granular craft relies on manual keyframes. To animate a property manually, the designer parks the playhead at the starting timestamp and clicks the diamond stamp next to the desired attribute in the properties panel. Moving the playhead forward in time allows the designer to place an ending keyframe either by stamping the panel again or by physically dragging an on-canvas directional handle nicknamed "Mo." As Luca quips, “We call him Mo. He's a We're a big fan of Mo.”
A raw two-keyframe translation generates a rigid linear transition. To make the movement natural, designers select the easing bar spanning between the keyframe diamonds on the timeline track, which surfaces the easing adjustment panel in the inspector. Daniela and Luca select a classic ease-in curve to build acceleration toward the end of the travel path. Luca notes that custom bezier curves and overshoot controls are fully supported: ramping up the overshoot parameter forces the object to deliberately travel past its terminal coordinates and spring back into position, producing a responsive, elastic finish. With the basic path established, Luca observes that “two key frames does not an animation make” and prompts Daniela to insert additional intermediate keyframes along the path using Mo to introduce richer choreography.
[11:25](https://www.youtube.com/watch?v=3evAfmLVZK8&t=685s) Smoothing Motion Paths and Pre-Composed Animation Styles
The presenters demonstrate how to refine raw, bouncing keyframes into natural motion. After adding a few keyframes to give an object an energetic pop and bounce with overshoot, the resulting path appears jagged. To fix this, Figma enables smooth curve handles directly on the canvas: hovering over any keyframe and holding down `Command` while dragging pulls out handles that convert sharp trajectory corners into smooth Bezier curves. Repeating this on every keyframe grants fine-grained control over the exact spatial path of the animation.
Beyond building animations manually with keyframes, Figma introduces a built-in library of pre-composed animation styles accessible from the animations panel dropdown right beside the plus icon. Designed for users who might not know where to start on a static node, the library organizes motion into entrance, cycle-based, and exit animations. Demonstrating an entrance style called "Slam" (which drops an element in aggressively from the top), the presenters note that presets can be easily adjusted; dragging the preset bar to extend its duration automatically scales and moves all underlying animation timings in sync. On the canvas, they show an array of roughly 12 to 16 styles available at launch, inviting community feedback and teasing future capabilities where organizations will be able to author custom pre-composed styles for their design systems.
- **Command-drag keyframe handles:** Holding `Command` while pulling on a canvas keyframe point instantly smooths the motion curve.
- **Preset categories:** Pre-composed styles are categorized into entrances, cycle-based loops, and exits.
- **Synchronized timing adjustments:** Extending or compressing a preset bar proportionally scales all internal animation properties and keyframes.
- **Future org-level presets:** Figma plans to enable design teams to package and distribute their own custom brand presets across their organizations.
[13:56](https://www.youtube.com/watch?v=3evAfmLVZK8&t=836s) AI-Driven Motion with Figma Agent
Tying into Figma's platform-wide agentic features, motion design now integrates directly with the Figma Agent. Selecting vector nodes exposes an agent icon where users can enter natural-language prompts to generate animations from scratch. On stage, the team selects a vectorized five-piece Figma logo and submits a playful prompt: “We're on stage at Config. Please don't screw this up for us. Make it fly in from the sides.” While the prompt processes in the background, they walk through several production-ready examples that illustrate how designers can partner with the agent to avoid repetitive timeline setup:
```mermaid
flowchart TD
accTitle: Figma Agent Motion Workflows
accDescr: Three distinct workflows showing how Figma Agent generates, augments, and composes motion.
subgraph Iteration["1. Rapid Concept Riffing"]
A["Vector Graphic"] --> B["Prompt Figma Agent"]
B --> C["Generate Multiple Variations"]
C --> D["Manual Timeline Refinement"]
end
subgraph Hybrid["2. Hybrid Production Workflow"]
E["Manual Keyframing (e.g., C-O-N-F-I-G)"] --> G["Final Combined Asset"]
F["Agent-Generated Micro-Bits (O element)"] --> G
end
The speakers emphasize that the agent eliminates the tedious upfront work of laying down dozens of foundational keyframes. In one example created by brand animator Jill, the letters of the "Config" wordmark were animated by hand, but the complex "O" logo contained dozens of tiny points requiring intricate show/hide timing. Jill prompted the agent to build smaller, reusable animated components, which were then stacked and integrated into the primary brand mark. Another showcase highlights work by Daniela, who prompted the agent to generate an entire matrix of stylistic riffs on an 8-bit pixelated Figma logo to explore different creative vibes before committing to manual timeline adjustments.
- **Deep property awareness:** The Figma Agent understands keyframes, easing curves, and timeline properties, allowing designers to request specific mechanical tweaks.
- **Speed-mode tradeoffs:** Prompting the agent to speed up skips multi-step clarifying reasoning, whereas standard prompts allow the agent to ask clarifying questions before generating motion.
- **Text sequencing utility:** While Figma Motion lacks a dedicated typography animation suite, the agent can automatically convert live text into vectors, generate separate entrance/exit transitions per letterform, and stagger multi-shot compositions onto a single master timeline.
[18:00](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1080s) Real-Time Multiplayer Motion Collaboration and Timeline Comments
Once the live demo agent completes its work on stage—producing an entrance where the logo pieces fly in from the canvas margins—the speakers explain how iterative prompting can further refine physical nuances (such as requesting the orange and red elements to slam harder or forcing the green segment to enter strictly from the bottom). They then pivot to Figma’s core strength: real-time team multiplayer collaboration within motion timelines.
Joining the canvas remotely is team member Dave, illustrating how real-time co-editing behaves inside the Motion Timeline. When Daniela leaves feedback on Dave's cursor animation, Figma automatically stamps the comment with the exact current playhead position (`0.8s`). Additional timestamps (e.g., `0.4s`, `0.5s`) can be attached from the comments panel directly to the timeline ruler. When Dave addresses the comment, the presenters and audience observe his changes live: as Dave drags the cursor's position on the canvas, the vector motion path and its easing curves recalculate instantaneously. The speakers highlight the clarity of this workflow:
> “And that time is reflected not only in the comment, but also on the timeline. So, you can easily kind of grok like where are my, you know, collaborators asking me to make an addition or a change, right?”
- **Timestamped feedback:** Comments left while inspecting an animation automatically inherit the active playhead timestamp and render persistent visual markers along the timeline.
- **Real-time path and curve rendering:** Spatial motion paths and property curve adjustments update simultaneously across all connected multiplayer clients without requiring canvas refreshes or re-renders.
- **Spotlight support:** Motion mode fully supports Figma's spotlight feature, enabling team leads or animators to guide collaborators through playback and timeline inspections in real time.
[20:36](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1236s) Multiplayer Collaboration and Real-Time Spotlight
The session demonstrates multiplayer collaboration in motion design by clicking on Dave to follow him on the canvas. When Dave triggers a spotlight, the timelines between Dave’s machine and the presentation machine synchronize completely. This setup allows teams to build animations together over a video or voice call without sacrificing visual fidelity or frame rates; the motion renders natively on both ends in real time. If Dave scrubs the playhead, everyone on the file sees the exact frame simultaneously.
Luca banters about how impressive this is to witness, noting, “It's all right. I think it's sick sick for a PM, that sounds good. You know how many PMs I want to talk.” Dave then steps out from backstage onto the stage to applause, joking about his delay: “HEY, LIKE GUYS, I'M so sorry I'm late. I was I was just backstage practicing how to say beta. Beta?” After recapping that they have already addressed animation styles, keyframes, granular control, collaboration, and agent capabilities, Dave transitions into deep-dive property manipulation.
```mermaid
flowchart LR
accTitle: Real-Time Timeline Spotlight Flow
accDescr: Shows how Dave's machine syncs timeline playhead and animation rendering to the collaborator's machine.
subgraph Follower["Follower Machine"]
B --> C["Mirror Playhead Position"]
C --> D["Native Local Render"]
end
```
[22:03](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1323s) Auto Keying and Animatable Properties
Dave introduces the auto keying workflow to eliminate the friction of manual keyframing. Pressing the auto key button on the timeline arms all keyframe properties in the right-hand panel, instructing Figma to watch the canvas and the properties panel for updates. Any adjustments made—such as changing position, rotation, or opacity—automatically generate and stamp keyframes on the timeline without extra clicks.
The team demonstrates a series of animatable properties across design assets:
- **Color**: Transitions can be animated directly, demonstrated through a whimsical, hypnotic graphic on the main screen that Luca notes “really draws you in.”
- **Stroke Width**: Stroke properties retain their standard placement in the properties panel but now include an inline keyframe stamp button. Dave jokes that animating strokes “always reminds me to buy some new blinds.”
- **Path Trim**: Originating from Figma Draw, path trim allows creators to animate start and end positions independently. The motion team elevated these controls to the top level of the properties panel in motion mode. Dave highlights an intricate kinetic path piece created by their colleague Piers, as well as a path trim graphic featured in the Config keynote.
- **Arcs**: When animating shapes with arc data, Daniela clarifies the three core animatable values: start, sweep, and ratio. This functionality is tailored for building dynamic gauges, circular progress bars, and dashboard visualizations.
- **Points on a Shape**: The polygon point count property can be animated live (for example, morphing a shape from 3 points to 6 points, or 4 points to 6 points) to create rotating cog icons and geometric transformations.
Dave summarizes the creative potential of stacking these controls: “One of the tricks that you can use is to combine styles and keyframes together.” He highlights an example where an object's scale is dictated by manual keyframes while its continuous rotation runs on a motion style preset.
[26:51](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1611s) Motion Variables: Easing, Timing, and Theming Modes
Figma Motion introduces two dedicated variable types: **Easing** and **Timing**. These variables can be authored directly within the central variables panel, or assigned on the fly from the style properties panel and the keyframe easing menu. Centralizing timing and easing curves as variables allows motion systems to be tokenized and updated globally across an entire product design system.
The presenters showcase how these motion variables interface with variable modes. They demonstrate three distinct motion modes applied to the same UI component:
- **Standard**: A baseline, production-ready motion behavior.
- **Expressive**: A livelier, bouncy, exaggerated motion feel.
- **Smooth**: A subtle, gliding transition curve.
By pairing motion variables with standard appearance modes, teams can link specific animation curves to visual themes. Dave emphasizes this flexibility: “So, what this means is that if you want your dark mode animation a different vibe to your light mode, you absolutely can.” Daniela tests swapping between expressive and smooth settings before locking in smooth paired with dark mode. With his section complete, Dave departs the stage, joking: “I need to go and do some really important PM stuff like stand over an engineer and ask them if it's finished yet.”
The session shifts to examining how Figma’s component architecture scales motion design across teams. Luca explains that the Config intro video was authored entirely inside a real brand motion Figma file using componentized motion workflows. Rather than working in isolated external software files that must be exported and re-shared, the brand motion team broke down the composition into individual pages and modular components.
```mermaid
flowchart TD
accTitle: Modular Component Motion Hierarchy
accDescr: Illustrates how micro-animations feed into component instances to construct full motion compositions.
In this production pipeline, designers animated discrete steps—such as an opening flower bloom—inside a base component with internal keyframes. They then pulled instances of those animated components into higher-level artboards, stacking them sequentially. Luca highlights why this replaces legacy workflows: “So, it's a really awesome to work in this way with a large team. You're not stuck in your own file on your machine having to copy and paste and send those around for motion, which is just kind of an antiquated workflow.”
Daniela critiques the intro composition's palette, noting that the central flower does not align with the surrounding pink cards. Luca walks through the solution: because the animation is constructed with nested component instances, updating a single fill color on “Circle 4” inside the root component propagates the color change instantaneously throughout every downstream animation stage in the composition.
[31:20](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1880s) Design Systems Integration and Prototyping Controls
The session opens with a demonstration of how motion integrates seamlessly into component and design system workflows within Figma. When an upstream color or token changes in a design system component, that change cascades all the way down to the final composition without destroying or resetting any of the existing animation keyframes and timing curves. As the presenter points out: “You don't have to worry about, you know, a design changing upstream and then having to bring that down into a separate product in order to kind of keep your designs in check.”
```mermaid
flowchart LR
accTitle: Component Animation Workflow in Figma
accDescr: Diagram showing how upstream design system components pass style changes down to animated components and prototyping triggers without losing animation data.
subgraph DesignSystem["Design System"]
A["Master Component<br/>(Styles & Tokens)"]
end
subgraph PrototypeEngine["Prototyping Tab"]
D["Interactive Triggers<br/>(Clicks, Hovers, Scrolls)"]
E["Timeline Actions<br/>(Play/Pause, Set Playhead)"]
end
A -->|"Cascade changes"| B
B --> C
B --> D
D --> E
```
Beyond static components, animations plug directly into Figma's native prototyping tab. Demonstrating a sample flow with a simple move-in animation between frames, the speakers show what happens when you click the "Add Goal" button: it reveals a nested animation frame playing smoothly inside the prototype. Furthermore, animated components expose specialized interactive triggers and actions. Designers can attach standard events—like clicks, hovers, or scrolls—to toggle animation playback, pause the timeline at specific moments, or set the playhead position directly.
- Upstream component color/style changes propagate down to animated instances without losing animation curves or timing context.
- Prototyping interactions support playback control actions, including playing, pausing, and scrubbing/setting the timeline position.
- Standard interaction triggers (click, hover, scroll) hook directly into the timeline controls of nested animated components.
---
[33:17](https://www.youtube.com/watch?v=3evAfmLVZK8&t=1997s) Animating Shader Effects and Building Timeline Plugins
The presenters transition from core prototyping to pairing motion with Figma's new shader effects. Focusing on a frame filled with a dynamic "Cloud" shader, they show how setting just two keyframes on the shader's `phase` property produces a rich, undulating procedural texture. Every parameter of a shader fill can be adjusted and given its own set of keyframes, allowing complex visual effects to evolve dynamically over time. The speaker notes that while an experimental easing curve didn't turn out quite right on stage, the flexibility to manipulate properties directly inside the timeline creates endless possibilities, urging the audience to attend the dedicated effects deep dive later in the conference.
Moving on to timeline extensibility, the speakers highlight a custom stagger animation tool developed by their teammate Miggy. Controlling four circles manually across two timeline tracks is straightforward, but orchestrating 10, 100, or more elements quickly becomes tedious. Miggy’s plugin provides a dedicated property panel where designers can select multiple animated elements and adjust stagger timing, delay offsets, overall durations, and easings simultaneously. Crucially, the plugin does not abstract away or destroy the underlying timeline structure; designers retain full visibility and manual control over every individual keyframe and preset on the main canvas timeline.
- Shader fills expose granular procedural parameters (such as `phase` in the Cloud shader) that can be animated with independent keyframes.
- Miggy's timeline plugin introduces a specialized panel for bulk stagger delays, duration manipulation, and easing adjustments across dozens or hundreds of layers.
- Plugin manipulations stay non-destructive, leaving all standard timeline keyframes visible and editable directly in Figma.
---
[35:43](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2143s) Cross-Product Workflows: Figma Make, React Motion, and Weave
Figma's motion capabilities are built to extend outside the main canvas into broader ecosystem tools, starting with Figma Make. Demonstrating this bridge, a presenter copies an animated component from Figma, opens a new Make file, and pastes it in with Command-V as an attachment. By passing both design styling and animation parameters, designers can prompt the model—asking it, for example, to “Let's recreate this animation with React motion.dev.” Figma Make interprets the underlying timings, styles, colors, and design tokens, translating the Figma timeline directly into production-ready front-end animation code or functional prototypes.
```mermaid
flowchart TD
accTitle: Exporting Motion to Make and Weave
accDescr: Flow diagram showing how an animated Figma component is converted to code in Figma Make or processed through video style transfer in Figma Weave.
subgraph MakeWorkflow["Figma Make Pipeline"]
B -->|"Copy & Paste Attachment"| C["Figma Make Prompt"]
C -->|"Parse Timings & Styles"| D["Code Rebuilt<br/>(React motion.dev / Webflow)"]
end
subgraph WeaveWorkflow["Figma Weave Pipeline"]
B -->|"Export as Video"| E["Figma Weave Node"]
F["Style Reference Image"] --> G["Image Style Transfer"]
E --> H["Prompt Construction Engine"]
G --> H
H --> I["Final 3D Style-Transferred Video"]
end
```
The speakers next demonstrate Figma Weave, showcasing a logo animation crafted by designer James (with a humorous apology from the presenter for being one pixel off during the copy-paste). After rendering the timeline as a source video, it is pulled into a multi-step Weave node graph. The workflow performs image style transfer, using prompt construction nodes that blend the reference imagery's visual language with the motion vectors of the source clip. The result is a fully transformed, stylized 3D video that preserves the exact animation timings of the original Figma file. Because Weave workflows are reusable templates, swapping out the input image instantly produces new variations matching the same motion blueprint.
- Figma Make accepts pasted animated components as attachments, parsing layout styles and timeline keyframes simultaneously.
- Code generation in Make can target modern web animation libraries such as React motion.dev or be integrated into platforms like Webflow.
- Figma Weave workflows consume exported motion videos to run AI image style transfer and prompt-driven rendering while keeping exact source timing intact.
---
[38:59](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2339s) Video Export Formats and Dev Mode Motion Handoff
Turning to local file production, the presenters showcase the overhauled export panel, which now includes a dedicated "Animated" tab alongside traditional static exports. Figma natively exports animation sequences into MP4, WebM, GIF, and animated SVG formats, with configurable dimensions, resolution scales, and frame rates. Users on Pro Plus plans also unlock high-resolution exports up to 4K at 60 FPS for broadcast and high-fidelity video production.
The walkthrough wraps up with production engineering handoff inside Dev Mode, using an intricate animated "bento grid" layout from the keynote as an example. Instead of forcing developers to guess curves or manually convert complex multi-layered motion by hand, Dev Mode provides a clean, read-only timeline view. Developers can focus on the component without distracting canvas clutter, scrub the playhead across tracks, inspect specific easing curves, and select individual elements. Selecting an animated layer immediately renders production-ready code snippets—including pure CSS keyframes and React motion properties—in the right-hand inspection panel, streamlining the handoff from design engineer to production codebase.
- The new Animated export tab supports MP4, WebM, GIF, and animated SVG formats.
- Pro Plus subscribers can export animated files at up to 4K resolution and 60 frames per second.
- Dev Mode features a dedicated, read-only motion timeline view to inspect keyframes and scrub playheads without modifying source design files.
- Selecting animated elements inside Dev Mode surfaces generated code implementations, including CSS animations and React Motion properties.
[40:57](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2457s) Exporting Motion to Code via MCP and LLMs
The presentation moves into translating timeline animations directly into real-world code without losing fidelity. With JSON and code outputs available directly from the tool, designers no longer have to worry about their work getting lost in translation during handoff. The speaker highlights that designers will not lose “the context of your animations, the timings, the colors, everything as you're bringing them over to a production code base.” While translating these values manually into a codebase remains fully supported, Figma also integrates directly with Model Context Protocol (MCP) workflows.
```mermaid
flowchart LR
accTitle: Motion to Code Pipeline
accDescr: Pipeline showing how motion context moves from Figma into LLMs via MCP to produce production web code.
subgraph FigmaDesign["Figma Motion"]
A["Timeline Animation"] --> B["JSON & Context Export"]
end
subgraph AIWorkflow["MCP & AI Integration"]
B --> C["MCP Prompt Template"]
C --> D["LLM of Choice"]
end
subgraph Production["Production Output"]
D --> E["Brand Motion Website"]
end
```
By copying an example prompt provided directly in the MCP section, designers can feed the complete animation data straight into their LLM of choice. The AI ingests the entire context—including precise timings, easing curves, and color values—and reconstructs the motion inside a live application. Switching over to slide visuals, the speaker demonstrates a video of that exact workflow in action: an LLM was handed the extracted animation context and prompted with the instruction, “Can you actually make a brand motion site from this initial animation?” The result is a fully functional web page that faithfully recreates the timings and palette of the original Figma motion file, establishing a seamless path from design to production.
- Key animation parameters exported include exact frame timings, easing curves, and color values.
- The workflow utilizes MCP prompts to pass structural design data into external LLMs.
- Demonstrates an end-to-end bridge transforming design assets into deployable web code.
[42:01](https://www.youtube.com/watch?v=3evAfmLVZK8&t=2521s) Upcoming Features: Styles, Transition Controls, and Roadmap
Wrapping up the foundational walkthrough, the speaker reiterates that Figma's motion tooling is currently in active beta, meaning the product team is actively soliciting community feedback to shape its trajectory. To give attendees a glimpse into what is coming next, the team reveals several major features currently in development. Chief among them is user-created animation styles. This feature will allow designers to build signature motion sequences—such as a company's standard entrance animation—package them into reusable, shared styles across a library, and apply them globally across any design system component.
Beyond reusable styles, Figma is expanding its prototyping and interaction capabilities by introducing granular controls over transition animations. The speaker explains the practical need for this refinement: “When you know what two states are going to look like, sometimes you just need to say, 'Hey, I need this property to come in half a second later, right?'” The forthcoming extensions will allow designers to stagger individual component properties between known states without having to build out complex manual workarounds. Attendees at Config are invited to visit the Product Studio to test live laptops running these unreleased features and provide immediate feedback. The presentation closes with a teaser of upcoming roadmap items, including:
- User-created, shareable animation styles for design systems
- Granular property-level control and staggering for state transitions
- Expanded export formats for production handoff
- Dedicated text animation systems
- Native video support directly on the Motion Timeline
## Notable quotes
> [05:50](https://www.youtube.com/watch?v=3evAfmLVZK8&t=350s) Adding animation to existing designs is actually pretty easy. — Daniela
## Video description
Motion isn't just decoration, it's how your product communicates. We're diving deep into how you can create flexible, componentised, on-brand motion content right inside Figma. We'll take you from the new Motion Timeline all the way through to agent-connected skills and exporting animations to files or your production codebase. There's plenty to get through, we're going to have some fun doing it, and we might just have a sneak peek at some features coming down the line. You're not going to want to miss this one.
____________________________________________________
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/
At Config 2026, Figma's motion and interaction design team introduced native motion authoring directly within the design canvas, integrating timeline controls, design system tokens, multiplayer collaboration, and automated code generation.
Canvas-Native Timeline, Presets, and Keyframe Controls (5:50)
Figma Motion embeds an interactive timeline tray directly beneath the design canvas, eliminating the need to switch into external preview windows. Designers can establish motion through stacked pre-composed styles—categorized into entrances, cycles, and exits—or via manual keyframe stamping on standard object properties like dimensions, position, and opacity. An on-canvas handle named "Mo" allows direct manipulation of spatial coordinates, while holding Command on keyframe nodes reveals Bezier handles to smooth trajectories. Users can dial in acceleration via customizable easing curves and overshoot controls, or engage auto-keyframing to record property adjustments automatically as the playhead advances.
Multiplayer Collaboration and AI Agent Integration (13:56)
Figma adapts its collaborative core to time-based design by automatically stamping user comments with active playhead timestamps, such as 0.8s, and displaying visual markers across the timeline ruler. When team members collaborate, spatial motion paths and easing curve recalculations render simultaneously across connected sessions, supported by spotlight synchronization that mirrors frame-by-frame playhead scrubbing between host and follower machines. In parallel, the platform connects to the Figma Agent, allowing designers to generate multi-shot, staggered motion sequences from natural language prompts, automate letter-by-letter vector conversions for text layers, or produce rapid creative variations for manual timeline refinement.
Design System Scaling and Motion Tokenization (26:51)
Motion integrates natively into Figma's component hierarchy, ensuring that upstream style, color, or token modifications propagate downstream without resetting established keyframes or timing curves. The platform tokenizes animation via two dedicated variable types—Timing and Easing—which can be authored in the central variables panel and tied to visual appearance modes. This setup allows teams to assign distinct motion profiles, such as standard, expressive, or smooth behaviors, to different themes like light or dark mode. Furthermore, animated components link directly into the native prototyping engine, enabling click, hover, or scroll triggers to play, pause, or seek specific points along the nested timeline.
Developer Handoff, Ecosystem Bridges, and Code Generation (35:43)
To streamline production engineering handoff, Dev Mode includes a read-only timeline view where developers can scrub playheads, inspect easing curves, and generate clean CSS keyframes or React motion properties. Local file generation supports MP4, WebM, GIF, and animated SVG formats, with Pro Plus plans offering up to 4K resolution at 60 FPS. Across broader ecosystem workflows, animated components can be copied into Figma Make to generate production front-end code, routed into Figma Weave node graphs for video style transfer, or passed via Model Context Protocol (MCP) prompts into external LLMs to programmatically build functional, styled web applications from extracted timing and color data.
Figma Motion remains in active beta, with the product team soliciting community feedback while developing upcoming roadmap features, including organization-wide user-created motion styles, granular property-level transition staggering, native video timeline tracks, and dedicated typography animation tools.
Source quotes
[5:50] Daniela: Adding animation to existing designs is actually pretty easy.
Original transcript
[0:13] What's up, Config?
[0:16] >> [cheering]
[0:17] >> I missed you all.
[0:18] Good morning, good afternoon, and good
[0:20] evening, wherever you're joining from.
[0:22] My name's George Rust, and I'm on the
[0:24] product team here at Figma.
[0:25] >> Hi, I'm Meena Anand Seshadri, and I'm on
[0:27] the research team here at Figma. We've
[0:29] got an incredible afternoon lined up for
[0:31] you, but before we get into that, I am
[0:33] still buzzing from this morning's
[0:34] keynote. So, I'm curious, I have to ask,
[0:37] researcher, sorry, how many of you are
[0:40] excited about trying something new or
[0:42] retrying something because of something
[0:44] you saw in the keynote this morning?
[0:46] Anyone? Oh, yeah. I love that. The
[0:50] keynote ended like, what, an hour ago,
[0:51] and I'm sure this room is already
[0:53] thinking about all the amazing things
[0:54] they can build. That's the Config
[0:55] spirit.
[0:57] So, before we get started, just a couple
[0:58] of quick notes.
[1:00] If your phone is about to make an
[1:02] unexpected appearance out here, let's
[1:04] put it on silent and give our speakers
[1:05] our attention. One of the best things
[1:07] about Config is the incredible people it
[1:10] brings together. Some of the best ideas
[1:12] that you have out coming out of the next
[1:14] 2 days might come from the person
[1:16] sitting right next to you. So, let's
[1:17] make this a great room to be in. Let's
[1:19] be curious, supportive, and fully uh
[1:22] listening to the speakers who are up
[1:24] here on stage. All right, let's get on
[1:26] to our agenda.
[1:27] >> All right, as I mentioned, we've got an
[1:28] incredible afternoon planned for you.
[1:30] You're going to be hearing from
[1:31] designers, artists, uh engineers, as
[1:34] well as the product teams that brought
[1:36] you all the incredible things you saw
[1:37] this morning. So, to kick us off, let's
[1:40] start with the team behind one of the
[1:41] most moving launches you saw this
[1:44] morning. Please welcome the team behind
[1:46] motion, Dave, Daniela, and Luca.
[1:49] >> Woo!
[1:50] >> [applause]
[3:14] [music]
[3:19] >> Hey everyone. How about that intro video
[3:22] all made in Figma motion?
[3:24] Pretty incredible every bit of
[3:25] animation.
[3:27] So, I'm Luca. I'm an engineering manager
[3:29] here on our motion and interaction
[3:31] design teams at Figma.
[3:32] >> And I'm Daniela, a designer of our
[3:34] exciting our exciting design area.
[3:37] >> Yeah, I mean you might have noticed
[3:38] Dave's name up there, but unfortunately
[3:40] he got caught up after the keynote. He
[3:41] might be able to join us later, but uh
[3:43] we're not going to let that stop us. Who
[3:45] is ready to get moving?
[3:48] Here we go. All right.
[3:51] Now, uh
[3:52] let's uh move on over here. Hold on.
[3:56] Go ahead. You know.
[3:57] >> So, we're going to cover a number of
[3:58] topics like simple animations,
[4:01] multiplayer and commenting, complex
[4:03] animations.
[4:05] And also, we're going to cover some new
[4:08] motion motion workflows that you're
[4:09] definitely going to be excited about.
[4:11] And we're also going to talk about
[4:13] exporting into production and some sneak
[4:15] peeks at of what's coming next.
[4:19] >> Yeah. Now, in addition to that amazing
[4:21] launch video, there's been a lot of
[4:23] fantastic work made by the Figma team.
[4:25] So, before we get into that getting
[4:26] started, we want to show a few of the
[4:28] things made by our team and the partners
[4:30] in our alpha. Starting with
[4:33] Here is an amazing set of animations
[4:35] created by Fabian on our team, mixing uh
[4:38] a bit of auto layout, color styles, key
[4:40] frames, effects to create this beautiful
[4:42] set of app intro and interaction
[4:44] animations.
[4:47] Here, we have a lovely little motion
[4:49] composition created by using components
[4:51] inside of Figma to stack these
[4:53] animations on top of each other.
[4:56] Here, we've got a set of product
[4:57] animations built by Fifi, which actually
[4:59] landed inside of Figma today.
[5:02] Here's a set of icon animations created
[5:04] by Adonna using some variables and modes
[5:07] to quickly switch between those color
[5:09] styles while preserving the animation.
[5:13] We can even make character animations.
[5:14] Here's a little uh vectorized
[5:16] Frankenstein face that mixes some
[5:18] vectors and some effects to create a
[5:19] little bit of a spooky styling.
[5:23] And uh this one just came in from Igor.
[5:26] I mean, like look at that. That is
[5:27] fantastic. Stellar work. That is
[5:29] awesome.
[5:30] Uh so,
[5:32] these examples give you a quick set a
[5:34] quick quick like little look into what
[5:36] types of things you can make inside of
[5:37] Figma motion. Um
[5:39] so, yeah.
[5:39] >> And let's ease our way into it with a
[5:42] demo.
[5:43] >> Woo.
[5:47] >> [applause]
[5:50] >> So,
[5:52] we are going to go through the most
[5:53] basic building blocks of motion. Adding
[5:55] animation to existing designs is
[5:57] actually pretty easy. And first, let's
[5:59] just open motion mode. And if you look
[6:02] down here, you can you can see this
[6:04] amazing tool belt with a new motion
[6:06] icon. And let's just go into it.
[6:10] And we're going to notice that here we
[6:12] have a new timeline. And on the left
[6:14] side over here, you see that we have
[6:17] a lot of different new controls. For
[6:19] example, you can just play this
[6:21] animation right into Figma, right on
[6:23] canvas.
[6:24] And you will also going to have some
[6:27] auto keyframing, which we also going to
[6:29] discuss slightly bit later. We also have
[6:32] some controls for the current time,
[6:34] which is basically a position of our
[6:36] play head. We also have some controls
[6:38] for the whole duration of your
[6:39] animation. So, basically, if you want to
[6:41] adjust this, you can adjust this in this
[6:43] input, or also you can just drag this
[6:45] control, and it also going to change the
[6:48] duration of your animation over here.
[6:50] You can also change the time format. So,
[6:52] if you prefer, for example, to work in
[6:54] seconds, it's also going to be possible
[6:56] for you to switch. And you can also
[6:58] change some looping settings. So, let's
[7:00] say that we have here ping pong, but you
[7:03] can also change to looping or like
[7:04] whatever settings you basically prefer
[7:06] in this case. And you can also collapse
[7:09] layers over here, adjust to kind of like
[7:11] have like slightly bit more condensed
[7:13] timeline if you want this. And if you're
[7:15] going to try to like scrub this play
[7:17] head, you see that animation is running
[7:19] again right on this canvas, which is
[7:21] also pretty amazing. You can also adjust
[7:25] the
[7:25] the height of this timeline over here.
[7:29] You can also adjust the zoom level on
[7:32] this side. And you can also collapse
[7:34] your timeline if you need a little bit
[7:35] of more space on the canvas.
[7:38] And you might also notice that over
[7:40] here, we have some new properties panel,
[7:44] but what is really amazing about this
[7:46] particular thing is that we actually try
[7:49] to keep design mode and motion mode
[7:51] aligned as much as possible,
[7:54] but still like making some space for new
[7:57] additional things like key frames. So
[7:59] you see that all properties that they
[8:01] used to have actually right now have
[8:03] this nice amazing icon which is the key
[8:05] frame. And we also have this new section
[8:08] which calls animation styles for new
[8:10] animation styles over here. So let's
[8:13] just try to create some new animation. I
[8:16] have this nice illustration over here
[8:18] without any animations. And we have on
[8:21] the right side here this animation
[8:23] section, right? And if I'm just hit this
[8:26] plus button,
[8:27] it basically just add position style
[8:30] over here. And you see that we have this
[8:33] flyout with a lot of different settings
[8:35] which actually helps you to make like a
[8:38] little bit more control over this
[8:40] particular animation. And we can also
[8:42] adjust distance, delay, duration here,
[8:45] but I can also use this control to
[8:48] adjust this right on a timeline.
[8:51] And if I'm just keep stacking those
[8:53] animations over here, so let's say that
[8:56] I also want to scale and maybe some
[8:58] rotation and also maybe some change of
[9:01] size, but maybe I'm going to change this
[9:02] opacity. We also see that we sort of
[9:05] like trying to be smart about adding and
[9:08] stacking all those animations. So that's
[9:09] why they are kind of different each and
[9:11] every time when I'm hitting plus button.
[9:13] But you can always change this and
[9:15] explore more options here. And if you're
[9:18] going to hit play button, it works. And
[9:22] let's talk a little bit about key
[9:24] frames.
[9:25] >> Yeah, yeah. So Daniel just showed being
[9:27] able to stack these pre-made animation
[9:29] styles onto a node, but when you want
[9:31] more fine-grained control, you're going
[9:33] to turn over to key frames. She
[9:35] mentioned in the properties panel,
[9:37] you'll see that every animatable
[9:39] property has a little diamond stamp next
[9:41] to it. If you want to animate that
[9:43] property, first you set your play head
[9:45] to the starting point of your animation.
[9:47] Then, you can stamp one of the key
[9:48] frames. So, Daniela chose position
[9:50] there. We can then move the play head to
[9:53] the next end or next point of your
[9:54] animation or the ending points and we
[9:56] can either stamp another play
[9:58] stamp another key frame or move the
[10:00] little motion gizmo that's now on the
[10:02] canvas over to our ending position. We
[10:04] call him Mo. He's a We're a big fan of
[10:06] Mo.
[10:07] And if you press play,
[10:09] you've got your animation.
[10:11] Now, this one's a little bit basic,
[10:13] little linear animation from left to
[10:15] right. So, let's say we want to smoothly
[10:17] move this object across the canvas. What
[10:21] we can do is select the easing bar in
[10:23] the center of those key frames
[10:24] and we get this little easing adjustment
[10:26] panel on the right-hand side. We can
[10:28] choose from a preset
[10:31] few types of easing. What do you think
[10:32] we should do, Daniela?
[10:33] >> Yeah, I think that I kind of like ease
[10:35] in. What do you think about that?
[10:36] >> Yeah, let's do ease in. Ease in's a
[10:38] classic, right? It lets you do a little
[10:39] bit of a ramp up to your animation.
[10:42] And so, you can kind of see that this
[10:43] animation picks up right at the end
[10:45] there. Um we can also add some custom
[10:47] easing styles here if we'd like. So, you
[10:49] can adjust those directly in the panel.
[10:52] Uh Daniela's adding a little bit of
[10:53] overshoot there. So, maybe we just pop
[10:54] it all the way up. And you'll notice if
[10:56] we do an overshoot, the animation will
[10:58] go beyond that last key frame.
[11:01] Nice. So, we can get a little bit of a
[11:02] spring there at the end. Fantastic.
[11:05] >> Cool.
[11:05] >> Awesome. Now, um two key frames does not
[11:08] an animation make. Or two basic ones,
[11:10] but we want to add a little bit more
[11:11] flare to this one. So, how about we add
[11:13] a few more key frames to that first
[11:15] animation, Daniela?
[11:16] >> Yep.
[11:18] >> And in here, we can move the play head
[11:20] between those first key frames, continue
[11:22] to move the motion gizmo,
[11:25] and add in a few more.
[11:27] Maybe we can make it I don't know. What
[11:28] do you think? Maybe we should make it
[11:29] like pop up and down.
[11:31] >> Oh, yeah. I kind like this idea.
[11:33] >> I like it.
[11:34] Awesome.
[11:36] Get a little bit of a bounce to this
[11:37] object and if we play it, we can see it
[11:39] follow those same animation curves with
[11:41] that overshoot.
[11:42] But, this is a little bit jagged. So,
[11:44] how about we smooth out those corners?
[11:46] If you hover over any of those key
[11:48] frames, you can hold command and pull
[11:50] and you'll get a nice smooth curve
[11:52] through your animation.
[11:53] We can do that on, you know, every key
[11:55] frame we add here.
[11:58] And get a lot more fine-grain control
[11:59] over the path that our animation is
[12:01] moving through.
[12:03] Awesome.
[12:05] So, this is great. We've shown preset
[12:08] some pre-made animation styles. We've
[12:10] shown a few key frames.
[12:11] Um, but let's take a look
[12:13] at some of the library of pre-made
[12:16] animation styles that Figma's going to
[12:17] offer to you starting today. Um, if you
[12:19] select a node that doesn't have any
[12:21] animation, you might not know how to
[12:22] start. Um, next to that plus button in
[12:26] the animations panel, there's also a
[12:27] little styles drop-down. When you press
[12:30] that, there's a set of pre-composed
[12:32] animation styles. If we go through,
[12:34] you'll see there's entrance entrance
[12:36] animations, some cycle-based animations,
[12:38] some exits. When you select one of
[12:40] those, I don't know, what should we
[12:40] choose? Maybe like an entrance?
[12:43] >> Maybe something like slap.
[12:45] >> So,
[12:45] let's try it. This is a slam animation
[12:47] coming in from the top. It'll pop a few
[12:50] of those animation styles onto the
[12:51] timeline for you. This one's a little
[12:53] bit, I don't know, this one feels a
[12:55] little bit fast for me. So, why don't we
[12:56] extend it out? We can go to these
[12:58] pre-made
[13:00] presets. We can extend them a little bit
[13:02] longer.
[13:04] And the timing of the all of those
[13:06] animations will kind of move in sync
[13:07] with one another. So,
[13:09] this is just one of the many that we've
[13:11] added. Uh, if we zoom out here, we can
[13:13] see just a few of them kind of working
[13:14] in concert with one another.
[13:17] Down here in the pre-made section there.
[13:21] Great. And if we zoom out here on the
[13:23] canvas,
[13:25] we're going to see kind of a set of 16
[13:28] or 12 of the animation styles that we've
[13:30] created for you today. We want to hear
[13:31] from you all in terms of what you'd like
[13:33] to see in this preset section.
[13:35] Uh and maybe soon there'll be some
[13:37] opportunities for you all to create uh
[13:39] pre-composed animations for your teams
[13:41] as well, custom to your org.
[13:45] Great.
[13:46] Now.
[13:47] Yeah, I'll take a woo. I'll take a clap.
[13:50] That's pretty great. This is all
[13:51] happening in Figma in real time.
[13:55] Awesome.
[13:56] And you probably heard today that
[13:57] there's a lot of new agents capability
[13:59] inside of Figma. Uh motion is no
[14:02] different. You're able to build motion
[14:04] with the Figma agent as well.
[14:06] Here, we've got a basic Figma logo
[14:08] vectorized five different pieces. Um and
[14:11] let's say we're we're not sure where to
[14:12] start. Either we can add those manual
[14:14] pre- pre-made animation styles or
[14:16] keyframes, or we can prompt the agent to
[14:19] create animation for us. So, if we
[14:21] select these nodes, there's a little
[14:22] agents icon, and we can put it in a
[14:25] prompt for us. Let's say, I don't know,
[14:26] we pre- pre-generated a little prompt
[14:29] here. You know, we're on stage at
[14:30] Config. Please don't screw this up for
[14:31] us. Make it fly in from the sides. Uh
[14:34] we're going to send that off to agent.
[14:35] And while that cooks, we're going to
[14:37] show you a few animations that we've
[14:39] pre-baked before the session.
[14:42] Here's one that was made with agents.
[14:44] Asking it to move this mouse, grab a
[14:47] keyframe, pull it to the side. And you
[14:49] can see this is a pretty capable
[14:50] animation
[14:52] um that we then have the ability to edit
[14:54] after the fact. So, if we take a look at
[14:56] the timeline and zoom out,
[14:58] it's a pretty sizable number of
[14:59] keyframes. Kind of getting to this
[15:00] starting point for a draft would be a
[15:01] lot of kind of tedious work up front. Um
[15:04] but this gives us a really great place
[15:06] to kind of begin our animation. We can
[15:08] then iterate in concert with that agent.
[15:12] Move on to the next one here.
[15:14] This one is a little bit more
[15:15] complicated. This was built by one of
[15:17] the people on our brand motion team. And
[15:19] what I love about this example is this
[15:21] was a mixture of manually created
[15:23] animation and agent created animation.
[15:26] The config logo here, the C, the N, the
[15:29] F, the I, the G were stubbed out by one
[15:31] of our brand motion team animators to
[15:33] start with. But that O animation has a
[15:36] number of tiny points in it. Kind of
[15:38] going through here and starting and
[15:40] stopping and hiding and showing all
[15:42] those little bits would be a really
[15:43] tedious piece of work. So, uh Jill on
[15:45] our team kind of worked with agent to
[15:47] create a series of smaller components
[15:49] that were easy to stack. Once we had
[15:51] animation and kind of feel that we
[15:52] liked, we were able to stack those on
[15:53] top of each other and insert that into
[15:55] the animation after the fact. So, really
[15:58] nice if you want to speed up your
[15:59] workflow in that way.
[16:02] Awesome.
[16:03] >> Great.
[16:04] >> So, here's a set of animations actually
[16:05] made by Daniela
[16:07] um with the agent. She created this
[16:08] little pixel vectorized logo uh for
[16:11] Figma. And then she asked the agent to
[16:13] create a series of riffs of animations
[16:15] for her.
[16:16] Now, trying to build all these by hand
[16:18] to start would be so much work to get
[16:20] started. But this helps us kind of look
[16:22] at a huge number of options really,
[16:25] really quickly. Each of these could be
[16:26] edited and animated on the on the
[16:28] timeline as well. Um but we can quickly
[16:30] kind of work through and see, all right,
[16:31] this is the the vibe we're going for,
[16:33] this is the style, let's move in this
[16:34] direction and kind of push the agent
[16:36] towards the animation styles that we're
[16:37] looking for.
[16:40] Then lastly over here, we want to show a
[16:41] little bit of text animation. Now, Figma
[16:43] motion doesn't have a full text
[16:45] animation suite yet. But these
[16:48] animations were created by stubbing out
[16:50] a few pieces of text. Asking the agent,
[16:53] can we please vectorize this task text
[16:55] and animate them in with some entrance
[16:56] and exit animations?
[16:58] And then once each of these individual
[17:00] pieces of animation were built, we were
[17:02] able to select that and ask the agent to
[17:04] compose those onto a single timeline to
[17:06] create this final text result.
[17:09] This is pretty smooth getting started
[17:10] with that. Doing that by hand would be
[17:12] quite a bit, right, of work. Um Uh, but
[17:16] getting the agent to kind of pull out
[17:18] each of those individual pieces, riff on
[17:20] each of those individual shots, and then
[17:22] pull that into a single composition was
[17:24] just such kind of a fun and playful
[17:26] workflow. Highly recommend it. It is It
[17:27] is really great. This is only four
[17:29] shots, but you could imagine if you had
[17:31] 10, 20, 30 shots of an animation that
[17:34] you needed to compose, asking the agent
[17:36] to put those all on a timeline, stagger
[17:37] them for you. These are great little
[17:39] kind of utilities that you can use to
[17:41] really build up the style of your
[17:43] animation.
[17:45] Awesome.
[17:46] Now,
[17:47] so that's Agent. What do we think?
[17:49] Pretty fun, right?
[17:50] >> [applause]
[17:53] >> The agent understands keyframes,
[17:55] animation styles, and so you can ask it
[17:56] quite a bit about the pieces of the
[17:58] properties of the uh the animation
[18:00] itself. Um, did that first one actually
[18:02] finish while we were up here?
[18:03] >> I think so.
[18:05] >> Awesome.
[18:06] So, this is a a great starting point for
[18:07] this uh for this Figma logo. Um, just
[18:10] flying in from the sides. Now, we told
[18:11] the agent to speed up in our prompt, so
[18:13] it skipped over some reasoning. It might
[18:15] ask us questions if we uh if we kind of
[18:17] didn't ask it to speed up. Um, but in
[18:20] this case, it's it's kind of nice. The
[18:22] objects on screen, uh you know,
[18:25] or end where we started, right? But if
[18:27] we wanted to, we could reference, "Hey,
[18:29] I want the orange and red bit to slam
[18:31] against each other a a little more
[18:32] aggressively. I'd like the green uh chit
[18:35] here to come in from the bottom of the
[18:36] screen." We can kind of add in, you
[18:38] know, more nuance here if we wanted to
[18:40] go for a few more iterations.
[18:43] Cool. So, that's collaboration with the
[18:45] Figma Agent. Now, Figma's known for
[18:47] collaboration not just with agents, but
[18:49] with your team, right? So, we want to
[18:50] show you how you can collaborate with
[18:51] your team on these motion designs as
[18:54] well.
[18:55] Oh, and
[18:56] >> Oh.
[18:56] >> Who's in here? Look at that guy. There's
[18:58] Dave. We miss you, buddy. Wish you were
[19:00] out here. Um,
[19:03] so we want to show a couple of things uh
[19:06] that the Figma uh motion team has kind
[19:08] of integrated into multiplayer and
[19:10] commenting.
[19:11] Looks like Dave's been working on this
[19:12] animation for us.
[19:14] Uh
[19:15] it's okay. Maybe we want to leave a
[19:16] comment. I don't know. Towards the end
[19:18] there, the cursor's looking a little bit
[19:19] kind of flat. What if we threw a comment
[19:21] to that spot?
[19:23] And as Daniela is adding a comment,
[19:25] you'll notice that there's a new
[19:26] timestamp on the comment for 0.8
[19:28] seconds.
[19:29] You can add additional timestamps if you
[19:31] like. There's a little button in the
[19:32] comments panel where you can say, you
[19:34] know, add an extra comment at 0.4, 0.5
[19:37] seconds. It'll add wherever your
[19:39] playhead is. And that time is reflected
[19:41] not only in the comment, but also on the
[19:43] timeline. So, you can easily kind of
[19:45] grok like where are my, you know,
[19:47] collaborators asking me to make an
[19:49] addition or a change, right?
[19:51] Uh so, that's great. We left a comment
[19:53] here earlier and it looks like, yeah, we
[19:55] thought that, you know, we should change
[19:56] the animation and looks like Dave
[19:58] agrees. So, go ahead, Dave. Make those
[20:00] changes. So, Dave's pulling that cursor
[20:02] up and while he does so, we can actually
[20:04] watch the motion path update in real
[20:06] time. He's able to do things like move
[20:08] items on the canvas, like always. He can
[20:10] change the actual keyframes. If he wants
[20:12] to, he can change those easing curves
[20:15] that we showed before as well.
[20:16] Um and we can see all of that get edited
[20:18] in real time. We can also ask Dave to
[20:21] spotlight because I don't know that
[20:23] we're kind of picking up what he's
[20:24] trying to do here. Um so, Dave, why
[20:26] don't you go ahead and spotlight
[20:27] yourself?
[20:30] Oh.
[20:30] How we doing?
[20:32] Any luck?
[20:36] Well, we can actually click on Dave to
[20:37] follow. Oh, there we go. Awesome.
[20:38] >> Oh, nice.
[20:39] >> Thanks, Dave. So, Dave's going to go
[20:40] ahead and spotlight. Great. And now in
[20:43] this state, we've actually synchronized
[20:44] the timelines together between Dave's
[20:46] machine and ours. This is really
[20:48] helpful. Let's say we're building this
[20:49] animation over a video call or we're
[20:52] building this animation over, uh you
[20:54] know, a voice call without having to
[20:56] drop any kind of the visual effect, any
[20:58] of the fidelity. We're seeing this
[20:59] rendered in real time on both of our
[21:01] machines. If Dave moves that playhead
[21:03] around, we see exactly where he is in
[21:05] real time.
[21:07] So, that's awesome. Dave, what do you
[21:08] think, man?
[21:12] Sick?
[21:14] It's all right. I think it's sick sick
[21:16] for a PM, that sounds good. You know how
[21:17] many PMs I want to talk.
[21:19] Um
[21:20] cool. Well, I think we got a couple of
[21:21] other like sick features to show. Dave,
[21:23] why don't you come out and join us if
[21:24] you're actually here?
[21:26] Come on, man. Everybody, why don't we
[21:27] welcome Dave TO THE STAGE?
[21:29] >> [applause]
[21:32] >> HEY, LIKE GUYS, I'M so sorry I'm late. I
[21:35] was I was just backstage practicing how
[21:38] to say
[21:39] beta. Beta?
[21:42] >> [laughter]
[21:43] >> Right, where have we got to?
[21:45] >> So, we were already talking about
[21:47] animation styles and key frames. We also
[21:50] have discussed a little bit like a
[21:52] granular control. We were talking about
[21:54] collaboration and agent.
[21:55] >> Very good.
[21:57] So,
[21:58] we're ready then to jump into some
[21:59] properties and go a bit further.
[22:01] >> Awesome.
[22:03] >> So, first up, let's talk about auto
[22:07] keying.
[22:08] Adding key frames can be pretty tedious.
[22:10] There's lots of movement back and forth.
[22:13] Uh but if we look down on the timeline,
[22:16] we can see the auto key button. If you
[22:18] press that,
[22:20] what this is going to do is arm all of
[22:23] those key frame properties on the
[22:25] right-hand side.
[22:28] Very good. And Figma is now going to
[22:30] listen to any change on the canvas or in
[22:34] the properties panel.
[22:36] And it's going to stamp those key frames
[22:39] automatically.
[22:42] So, it looks like we've got some
[22:43] position, rotation, and opacity.
[22:47] There we go. They've all been recorded.
[22:50] Super useful.
[22:54] So,
[22:55] so far we only done a few properties,
[22:57] but let's talk about some more that we
[22:59] can also key frame. We've got color.
[23:03] Nice.
[23:05] Look at that guy.
[23:07] Not really sure that's the best product
[23:10] animation. What have we got?
[23:12] Oh, look at this.
[23:14] Amazing.
[23:17] Wow.
[23:18] Um
[23:19] It really draws you in this, doesn't it?
[23:21] >> Yeah.
[23:22] >> Hold on. Hold on. Off.
[23:26] Brilliant. Brilliant. Now, um
[23:29] yeah, again, not the a most amazing
[23:32] product animation, but I I thought it'd
[23:33] be hilarious to see this animation on
[23:36] this this big screen.
[23:38] Let's move on and look at stroke width.
[23:42] Yes, we can animate stroke. The property
[23:44] is where it always is. It's now got a
[23:46] keyframe stamp next to it.
[23:49] And you can do it. I always forget about
[23:51] this one, but this one
[23:54] always reminds me to buy some new
[23:55] blinds.
[23:58] Great.
[23:59] Next up, path trim. One of my absolute
[24:02] favorites.
[24:04] We can animate the start position and
[24:07] the end position.
[24:08] And it's worth calling out the
[24:10] properties panel here because we have
[24:12] brought these properties top level
[24:14] within motion mode.
[24:16] Thank you, Figma Draw, for these
[24:18] features.
[24:20] And what can we do with this?
[24:22] Wow, yes. When we start getting
[24:23] comfortable with path trim, we can do
[24:26] crazy things like this.
[24:28] This is from our friend Piers. [snorts]
[24:31] He's going to show you much more cool
[24:33] like stuff like this later.
[24:35] And um I think we've also got the path
[24:38] trim from the keynote down here as well.
[24:40] No shaders on it this time, but yeah.
[24:43] Path trim really really effective for
[24:46] animation.
[24:48] We got a Figma classic next.
[24:51] Arcs.
[24:53] Also worth pointing out the properties.
[24:56] Dana, do you mind hovering over this cuz
[24:58] I can never remember what the properties
[25:00] are called for arcs.
[25:02] Just hover over
[25:04] >> Oh, yes. I think it's uh start, sweep,
[25:07] and ratio.
[25:08] >> Yeah, super super handy if you're making
[25:11] gauges or dashboards or anything, you
[25:15] know, similar where you want it to sweep
[25:18] in over an arc. So, you might have
[25:20] noticed this one from the keynote. There
[25:23] we go. Really really handy for that.
[25:27] Last stop on our property hit list,
[25:29] we've got points on a shape.
[25:33] So, here we are animating the count
[25:36] property from is it three to six?
[25:38] >> Yep.
[25:38] >> I'm not that fast at counting. Yeah. And
[25:41] we might use this on something like an
[25:44] icon. Have we got something below that's
[25:46] There we go.
[25:48] So, I think on this one we go from a
[25:50] four point to a six point, make this cog
[25:53] shape appear.
[25:55] It's really fun to animate. We've had so
[25:58] much fun experimenting mixing all of
[26:00] these things together.
[26:03] One of the tricks that you can use is to
[26:06] combine styles and keyframes together.
[26:10] So, in this example
[26:13] we've got the scale controlled by
[26:17] keyframes and then the rotation
[26:20] is controlled by a style. So, you can
[26:22] mix these two things together really
[26:24] fluidly, doesn't make a difference.
[26:27] Uh let's see. There we go. A more
[26:30] advanced animation.
[26:32] Dana and Luca showed this one earlier.
[26:34] It's the one that has uh nested
[26:36] components. So, all of those components
[26:38] contain keyframes, and then what we've
[26:41] done is we've bought those components in
[26:43] and we're controlling them all with a
[26:46] single scale preset. Really really easy
[26:49] to use.
[26:51] Now,
[26:53] this wouldn't be Figma unless we talked
[26:55] about variables.
[26:58] We've added two new variable types for
[27:00] Figma motion. We've added easing and
[27:02] timing.
[27:03] You can add them directly within the
[27:05] variables panel or from within the
[27:07] styles properties or keyframe easing
[27:10] panel, too.
[27:11] And when I've
[27:12] Oh, yeah, feel free, please.
[27:16] >> [applause]
[27:18] >> Um obviously when there are variables,
[27:20] you can control them centrally and we've
[27:23] got some modes set up on this as well,
[27:26] right? So, what what modes of um what do
[27:29] we got? We got standard. So, we're
[27:30] seeing a set of variables applied there
[27:33] that's standard.
[27:34] Next up, we've got
[27:36] expressive. Try that expressive one.
[27:38] What's happening there? Oh,
[27:40] that is expressive, isn't it?
[27:43] And smooth.
[27:45] Very, very smooth.
[27:48] So, what this means is that if you want
[27:51] your dark mode animation a different
[27:53] vibe to your light mode,
[27:56] you absolutely can. Dana's going to mix
[27:59] and match there to her heart's content.
[28:02] So,
[28:04] >> Yeah, while we're here, we could try
[28:05] expressive.
[28:06] >> Expressive?
[28:07] >> Uh I'm not sure. Maybe smooth.
[28:11] And I kind of prefer dark mode, I guess,
[28:13] right?
[28:14] >> Nice.
[28:16] Really good. Thank you very much. Uh
[28:17] look, it's been a flying visit for me.
[28:20] I'm very, very sorry. I need to go and
[28:22] do some really important PM stuff like
[28:25] stand over an engineer and ask them if
[28:26] it's finished yet.
[28:27] >> Oh, amazing. Thank you, Dave.
[28:29] >> Thank you very much, Dave. Appreciate
[28:31] it, dude.
[28:32] >> [applause]
[28:34] >> Awesome.
[28:35] Very cool.
[28:36] So, we saw a little bit of the basics.
[28:40] We got into some of the more kind of
[28:41] fine-grained details that you can edit
[28:43] with keyframes and all those lovely
[28:44] properties. Definitely take a look at
[28:46] every animatable property in that panel.
[28:49] Um but we've kind of touched a little
[28:51] bit on those design systems aspects that
[28:55] we love in Figma. A little bit of
[28:56] variables, we've mentioned components,
[28:59] and we think there's kind of no better
[29:01] example Hang on to that one, too. Thank
[29:03] you. There's no better example for um a
[29:06] components workflow than one of the
[29:08] shots that was created for that intro
[29:10] video we played as we walked on.
[29:12] Uh this is kind of a real copy paste
[29:15] from one of the uh brand motion uh Figma
[29:17] files that were used to build that intro
[29:20] video.
[29:21] The way the motion team was working was
[29:23] they broke each of their shots into
[29:25] individual individual page. And like we
[29:28] just kind of found them doing this as
[29:30] they were playing with the tool while we
[29:31] were building, and it kind of turned
[29:32] into this awesome creative collaborative
[29:35] workflow for the team.
[29:37] They were able to take those components
[29:38] I mentioned, build out animations in
[29:40] steps. So, here's like a little flower
[29:42] bloom. All the arrows and stuff just
[29:44] came straight from their file. They were
[29:45] building these flows out as they built
[29:47] it. They would take those and stack
[29:49] these components one on top of each
[29:50] other by pulling instances out and
[29:52] bringing them in.
[29:53] Uh and these would kind of bring
[29:56] one into another into another. They were
[29:57] able to riff on different subsections
[29:59] here, maybe pulling in different like
[30:01] pieces of the animation and actually see
[30:03] how those would stack into one another.
[30:05] And then in the end they were able to
[30:06] build out these full compositions
[30:08] without losing the context of any
[30:10] individual piece of that animation
[30:12] working with one another. So, it's a
[30:14] really awesome to work in this way with
[30:17] a large team. You're not stuck in your
[30:18] own file on your machine having to copy
[30:20] and paste and send those around for
[30:22] motion, which is just kind of an
[30:23] antiquated workflow. We're bringing the
[30:25] classic Figma workflow to these motion
[30:28] uh motion topics.
[30:30] Um now this is is a stellar animation in
[30:33] my eyes, Daniela, but like is there I
[30:35] don't know. I would never critique some
[30:37] of the brand motion team's work, but
[30:38] since you're a designer you're allowed
[30:39] to. Do you want to give maybe a uh a
[30:41] recommendation, maybe something we
[30:42] should try to change here?
[30:44] >> I think this animation looks really
[30:45] amazing, but I'm kind of wondering, this
[30:47] flower is basically like not following
[30:49] like all the like design palette, so
[30:51] maybe we could just change this to pink
[30:53] color, for example, because like the
[30:54] rest of cards are kind of pinkish, so
[30:57] maybe we could adjust this. I don't
[30:58] know, what do you think about that?
[30:59] >> Yeah, I see that, right? Like the little
[31:01] pink kind of florets on the side there.
[31:03] Yeah, we can do that with a really
[31:05] simple workflow. Since this is all built
[31:07] up with components, we can just go over
[31:08] here to this first component. We can
[31:10] select a piece of the component that we
[31:12] want to change, say, I don't know, about
[31:13] circle four, that sounds good to me.
[31:15] Maybe add in one of those colors that we
[31:17] were using from beforehand. And because
[31:20] this is a component and animation
[31:21] workflow in Figma, that color is then
[31:23] sent all the way through down to the
[31:25] final composition without us losing any
[31:28] of the animated context from the rest of
[31:30] the animation. Now, that is a pretty fun
[31:33] workflow.
[31:34] >> [applause]
[31:36] >> You don't have to worry about, you know,
[31:38] a design changing upstream and then
[31:40] having to bring that down into a
[31:41] separate product in order to kind of
[31:43] keep your designs in check. It all just
[31:45] works with Figma design systems. Pretty
[31:48] great.
[31:49] >> Amazing.
[31:50] >> Yeah.
[31:51] And, uh, it works with the other Figma
[31:52] tools that you know, uh, come to uh,
[31:55] know and love, things like prototyping.
[31:57] >> So, in this particular example, you see
[31:59] pretty basic prototype with just a
[32:01] simple back and forth interaction. So,
[32:03] if you're just going to go to prototype
[32:05] tab, you see that we have like a pretty
[32:06] simple connection here and just like
[32:08] move in animation, I think, and it works
[32:11] pretty simple, I guess. So, let's just
[32:12] try to open this in prototype view and
[32:15] have a look how it works. And you see
[32:17] that this frame basically using
[32:20] animation, uh, frame inside, so that's
[32:23] why we have this incredible animation
[32:25] over here. And let's just try to click
[32:28] on add goal button and
[32:30] amazing, this is also another animation
[32:33] frame inside prototype and we see that
[32:36] it's even possible, I think, to click on
[32:38] this.
[32:39] Do you think it's going to work?
[32:40] >> Yeah, definitely. So, that animated
[32:42] component in the background has a few
[32:44] new um actions on it that let me click
[32:47] and pause the timeline at any any given
[32:49] place. You can also set the timeline
[32:51] position, and that's all just done
[32:53] inside the prototype tab uh when you
[32:55] have an animated component, you can add,
[32:57] you know, your clicks, your hovers, your
[32:58] scrolls, and you can do things like
[33:00] toggle the animation timeline, set the
[33:02] playhead position uh to set a few of
[33:04] those basic interactions. This is just
[33:06] some basic prototyping. We have some
[33:07] more stuff coming on the way, maybe in
[33:09] the sneak peek section we'll show you a
[33:10] few things. Um but yeah, those
[33:12] animations just work inside of
[33:14] prototyping with the triggers and
[33:16] actions system.
[33:17] >> Amazing. So, also in Keynote, you might
[33:20] have heard about shader effects. And in
[33:22] this example, shader fill has been
[33:25] applied to this particular frame, and
[33:26] you can see that just with two
[33:28] keyframes, we were able to animate this.
[33:31] And if you're going to go to the
[33:32] property panel, you're going to see that
[33:35] to this particular frame, cloud fill has
[33:37] been applied. And we have a lot of
[33:39] different properties here, but uh only
[33:41] phase uh property has been animated with
[33:44] just the two keyframes. But, if you want
[33:46] to adjust this, or maybe like play with
[33:48] this a little bit more, it's also
[33:49] possible to animate each and every
[33:51] keyframe in this particular shader. And
[33:53] it's also true to any shader fill.
[33:56] >> Yeah, it's really fun just kind of
[33:57] coming in here, playing with the
[33:59] properties of each of these shaders,
[34:01] adding in little keyframes, uh and kind
[34:03] of playing through. That was not a fun
[34:05] animation, so I might want to change the
[34:06] easings later. But, um this is just a
[34:08] taste of what effects and motion can do
[34:10] together. Definitely recommend y'all go
[34:13] to the effects deep dive that's
[34:14] happening later today. Um it is going to
[34:16] melt your brains. It is incredible what
[34:18] you can build with these effects.
[34:23] >> Awesome.
[34:24] >> Amazing. And you also might have heard
[34:26] about plugins. And in this particular
[34:28] example, I have built this like a really
[34:31] simple stagger effect animation and it's
[34:33] actually pretty easy to control this
[34:35] just like with the two different bars,
[34:37] right? But let's say that we have
[34:38] actually not four different circles, but
[34:41] like 10 or maybe 100 or maybe even more.
[34:43] And in this example, we were trying to
[34:46] use this incredible plugin that our
[34:48] friend Miggy has been building. And this
[34:50] basically mean that if I'm going to try
[34:52] or if Luka going to try to select all of
[34:54] the circles and down here like in a
[34:57] properties panel, you're going to see
[34:58] this stagger a timing tool, which
[35:01] basically going to allow you to like
[35:03] change a stagger effect, stagger delay,
[35:06] duration, easing, like literally
[35:08] everything. And you're still going to be
[35:10] able to see all of those different key
[35:12] frames and presets. So, you still have
[35:15] like a full control over this timeline.
[35:17] But you have like an additional panel to
[35:19] control this, which is great.
[35:21] >> Yeah, really really fun building out
[35:23] these little plugins that kind of help
[35:24] your animation workflows kind of just in
[35:26] situ. You know, you might have a little
[35:28] problem that's coming up and kind of
[35:29] kind of egging at you while you're
[35:31] building out your animations, you can
[35:32] easily build a tool that extends to
[35:34] this. This is also just a taste of what
[35:36] you're going to see. We also have a
[35:37] generative plugins deep dive that you're
[35:39] not going to want to miss coming up
[35:40] later on as well.
[35:43] Cool.
[35:44] And
[35:45] Oh, I'll Yeah, sure. For sure.
[35:48] Generative plugins are sick. Definitely
[35:51] play with them. Um now,
[35:54] we don't just want to keep our
[35:54] animations inside of Figma. We want to
[35:56] be able to bring them to other
[35:58] experiences as well. Uh namely, Figma
[36:01] make. So, if I've got an animated
[36:04] component inside of Figma, I can easily
[36:06] copy and paste this object into a make
[36:10] file
[36:11] um or
[36:12] come over here,
[36:13] build out a new make, and just
[36:15] command V paste that in as an
[36:17] attachment. When I do so, I'm able to
[36:19] pass the animation properties as well as
[36:21] the design properties over to make. I
[36:24] can say something like, "Let's recreate
[36:27] this animation with React motion.dev.
[36:31] We can kick off this
[36:33] uh this creation.
[36:35] And then the background, Figma makes
[36:36] going to understand the timings, the
[36:38] styles, the colors. If I'm using other
[36:40] aspects of my design system while I'm
[36:41] building out this animation, it should
[36:43] be able to recreate it. Now, uh let's
[36:45] see while this generation is uh kicking
[36:48] off. We've got one that uh we built
[36:50] beforehand, but I want to see if we can
[36:52] get this one going quickly.
[36:54] Um
[36:55] being able to bring over all of that
[36:57] animation context in addition to the
[36:59] base design context is so useful for
[37:01] quick prototyping.
[37:02] Um this is obviously just a basic
[37:04] component example, but all of this is
[37:06] rebuilt
[37:07] inside of Webflow. Yeah.
[37:10] Really great.
[37:12] Um now that's a a super simple example,
[37:15] uh
[37:16] but we uh we'll have a a more extensive
[37:18] one with kind of a generic code base in
[37:20] MCP in a sec.
[37:22] Uh but in addition to be able to being
[37:23] able to export these to make, you might
[37:26] also want to work with workflows like
[37:27] Figma weave.
[37:29] Here's a phenomenal
[37:31] little Figma logo animation created by
[37:33] our designer James. I think when I
[37:35] copied it in there, a little pixel off,
[37:37] that's my fault, not his fault. I'm
[37:38] sorry, James. Please don't hurt me. Um
[37:41] Here's your Here's your animation.
[37:44] And we can take this this animation,
[37:46] export it as a video, and bring it over
[37:48] to a Figma weave workflow. Now this one,
[37:52] pretty fun, pretty fun. This one, uh
[37:55] might look a little bit intense. It's
[37:56] very similar to the workflow that Itai
[37:58] showed in the keynote. Uh and what it's
[38:00] doing is it's grabbing some stylings
[38:02] from an image. It's then taking that
[38:05] image,
[38:06] uh building out kind of a custom little
[38:07] Figma logo here with some image style
[38:09] transfer, and then it's using a few
[38:11] prompts to build a prompt that kind of
[38:14] understands the context of those
[38:16] original images.
[38:18] We can then use that to generate a final
[38:20] style transferred video
[38:24] right here that builds up with that same
[38:26] animation timing
[38:28] in 3D in this case.
[38:30] And we can do that with a number of
[38:32] images as well. So, this is a reusable
[38:34] workflow. I can bring in an image, you
[38:36] know, that I've generated and pull out,
[38:38] you know, a series of different videos.
[38:40] They just kind of work together and
[38:41] build them out in these Weave workflows.
[38:44] Pretty fun, right? Incredible results.
[38:47] >> [applause]
[38:48] >> Reusable workflow.
[38:50] Awesome, awesome, awesome stuff.
[38:51] Definitely check out the Weave deep
[38:53] dive. I keep Keep going over the deep
[38:54] dives, but they are fantastic.
[38:57] Um [snorts]
[38:57] great.
[38:59] So, that is uh exporting to Weave. I
[39:01] mentioned video export. If you head over
[39:05] to the export panel, you might notice
[39:06] that it got a little bit of a makeover.
[39:09] In addition to static exports that
[39:10] you've always added, we also have this
[39:12] new animated export tab.
[39:14] In here, we have a few different formats
[39:17] of animation that you can export today.
[39:19] We're working on a few more. But, we've
[39:20] got MP4, WebM, GIF, and SVG animated SVG
[39:26] that you can bring into your websites.
[39:27] Um
[39:28] we can export it at different sizes,
[39:31] resolutions, frame rates. Pro Plus plans
[39:33] have access to 4K 60 FPS exports as
[39:36] well.
[39:37] Um and just hitting that export tab will
[39:38] open up a video export workflow that you
[39:40] can bring in anywhere.
[39:42] Now, in addition to these video exports,
[39:46] we also want to see how we get these
[39:48] animations into larger production code
[39:52] bases in addition to make.
[39:54] If you'd like to do that, here's a I
[39:56] have a nice little animated bento that
[39:58] we saw earlier in the keynote.
[40:01] This is a lot of different pieces of
[40:02] animation. Converting this by hand uh to
[40:04] an enemy workflow would be a real pain.
[40:06] Uh if we head on over to dev mode,
[40:08] though, we now have a few new tools that
[40:10] you can use to hand this animation off
[40:12] to a production team or use it on your
[40:14] own if you're, you know, bringing in
[40:16] some of that design engineer uh figure.
[40:19] So, here
[40:20] I'm going to open up this timeline.
[40:22] And in dev mode, we get this read-only
[40:24] timeline view. So, if you have someone
[40:26] on your team that maybe is not as
[40:27] comfortable inside of a Figma design
[40:29] editing experience, they'll be able to
[40:30] come over here and see the full
[40:32] animations in this nice focus view
[40:34] without the distractions of anything
[40:35] else on the canvas.
[40:38] You're also going to be able to, you
[40:39] know, move the play head, take a look at
[40:41] individual animations. And when you
[40:43] select individual animated items, either
[40:45] on the canvas or inside the timeline,
[40:48] you're also going to see on the
[40:49] right-hand side that we have generated
[40:51] code assets for each of these
[40:53] animations. So, CSS, React in Motion,
[40:57] and JSON outputs.
[40:59] I know, it's awesome, right?
[41:02] You're not losing the context of your
[41:04] animations, the timings, the colors,
[41:05] everything as you're bringing them over
[41:07] to a production code base. Now, doing
[41:10] this by hand is certainly possible if
[41:11] you'd like, but you can also copy this
[41:14] little example prompt up here in the MCP
[41:17] section, and you'll be able to bring
[41:19] that into your LLM of choice, and it's
[41:21] going to be able to get all of the
[41:22] context from these animations and
[41:24] rebuild them in a real production code
[41:26] base. We switch to the slides for a
[41:28] second. We've actually got a video
[41:32] right here of that same animation
[41:35] built with an LLM,
[41:37] and we've pulled all the animation
[41:38] context out and asked it, "Can you
[41:39] actually make a brand motion site from
[41:42] this initial animation?" All of this is
[41:45] recreated in web. The animation timings
[41:47] and all the different colors are built
[41:49] in as well. Really fun stuff. So, full
[41:51] production end-to-end animation to
[41:54] product output. Pretty fun.
[41:57] >> [applause]
[42:01] >> Great.
[42:02] Now,
[42:03] so those are the basics of Figma motion.
[42:05] That's how you get started. We'd love to
[42:06] see what y'all make. We also want to
[42:08] show you a couple of things that our
[42:09] team is currently developing. And as
[42:11] Dave said, Figmotion is in beta, so we
[42:14] are looking for feedback. We want to
[42:17] hear what the community would like to
[42:18] see out of this animation tool. Here's a
[42:20] few of the things we think you'd love.
[42:22] First up,
[42:23] we have user-created animation styles.
[42:27] So, if you want to build out an
[42:29] animation,
[42:30] you're able to create maybe your brand's
[42:33] entrance animation, package that up into
[42:35] a reusable style, and share that across
[42:38] your team. You're then going to be able
[42:39] to apply that to any node and see that
[42:41] animation come to life
[42:43] on any objects inside of your design
[42:45] system. Pretty great.
[42:51] In addition to the basic interaction and
[42:54] prototyping tooling that we showed,
[42:56] we're looking to extend out the ability
[42:58] to control transition animations. When
[43:01] you know what two states are going to
[43:02] look like, sometimes you just need to
[43:03] say, "Hey, I need this property to come
[43:05] in half a second later, right?" Um and
[43:08] so we're going to be building out
[43:10] additional extensions to our transitions
[43:12] capability inside of Figma design.
[43:15] So, that's a couple of a couple of fun
[43:17] features that you can see if you come
[43:19] over to the product studio. We've
[43:20] actually got members of the team there
[43:22] with some laptops out. You can actually
[43:23] try these features today and give us
[43:25] feedback on them. We have a number of
[43:26] other things coming up. Things like user
[43:28] styles, new export formats, text
[43:31] animation systems, video on the
[43:33] timeline. We are really trying to build
[43:35] this into the best motion design tool
[43:37] for you all, and we cannot wait to see
[43:39] what you all make with it. Thank you so
[43:40] much. Have fun at Figma and enjoy
[43:42] Config.
[43:45] >> [applause]