Overview Auto Layout Components Prototype Japanese fonts Fine-tuning

Faithfully recreate your Adobe XD components — drop them straight into Figma!

Of all the work involved in migrating from Adobe XD to Figma, component conversion is one of the costliest things to rebuild. (The other heavy hitter is Auto Layout conversion — see “Skip the XD-stack rebuild — drop your layouts straight into Figma Auto Layout!” for that side of the story!)

Buttons, cards, navigation bars — recreating the very backbone of your design system as Figma Components by hand simply isn’t realistic on a large file 😇

Pixel Fine Converter turns XD symbol definitions into Figma main components, and symbol instances into Figma instances. Text and style overrides, per-instance resizing, and even component states (hover, pressed, and friends) are faithfully restored as Figma Variants!

Note: Component conversion is a Pro plan ($29, one-time purchase) feature. The plugin itself is free to install, and the Free plan still handles structure, styles, groups, and other basic conversions.

📋 What the conversion reproduces

Pixel Fine Converter (Pro) reproduces the following component-related structures from your XD file:

ItemWhat it does
Main componentsXD symbol definitions become Figma main components with layer hierarchy, styles, and child node structure preserved
InstancesXD symbol instances are placed as Figma instances with their reference to the main component intact
Text overridesPer-instance text edits are preserved, including character-level color (range fill)
Style overridesPer-instance color, opacity, and visibility overrides are preserved
Instance resizingInstances with sizes different from the master are resized to match the source. Precision is configurable via Strict / Standard / Tolerant tolerances
States → VariantsXD component states (hover, pressed, etc.) become Variants inside a Figma Component Set, managed as variant properties like State=Hover

All of this runs by analyzing the XD document structure locally on your machine. Your file data is never sent to any external server. 🔒

🧩 Why this is technically hard

XD and Figma have fundamentally different design philosophies for components. That mismatch is what makes naive conversion impossible!

⚡ XD’s flexibility vs Figma’s strictness

XD instances are extremely flexible, and are allowed to differ structurally from their master symbol. The type of a child node can change (say, a rectangle becomes a mask group), and the number or order of children can shift too.

Figma instances, by contrast, must match the main component exactly in structure. You can’t add, remove, or retype child nodes — only property overrides are allowed. That’s the core gap we have to bridge!

🔎 Structural match verification

Before creating an instance, Pixel Fine Converter recursively compares the node tree of the master and the instance to check they match structurally:

  • ✅ Matching node types (GROUP ↔ FRAME variance allowed)
  • ✅ Matching sizes (tolerance of 1% of dimension, minimum 1px)
  • ✅ Matching positions and rotations for children
  • ✅ Consistent vector paths

When structure doesn’t line up, we fall back to a plain frame rather than force-create a broken instance. Appearance stays as faithful as possible, but we never ship you a component graph that’s already broken on arrival 🛡️

🧬 Selective merge of overrides

When overlaying XD instance properties onto the master, blindly overwriting everything breaks the structure. Pixel Fine Converter performs a selective deep merge: primitive values like color and opacity come from the instance, while structural metadata (node types, constraints, layout info) stays from the master. It’s grimy work!

🔁 Detecting cycles in state references

XD states can reference other states, so cyclic references (infinite loops) are possible in theory. We walk the state reference graph before conversion and verify it’s cycle-free before generating any variants. For very large components (500+ nodes) we also auto-limit variant generation to respect memory constraints — a belt-and-braces safety measure 💪

⚠️ Limits and scope (being upfront about it)

We’ve talked up the good parts so far, but the fundamental “different design philosophies” problem between XD and Figma can’t be fully solved by any converter. Some things are technically or practically out of reach — here are the honest caveats:

  • Instances whose structure differs significantly from the master are converted as plain frames rather than real component instances. Appearance is preserved but the component reference is lost
  • Instance resizing works best when heights match the master. Instances with large size changes may need a tolerance adjustment
  • Text override font loading is asynchronous, so files with many unused fonts can take a bit longer to convert
  • The full option behavior is documented in Guide: Components option reference

Even across these structural differences, we aim for a result that’s as faithful as the data allows — and we keep improving it. We’ll keep working to make the plugin one you can genuinely rely on.

🚀 Try the Free plan first to check conversion quality

Pixel Fine Converter is free to install from the Figma Community! The Free plan includes the full set of basic conversions — shapes, text, styles, groups, masks, images, transforms — so you can check the conversion quality on your own .xd file right away.

If you need component conversion, instance resizing, or state-to-variant mapping, you can unlock them with the Pro plan ($29, one-time purchase — no subscriptions) 🎁

🚀 Install on Figma (Free)

One-click install from Figma Community