On this page
A Figma screen describes an interface, but a working web page also needs document structure, responsive layout and behavior. Before exporting, decide whether the developer needs styling details, a standalone HTML/CSS package or components for an existing application. Those outputs solve different parts of the job.
This guide covers Pixso for design inspection and eligible D2C workflows, followed by Anima, Builder and pxCode for generating front-end code. Keep the original design file, try one representative screen and inspect the exported result before converting the rest of the project.
1. Prepare a Figma design for handoff in Pixso
You can import a supported Figma file into Pixso’s collaborative UI workspace, inspect layers and share implementation details. Copying a selected layer’s CSS is a styling handoff: it does not, by itself, export the page’s HTML structure or implement its interactions.
Pixso supports Figma and Sketch import, editable design work, reusable resources and team review. Import is a conversion between formats, so check fonts, components and layout in a copy before replacing any working source. Import permissions and design-file limits depend on the account and workspace you use.
For a styling handoff, follow these four steps. The screenshots illustrate the import and inspection workflow; older interfaces may label inspection as Handoff.
Step 1. Sign in to Pixso and open the workspace where the team will review the design. Keep a local copy of the original Figma file and confirm that you are allowed to export it.
Step 2. Use the workspace’s Import file option, select Figma and choose the supported local file. Open the imported design and compare a representative frame, including text wrapping and component states, with the original.
Step 3. Enter Dev View and select the layer the developer needs to implement. Inspect its dimensions, spacing, colors and exportable assets. Share the relevant layer or screen with the developer so the details have a clear visual reference.
Step 4. Copy the available CSS styling information and export the required assets. The developer still builds the semantic HTML and connects behavior. For generated application UI, Pixso also offers D2C⁺: the documented prerequisites are an Enterprise Full-feature Seat or Dev Seat and a file in that enterprise space, including its personal drafts. In Dev View, choose D2C⁺, select the page, component or layer, and generate React, Vue or Flutter output. This is a separate code-generation workflow, not a claim that every free account exports a complete HTML website.
2. Generate front-end code with Anima, Builder or pxCode
Choose the tool according to the artifact you need. An HTML package is useful for a standalone page; framework components are more useful when the team already maintains an application. In either case, review the generated structure and test it in the intended environment.
Anima: HTML/CSS or framework output
Anima’s current Figma plugin works in Design/Edit Mode and Dev Mode, with output and styling settings. Its HTML guidance distinguishes inspecting selected elements in Dev Mode from generating a whole flow in Edit Mode. Use the latter when you need linked screens and responsive breakpoints.
Source: Anima. The screenshot shows an earlier export interface; use the current output settings described below.
- Step 1. Open the Anima plugin from Figma and select the frame, section or component to convert. For a whole flow, prepare the relevant screens and connections in Edit Mode.
- Step 2. Choose HTML and the styling option that fits your project. Check Auto Layout and constraints in the design, then configure the breakpoints needed for the target widths.
- Step 3. Preview the generated result at both narrow and wide widths. Inspect text wrapping, image proportions and whether controls remain reachable.
- Step 4. Adjust the design or generation settings where the preview differs from the intended behavior. Confirm the export access included in your Anima account before committing to the workflow.
- Step 5. Copy the generated code or download the code package, as appropriate for the selection. Open it in a local development environment, inspect the HTML/CSS and run the interaction checks below. The older screenshot’s Sync & Get Code and ZIP options are not required labels in every current plugin view.
Builder: bring designs into a code project
Builder’s current Figma-to-code workflow exports selected designs through its Figma plugin into a Fusion/Code Space or a codebase through the CLI. This is different from importing an existing website into Figma. Start from the export direction that matches your task.
- Step 1. Install the official Builder Figma plugin and open it in the design file you can access. Select a representative frame rather than sending the entire project before you have checked the result.
- Step 2. Use the plugin’s design export workflow and send the selection to the intended Builder space or codebase. The documentation describes Smart Export and Classic Export; choose the supported route for your project and inspect the imported result.
- Step 3. Customize the generated code for your framework, styles and reusable components. Run it inside the application, check its dependencies and wire up data and actions. A successful import into Builder does not establish that your application logic is complete.
pxCode: refine responsive layout before export
pxCode offers Figma-to-code workflows with HTML and framework output, plus a visual editor for responsive adjustments. It is useful to evaluate when one design must adapt across widths and the team wants to inspect or refine that layout before exporting.
The workflow has four stages: export the selected design, create a pxCode project, adjust layout and export the resulting code.
- Step 1. Open the official pxCode plugin in Figma and select the frames you intend to convert. Confirm that their layer names, grouping and image assets are understandable before export.
- Step 2. Export the design through the plugin. The illustrated version uses Download All; follow the current plugin’s export control and keep the generated package together.
- Step 3. Open pxCode in the browser, create a project and import the exported design. Compare the imported layers with the source and resolve any missing fonts or assets before adjusting layout.
- Step 4. Refine responsive behavior in the visual editor, then choose the required HTML or framework output. Download the code, inspect its structure and integrate it into the destination project. Check both intermediate widths and the widest/narrowest intended layouts.
3. Validate the handoff with a working page
Code generation makes a design easier to inspect in a browser, but responsiveness is not proved by a single successful preview. Replace short placeholder text with realistic content, resize between the intended breakpoints and check whether images, buttons and validation messages still fit. HTML structure, keyboard operation and application data need their own checks.
Agree on the acceptance criteria before exporting. The designer can identify intended states and spacing; the developer can check semantics, maintainability and behavior. Record unresolved decisions next to the relevant screen instead of leaving the next person to infer them from a static image.
Example: a product card that survives real content
Use a card with an image, product name, price and Add to cart button. Add a long product name and an unavailable item. This is a proposed acceptance exercise, not a claim that a particular exporter passed it.
| Test | Expected result | What to inspect |
|---|---|---|
| Long product name | The title wraps without hiding the price or action. | Flexible height, spacing and overflow rules. |
| Narrow viewport | The image keeps its proportions and the button remains usable. | Container width, image dimensions and responsive layout. |
| Keyboard operation | Tab reaches the action, focus is visible and the button works from the keyboard. | Semantic button markup, focus styling and event handling. |
| Cart request fails | The user receives a clear error and can retry without losing context. | Loading, disabled and error states connected to real application behavior. |
For a form, also connect labels to inputs and check how errors are announced. For a component export, compare the generated interface with the application’s existing component API before adding a second implementation of the same control.
Choose the output your team can maintain
Use Pixso inspection when the team needs a shared visual reference, assets and styling details; evaluate D2C⁺ when its documented access and framework output fit the project. Use a dedicated HTML export route when a standalone web page is the actual deliverable.
Start with one screen in Pixso or your chosen exporter, validate the result, and expand only after the workflow is clear. Keep design decisions, generated code and the developer’s remaining work connected so later changes can be implemented deliberately.





