Converting Adobe XD Shapes to Figma — Plugin Comparison Across 5 Shape Types

When you migrate Adobe XD files to Figma, you sometimes hear things like “rectangles came through fine, but compound paths and boolean shapes broke” or “some corner radii disappeared.” Boolean shapes are forms like clouds, crescents, arrows, or hearts — shapes built by combining multiple primitives with Union, Subtract, Intersect, or Exclude operations. These breakages usually aren’t a Figma problem; they come from differences in how far each converter plugin can faithfully reproduce XD’s shape types — in other words, conversion precision.

This article walks through the 5 shape categories XD supports and how each one translates into Figma, using Pixel Fine Converter (PFC) as the reference point. To help you decide when plugin selection actually matters, we also cover 4 criteria for evaluating converters and a side-by-side comparison table.

📝 Why XD shapes look slightly off in Figma

XD and Figma are both vector-based design tools, but their internal shape representations differ in subtle ways. For example, XD’s Rectangle can hold a separate corner radius for each of the four corners — and Figma can too. Boolean operations (Union / Subtract / Intersect / Exclude), on the other hand, may be stored either as a “pre-baked, flattened path” or as “the original components plus the operation type,” and tools differ in which form they keep.

So even when two files represent “the same shape,” the information actually recorded on disk can differ between the two tools. A converter plugin’s precision comes down to how much of that gap it can close. Simple rectangles and circles come through almost perfectly on every plugin. The differences show up in icons and decorative elements that rely heavily on compound paths or boolean operations — where each plugin’s implementation quality starts to leak into the visual result.

In this article, we split XD shapes into 5 types and walk through how each one behaves during conversion.

🧩 The 5 XD shape types — Rectangle / Circle / Polygon / Compound Path / Boolean

XD’s shape primitives fall into five main categories internally. Here’s a quick rundown of each, together with the Figma node type they map to.

1. Rectangle (with per-corner radius)

The most-used type in XD. Each of the four corners can have its own corner radius (for example, a “tab” shape with only the top-left rounded). Figma supports both uniform corner radius and per-corner values, so as long as the converter reads the individual values out of the XD file, the rectangle reproduces cleanly as a Figma RECTANGLE node.

2. Circle / Ellipse

In XD, an Ellipse is treated as a circle when width equals height, and as an ellipse otherwise. These convert to Figma ELLIPSE nodes, with fills, strokes, and effects carried over straightforwardly.

3. Polygon / Line

XD’s Polygon is a regular polygon with a configurable side count (triangle, pentagon, hexagon, and so on). Line is a two-point straight segment. In Figma, these become POLYGON / LINE or VECTOR nodes — some plugins choose to unify polygons under VECTOR.

4. Compound Path

A compound path treats multiple sub-paths as a single shape. A common example is a “donut” built from an outer circle and an inner circle combined into one figure. In Figma, this maps to a VECTOR node, with the fill-rule setting (called Fill Rule in the UI, windingRule in the internal API) controlling how holes are rendered. This is where converter-plugin implementations start to diverge — whether the inner path is recognized as a hole determines how the shape looks in Figma.

5. Boolean Operation

XD supports four boolean operations: Union, Subtract, Intersect, and Exclude. Figma supports the same four as BOOLEAN_OPERATION nodes. However, XD files typically store the pre-baked result of the operation rather than the original components and operation type. Most converters therefore import this as a single VECTOR node, and reconstructing the BOOLEAN_OPERATION structure in Figma requires manual work.

⚖️ 4 criteria for choosing a shape-conversion plugin

How accurately each of the 5 types converts varies by plugin, so when you’re picking one, these four criteria are a practical lens to evaluate against.

Criterion 1: Conversion precision (position, size, rotation, color)

Whether the shape’s position, size, rotation angle, and fill color match the XD original. XD stores coordinates as floating-point numbers at 0.001 precision, but rounding during conversion can introduce 0.5px to a few px of drift. On a panel UI with rows of icons, even small misalignments are visually noticeable.

Criterion 2: Range of supported types

Whether the plugin supports all five shape types or only a subset. Every plugin handles Rectangles and Circles, but coverage diverges noticeably once you get to Compound Paths and Boolean Operations.

Criterion 3: Corner radius preservation

Whether per-corner radius values are reproduced. This matters for UI work where you build “header bars with only the top-left rounded” or “cards with only the right side rounded.” If a plugin can’t read individual corner radii, it tends to collapse all four corners to a single value (often the largest, or zero).

Criterion 4: Pricing and free tier

Plugins come in several pricing models: fully free, freemium with paid upgrades, one-time purchase, or subscription. If you only need shape conversion, a free tier might be enough; for complex files, you may need paid features.

📊 Plugin comparison — Pixel Fine Converter / Angel Converter / Convertify Sketch/Adobe/Google / manual SVG export

The table below compares the main XD → Figma converter plugins alongside manual SVG export (exporting from XD as SVG and importing into Figma). Exact behavior depends on hands-on testing for each plugin, so the table states PFC’s behavior based on its official spec, and shows whether the other plugins’ public documentation confirms equivalent coverage.

🎯 How Pixel Fine Converter handles each shape type

PFC reads XD files directly and converts them into native Figma nodes. Here’s how each shape type translates.

Rectangle

XD Rectangles map to Figma RECTANGLE nodes. If the XD file stores corner radii as an array of four independent values, each is mapped to the matching Figma corner property (top-left / top-right / bottom-right / bottom-left). If a single uniform radius is recorded, it’s set via cornerRadius. Fills, strokes, and effects (shadows, blurs) are handled separately — this section focuses on shape geometry only.

Circle / Ellipse

Width and height are read as-is and mapped to a Figma ELLIPSE node. Because XD and Figma handle ellipse center points and radii almost identically, conversion drift is negligible.

Polygon / Line

Both XD Polygons and Lines convert to Figma VECTOR nodes. For polygons, the path data — derived from the side count and circumscribed circle radius — is passed directly into the VECTOR’s vectorPaths. Lines use VECTOR rather than Figma’s LINE node intentionally: drawing a line with LineNode shifts the line vertically by half of strokeWeight, a known quirk that VECTOR avoids, so line positions stay aligned between XD and Figma.

Compound Path

When XD stores “multiple sub-paths combined into one shape,” it converts to a Figma VECTOR node. The Fill Rule is set to Even-odd or Non-zero based on the XD file’s winding specification (evenodd or not). This makes outer/inner path overlaps render as proper “holes” — the typical case for donut shapes, gear shapes, and decorative letterforms like “O,” “8,” or “0,” where rendering differences are easy to spot.

Boolean Operation

When XD applies Union / Subtract / Intersect / Exclude to a shape, the XD file typically stores only the result of that operation as a flattened path. PFC imports this flattened path as a Figma VECTOR node. If you want to rebuild the pre-operation BOOLEAN_OPERATION structure in Figma for re-editing, you’ll need to separate the source components manually.

🏗️ Why PFC stands out for complex shapes

If your design only uses simple rectangles and circles, almost any conversion method works. The difference shows up when you migrate designs that include the following kinds of “complex shapes.”

1. Icons and decorative elements

Service logos, icons, and decorative graphics frequently rely on boolean operations and compound paths. PFC imports both boolean results and compound paths as editable VECTOR nodes, with position, size, and color closely matching the XD source. You can preserve the design’s overall consistency and still make fine-grained tweaks on the Figma side (if you need the boolean structure itself for re-editing the operation in Figma, you’ll have to separate the source paths manually).

2. Shapes inside UI components (Pro feature integration)

For UI elements like buttons, cards, and modals — components that contain shapes — conversion quality depends not just on the shapes themselves but on preserving the component structure. PFC’s Pro features convert XD symbols into Figma Components, so the internal shape structure stays intact. For details, see Converting XD components / symbols into Figma Components — the complete guide.

3. Shapes inside Auto Layout

XD shapes laid out via Stacks convert to Figma Auto Layout through PFC’s Pro features. Within Auto Layout, each shape is treated as an independent child, so the responsive behavior also carries over. See Converting XD Stacks and Repeat Grids to Figma Auto Layout for the full mechanics.

4. Shapes combined with effects

When effects like shadows, blurs, or gradients are applied to a shape, conversion quality depends not only on the shape but also on the effect reproduction precision. PFC’s behavior for shadows and effects is covered in detail in How XD shadows and effects translate to Figma.

⚠️ Common failure patterns and how to avoid them

Here are the most common stumbles in shape conversion and how to work around each.

Pattern 1: Corner radii collapse to a single value

Symptom: A rectangle with “top-left only 16px, others 0px” ends up with all four corners at 16px (or 0px).

Cause: Some plugins only read the uniform corner radius value from the XD file and ignore the array form that holds per-corner values.

Workaround: Use a plugin that preserves per-corner radius (like PFC), or pre-export special-shaped rectangles as SVG and import them individually.

Pattern 2: Boolean Operation structure isn’t re-editable

Symptom: After converting a Union’d shape to Figma, you want to edit the pre-boolean components — and realize it came in as a flattened path.

Cause: XD files commonly store only the boolean result path, not the source components and operation type. Reconstructing the pre-operation structure during conversion is technically difficult, and most converters — including PFC — share this limitation.

Workaround: If you only need the shape as an icon, the flattened path is still editable (vertices, colors, and fills can all be edited). If you need the boolean structure itself, keep the source paths separate in XD before migrating, then reapply the boolean operation in Figma.

Pattern 3: Compound Path “holes” get filled in

Symptom: Donut or gear shapes show up in Figma as solid filled circles or gears.

Cause: The Fill Rule (how holes are determined; windingRule in the internal API) wasn’t set correctly during conversion.

Workaround: Use a plugin that sets Fill Rule to Even-odd correctly (like PFC), or switch the target VECTOR’s Fill Rule to Even-odd manually in Figma.

📌 Wrap-up — solo designers vs. team workflows

The short version: simple rectangles and circles convert cleanly across every plugin; complex shapes are where converter precision actually matters.

• Solo designers / small projects: If your designs are mostly simple shapes, the free tier handles them. PFC’s Free plan supports up to 3 artboards / 30 MB, and all five shape types (Rectangle / Circle / Polygon / Compound Path / Boolean) are covered as Free features.
• Teams / mid- to large-scale design systems: If your files include icon sets, components, or Auto Layout structures, pairing shape conversion with Pro features earns you “results that stay editable as native Figma structures” — which is what makes the post-migration work practical.

Shape conversion is the starting line of any migration project. Once shapes carry over without breakage, you can build on top of that foundation with confidence as you migrate Components, Auto Layout, and effects. A realistic flow is to try 1–2 artboards on the Free plan first, confirm that precision holds up even on files with complex shapes, and only then commit to the full migration.

Related pages

• Blog: Adobe XD to Figma migration — practical guide — End-to-end migration process and checklist
• Blog: XD→Figma converter plugins compared — Pixel Fine Converter and Angel Converter compared across 4 criteria
• Blog: Converting XD components / symbols into Figma Components — the complete guide — Symbol conversion and Components / Variants mapping
• Blog: Converting XD Stacks and Repeat Grids to Figma Auto Layout — Auto Layout conversion and Alignment inference
• Blog: How XD shadows and effects translate to Figma — Shadow, blur, and effect conversion precision
• Blog: Adobe XD support status and migration timing — When and how to time your migration
• Features: Auto Layout conversion — How XD Stacks become Figma Auto Layout
• Features: Components conversion — Restoring component / instance structure
• Features: Prototype & States — Prototype connections and state conversion
• Features: Fine-tuning — Compensating XD-vs-Figma rendering differences