Hero image for Digest, Nov 9–16, 2026: Figma's 3D Arrived Readable; Its Springs Forgot Their Physics

Digest, Nov 9–16, 2026: Figma's 3D Arrived Readable; Its Springs Forgot Their Physics

The question this week

When a design decision crosses the design-to-code boundary, which of its parameters can an agent read back — and which were consumed on the way in?

This week handed the question an unusually clean test. One vendor, Figma, shipped two design-to-code surfaces two days apart, and an agent reads them in opposite ways. The Nov 12 native 3D-transform work ships beside a plugin contract that is numeric, field-level, and names its own CSS counterparts — translateZ() rotateX() rotateY() rotateZ(), perspective, transform-style: preserve-3d. The Nov 10 physics-based Figma Motion springs run the other way: the designer sets mass, stiffness, and damping, and what an agent reads back from the node is one normalized bounce number. Same vendor, same week, opposite legibility — a natural experiment in what design tools actually hand to code.

What changed since last week: Figma Motion’s Machine-Readable Artifacts (Nov 1) built the verification contract for Figma’s machine-readable motion artifacts, and Motion Tokens Are Machine-Readable Now: Duration and Cubic Bezier in DTCG 2025.10 (Oct 10) covered the two token types DTCG defines for motion. This digest adds what only this week made visible: the spring parameter loss, the 3D contrast, four checks an agent can run now, and the spring-shaped hole in the DTCG format draft.

Nov 12 — 3D transforms, native in Figma

Per the Figma release notes, this is “3D transform, a new effect in Figma,” with rotation “along the x, y, and z axes” and controls to “Adjust perspective and depth.” Handoff is stated as a choice: “copy the CSS from Dev Mode or send designs directly to your coding agent with the Figma MCP,” and for composition, “let the Figma agent compose them for you.” UX News dates it — Figma “opened 3D transforms in beta on November 12 for Full seat users” — and reports that “Dev Mode exposes the CSS transform, including rotation and depth” and that “Coding agents can also read and create 3D designs through Figma MCP.” Its payload framing is the precise one: “This gives developers the transformation values behind a composition instead of only a flat reference image.”

What an agent can read: the effect name, three rotation axes, perspective and depth controls, a Dev Mode CSS path, an MCP path, and an agent-composition invitation.

What an agent cannot read: which CSS properties Dev Mode emits, or whether perspective appears in that CSS — the quote is only “the CSS transform, including rotation and depth,” with no property list. Whole-scene transfer is unproven; the report’s own caveat reads “It does not establish that an entire animated scene will transfer unchanged to every production environment.” And the launch-video composition ran through “an agent-built plugin” — “a custom tool, not a standard control included with the beta” — so nothing here supports a claim about the quality of agent-authored 3D.

Nov 12 — Plugin API Update 142: the machine-addressable 3D contract

The same day, narrower and more useful: the Plugin API updates page shipped Version 1, Update 142, “Create and animate 3D transforms.” Its identifiers: transform3d (“Read 3D transforms and create, update, or remove fixed-order transforms with Z translation and X/Y/Z rotations”), transformOrigin (“percentages or pixels on each axis”), scene3d (“Configure perspective and Preserve 3D on frames, components, and instances”), the types Transform3d, TransformOrigin, and Scene3d, and “Motion keyframe fields” (“Animate 3D rotation, Z translation, and scene perspective”). What an agent can read: those fields, the 3D keyframe field names documented in the Motion reference — TRANSFORM_3D_TRANSLATION_Z, TRANSFORM_3D_ROTATION_X, TRANSFORM_3D_ROTATION_Y, TRANSFORM_3D_ROTATION_Z, SCENE_3D_PERSPECTIVE — and full type shapes in the standing references below. What it cannot read: the shape of TransformOrigin (named only on this page), whether that keyframe field list is exhaustive or stable, and any stability guarantee — “These APIs are available in beta and are subject to change.”

The Transform3d type reference defines the union an agent has to handle: { readonly type: 'NONE' } (assign it to remove a transform); a FIXED_ORDER variant carrying translateZ, rotateX, rotateY, rotateZ plus the optional backfaceVisible and visible; and FREEFORM — “An imported transform that plugins can read. Assigning it throws an error.” FIXED_ORDER is the CSS-mapped variant: “An editable transform corresponding to the CSS transform functions translateZ() rotateX() rotateY() rotateZ(), in that order. All four numeric fields are required and must be finite. translateZ is in pixels; the rotations are in degrees.” backfaceVisible maps to backface-visibility: visible (true) or backface-visibility: hidden (false). Two scoping facts matter as much as the mapping. First, “A 3D transform changes how the layer looks on the canvas. It doesn’t change its layout size or relativeTransform” — an agent reading only relativeTransform sees no 3D at all. Second, returned objects aren’t editable in place: “copy the current FIXED_ORDER value and assign it back with your changes.”

The Scene3d type reference covers the container. perspective is “Perspective distance in pixels, corresponding to CSS perspective. Negative values disable perspective; -1 is the default.” preserve3d “Corresponds to CSS transform-style: preserve-3d when true, or flat when false.” Then the trap: “Reads return null when no scene is configured,” and “Assigning { perspective: -1, preserve3d: false } also reads back as null when visible is omitted or true” — so null is ambiguous between “no scene” and “a disabled scene.” Last, the flattening warning: avoid opacity, blend modes, effects, or clipsContent on a container whose scene3d.preserve3d is true; those properties have no visual effect there.

Nov 10 — Figma Motion: physics springs that lose their physics on read-back

Nov 10 is the countervailing release: “New Figma Motion updates: physics based springs, style and Lottie export previews” in the release notes and this forum product update, with a standing help center article and the Motion API reference.

The product surface: “Set mass, stiffness, and damping for iOS and Android, and the duration updates to match for more realistic animations. Save the spring in a design system to reuse at scale.” Presets ship as Gentle, Quick, Bouncy, Slow; “Custom curves and springs can be saved as variables”; the release documents Lottie export only as a preview — “Preview how your animation plays as a Lottie file before you export it.”

The machine contract is real. MotionEasing type takes 'EASE_IN', 'EASE_OUT', 'EASE_IN_AND_OUT', 'LINEAR', 'EASE_IN_BACK', 'EASE_OUT_BACK', 'EASE_IN_AND_OUT_BACK', 'CUSTOM_CUBIC_BEZIER', 'GENTLE', 'QUICK', 'BOUNCY', 'SLOW', 'CUSTOM_SPRING', 'HOLD', with easingFunctionCubicBezier?: EasingFunctionBezier and easingFunctionSpring?: NormalizedSpring. A custom spring payload is NormalizedSpring { readonly bounce: number }, where “bounce is a normalized value from 0 to 1.” And the machinery that makes “save the spring in a design system” machine-addressable rather than a UI promise: CustomAnimationStyle, node.applyAnimationStyle(), and animationStyles discriminated by "FIGMA" or "CUSTOM".

What an agent can read: all of that, plus AppliedFigmaAnimationStyle’s duration?: number, “expressed in seconds.”

What an agent cannot read: the physics. PhysicalSpring { readonly mass: number; readonly stiffness: number; readonly damping: number } is an input to figma.motion.physicalSpringToNormalized(). It is not a field on NormalizedSpring. It does not survive reading a node back. The conversion consumes the triple and stores one number, so every downstream consumer sees bounce and nothing else of the spring. The help center agrees: “the spring’s duration is determined by its stiffness, damping, and mass values,” and because “physics-based springs don’t follow a fixed duration,” motion can “end before or extend past a keyframe’s position on the timeline” — yet the node exposes only a number.

Two caveats bound it. Mass is scoped: note the drift between the release notes’ “for iOS and Android” and the help center’s “Mass (iOS/web only)” plus “On Android, springs don’t have a separate mass setting. Instead, they use stiffness and a damping ratio.” — how an Android spring maps to bounce is an open normalization problem these sources do not solve. And the beta stack — “available in Beta” (API), “open beta” (help center), “you may experience performance issues” (the only performance text) — gives any parser built this week no stability guarantee.

Nov 10 — The week’s only spring-to-code bridge: sampled linear()

Art Direction Daily’s November 10 issue published the only artifact in this window that carries spring intent into code, and it works by sampling, not by preserving parameters: “seventeen samples of a spring become a timing function any transition or animation accepts” — transition-timing-function: linear(0, 0.125, 0.337, …) with transition-duration: 725ms — plus “set the duration to the spring’s settle time rather than a round number.” Its bench prints “725ms to settle,” “1.00 damping ratio,” “0% overshoot” for stiffness 170, damping 26, mass 1.0. Its design move: “name the spring, not the duration.”

What an agent can read: a valid CSS timing function and a settle-time duration. What an agent cannot read: the physical parameters — a sampled linear() approximates the curve; it is not the PhysicalSpring inputs, and it lives in CSS, not in any token format.

Also in the window, briefly

Nov 10 — Adobe Firefly expansion. The announcement quotes that matter here: “a design-to-code tool to create apps and websites” and “a preview of design-to-code prototyping tools.” It names no token types, no easing fields, no transform fields, so no field-by-field comparison with transform3d or MotionEasing is possible, and this digest will not invent parity.

Nov 9 — Claude Fable 5.2 / Mythos 5.2. One line, split kept: what an agent can read — nothing interface-specific; what it cannot — any credit for design-file perception, because the announcement “makes no specific claim about interface work,” as Art Direction Daily summarized it.

Figma exposes vs DTCG defines

The DTCG format draft is the industry’s interchange target, so the week’s sharpest question is where Figma’s new surfaces and the format lose each other.

Concept Figma exposes DTCG format defines What an agent can verify computationally
Motion — duration duration?: number on AppliedFigmaAnimationStyle, “expressed in seconds” $type duration, required unit "ms" or "s" round-trip the number; attach an explicit unit
Motion — easing, cubic Bézier 'CUSTOM_CUBIC_BEZIER', easingFunctionCubicBezier?: EasingFunctionBezier $type cubicBezier, “an array containing four numbers” four-number array validation
Motion — easing, named 'EASE_IN' through 'HOLD' (fourteen type values) no named-easing type in these excerpts treat as Figma-local vocabulary
Motion — spring NormalizedSpring { readonly bounce: number }, PhysicalSpring, figma.motion.physicalSpringToNormalized() “the string ‘spring’ appears 0 times in the full specification text” no DTCG target type — flag as unconvertible
3D transforms transform3d, transformOrigin, scene3d, Transform3d, Scene3d not established by these sources parse the beta union; no token counterpart exists

Where the two lose each other: a 'CUSTOM_SPRING' reading back as easingFunctionSpring?: NormalizedSpring has no DTCG destination, because transition’s timingFunction “MUST be a valid cubic Bézier curve value or a reference to a cubic Bézier curve token.” In the other direction, a DTCG authoring tool could not reconstruct mass, stiffness, and damping from a node’s one-number easing — those values are not stored on the node at all. And duration carries a silent conversion hazard: DTCG demands an explicit unit of "ms" or "s"; Figma expresses it “in seconds,” the unit implied, never a field.

Four checks an agent can run this week

None of these were runnable before this week’s releases, and all four stand on APIs that are “in beta and are subject to change” — version every result to this week.

  1. Spring round-trip flag. On any MotionEasing with type: 'CUSTOM_SPRING', the readable payload is at most easingFunctionSpring = NormalizedSpring { bounce }, 0–1. Flag the animation non-round-trippable: mass, stiffness, and damping exist only as inputs to figma.motion.physicalSpringToNormalized().
  2. 3D read completeness. For any node whose look may include 3D, read transform3d, not only relativeTransform — because “A 3D transform changes how the layer looks on the canvas. It doesn’t change its layout size or relativeTransform.” Handle the union: 'NONE' to remove; 'FIXED_ORDER' with all four required finite numbers, assigned copy-first (“copy the current FIXED_ORDER value and assign it back with your changes”); 'FREEFORM' read-only — “Assigning it throws an error.”
  3. Scene null-ambiguity. Treat scene3d === null as ambiguous: no scene configured, or { perspective: -1, preserve3d: false } assigned with visible omitted or true — both read back as null. Treat perspective: -1 as disabled perspective; map preserve3d: true to transform-style: preserve-3d and false to flat; flag opacity, blend modes, effects, or clipsContent on a preserve3d: true container as flattening hazards.
  4. DTCG emission guard. Block any token-pipeline step that writes a spring as a DTCG token — “spring” appears 0 times in the full specification text, and timingFunction must be cubic Bézier — and require an explicit unit ("ms" or "s") whenever a Figma duration in implied seconds is converted.

FAQ

Can an agent read a Figma spring’s mass, stiffness, and damping from the file?

No. The spring payload an agent reads is NormalizedSpring { readonly bounce: number }, one value from 0 to 1. The physical triple exists only as input to figma.motion.physicalSpringToNormalized() and is never stored on the node. The presets correspond to the type values 'GENTLE', 'QUICK', 'BOUNCY', 'SLOW' — names, not physics.

Does DTCG have a spring token type?

No — “the string ‘spring’ appears 0 times in the full specification text,” and transition accepts only cubic-Bézier timing functions. The two motion types DTCG does define are the Oct 10 post’s subject; this digest adds only the gap.

Do Figma’s 3D transforms map to CSS?

Yes, via the plugin contract: 'FIXED_ORDER' “corresponding to the CSS transform functions translateZ() rotateX() rotateY() rotateZ(), in that order,” perspective to CSS perspective, preserve3d to transform-style: preserve-3d. Dev Mode’s output is quoted only as “the CSS transform, including rotation and depth” — its property list is not established.

Are the 3D and Motion APIs stable enough to build against?

Not contractually. “These APIs are available in beta and are subject to change” is the whole of Update 142’s stability statement; the Motion API is “available in Beta”; the help center says “open beta” and warns “you may experience performance issues.” Write checks that fail loudly when the shapes change.

What about Lottie export of springs?

Only a preview: “Preview how your animation plays as a Lottie file before you export it.” Which parameters survive export is not established by these sources. The Nov 1 post covers the verification contract for Figma’s motion artifacts; this digest doesn’t rebuild it.

How This Guide Was Built

Window: November 9–16, 2026. Fetched primary sources: the Figma release notes (Nov 12 and Nov 10 entries); the Plugin API updates page (Version 1, Update 142, Nov 12); the standing, undated Transform3d and Scene3d type references; the standing Motion API reference; the help center easing article; the Nov 10 forum product update; two UX News reports (3D beta, Motion springs); Art Direction Daily’s November 10 issue; the Adobe newsroom announcement; the Anthropic announcement as reported by Art Direction Daily; and the DTCG format draft. This post is built entirely from fetched primary sources, every identifier is quoted verbatim, and no hands-on testing was performed or is claimed.

The Bottom Line

The week improved agent legibility asymmetrically. 3D arrived with a numeric, field-level, CSS-mapped contract — transform3d, scene3d, named-function correspondence — beta and “subject to change,” but readable. Physics springs arrived with a one-number read-back and no DTCG destination: an agent can now verify 3D structure and detect spring loss (bounce present; mass, stiffness, damping gone), but cannot carry physical motion intent across the boundary. The defensible pattern: name springs where the designer names them, sample to linear() at settle time when code needs the curve, and treat the DTCG spring gap as the specification work this week exposed — not something any one vendor will close alone.