React

63 posts

figmaAug 24, 20212 min readCurated summary

What’s new in Figma: August 2021 | Figma Blog

Figma’s August 2021 updates focus on faster workflows, more flexible customization, and easier design-system management. The company expanded its plugin ecosystem into FigJam, improved the Figma plugin API, and introduced tools for moving, swapping, and finding components. Smaller usability improvements also addressed common frustrations in both products. ## Plugins and Widgets for FigJam - FigJam gained support for: - **Plugins**, which automate tasks such as organizing sticky notes, customizing styles, and importing data. - **Widgets**, interactive canvas objects for polls, voting, games, notepads, and other collaborative activities. - Plugins are accessible to users on every plan. - Developers can create plugins with basic HTML and JavaScript, while widgets can be built with React. - Widgets were initially offered through a private beta. ## Expanded Figma Plugin API - Plugins can now write to prototypes, enabling developers to: - Automate prototype creation. - Modify interactions in bulk. - Improve prototyping workflows without manual repetition. - **Plugin parameters** let users provide input through quick actions, avoiding the need for custom plugin interfaces. - Plugin parameters were released in open beta, with examples available through Figma’s plugin samples. ## Easier Design-System Maintenance Three component-management improvements make it simpler to scale and reorganize design systems: - **Move components:** Published components and component sets can be moved between files without breaking instance links. - **Swap libraries:** Entire style and component libraries can be replaced at once instead of updated individually. - **Search components:** Pressing **Shift + I** opens a shortcut for quickly locating components. ## Usability Improvements - Transparent objects now automatically knock out shadows behind them, reducing the need for manual adjustments. - Holding **Shift** while using the pencil tool constrains lines to straight paths in both Figma and FigJam. - Additional bug fixes and improvements were documented in Figma’s release notes. Together, these updates make Figma and FigJam more extensible, collaborative, and efficient—particularly for teams managing large design systems or automating repetitive design and prototyping tasks.

React Figma Design Systems Figjam+3

figmaAug 23, 20212 min readCurated summary

Bringing the power of our open platform to FigJam | Figma Blog

Figma is extending its open plugin platform to FigJam, allowing builders to create plugins and interactive widgets. Plugins automate individual workflows, while widgets support collaborative experiences such as polls, voting, and games. The APIs are designed to be approachable for developers familiar with JavaScript, HTML, or React. ## An Open Platform for FigJam - Figma’s original plugin API aimed to make customization accessible: anyone who can build a website should be able to build a plugin. - FigJam extends this philosophy while emphasizing collaboration and shared interaction. - Plugins can connect workflows, import real data, and automate repetitive design or brainstorming tasks. ## Interactive Widgets for Collaboration - Widgets can be dragged directly onto FigJam boards and used by multiple participants. - Potential uses include: - Voting and polls - Games - Interactive team activities - The widget API is declarative and functional. - Developers define interfaces with components such as `Frame`, `Rectangle`, `Text`, and `SVG`. - Event listeners can execute code in response to actions such as clicks. - Widgets can include inline property menus similar to native FigJam objects. - Synced state allows interactions, such as a counter, to remain consistent for everyone in the file. - The API is modeled after React, with components whose properties resemble CSS, reducing the learning curve for React developers. ## Plugins for Workflow Automation - Plugins are intended to reduce repetitive work and help teams focus on collaboration. - Examples include converting CSV data into sticky-note grids or creating sticky notes from text. ### Organization and Synthesis - Sort sticky notes by color. - Add tags for categorization. - Extract themes with tools such as word clouds. - Count votes using stamp counters. ### Task Automation - Add features such as spell checking and find-and-replace. - Generate large groups of objects automatically, such as 100 colored sticky notes. - Existing Figma plugins, including SPELLL, can be republished for FigJam. ### Content Libraries - Import icons, emojis, logos, and other reusable assets. - Planned integrations include Icons8, Material Design icons, Iconify, and Brandfetch. ### Customization - Plugins can help users apply custom colors, fonts, and text styles, addressing requests for more personalization in FigJam. FigJam’s open platform combines workflow automation with collaborative interactivity, giving developers a straightforward way to build tools that make brainstorming more efficient and engaging.

React Figjam JavaScript API+4

figmaAug 18, 20203 min readCurated summary

React at 60fps: improving scrolling comments in Figma | Figma Blog

Figma improved comment-scrolling performance threefold by targeting unnecessary React work during canvas panning and zooming. Although comment pins must recalculate their positions on every viewport update, unrelated fixed-position UI components were also re-rendering. By isolating viewport-dependent updates and optimizing comment transformations, Figma moved closer to its goal of maintaining 60fps even in files with many comments. ## The Performance Goal - Figma aimed to render the editor at 60fps, which is substantially smoother than 15 or 30fps. - Growing numbers of comments and threads exposed slowdowns while users panned and zoomed around the canvas. - Comment pins are anchored to canvas content, so their positions must continuously respond to viewport changes. ## Figma’s Rendering Architecture - The editor combines WebGL, WebAssembly, TypeScript, and React—effectively a browser-based design tool with a dynamic React interface. - Viewport updates are stored in Redux. - Comment components read viewport state and calculate their positions relative to the canvas. - Unlike static React interfaces, comments move as part of the canvas and must update frequently. ## Diagnosing the Bottleneck - Chrome Performance tools showed that JavaScript consumed most of the frame time. - With 30 comments, approximately 68ms per frame was spent on JavaScript, producing about 19fps. - React Profiler showed that rendering the comments themselves took only about 1.8ms. - The larger problem was unnecessary re-rendering of fixed UI elements such as: - The left panel - Toolbar - Properties panel - Comments list - Other components that did not depend on viewport movement - This revealed that viewport updates were propagating too broadly through the React component tree. ## Preventing Unnecessary Re-renders - Figma narrowed which components subscribed to viewport changes. - Components that did not need changing viewport data were prevented from re-rendering. - The optimization focused on separating dynamic canvas-attached comments from fixed interface elements. - Reducing this wasted React work freed time in each frame for the comment pins that actually needed updates. ## Optimizing Comment Positioning - Comment pins must transform their positions whenever the canvas viewport changes. - Figma optimized the transformation calculations and the way those updates were applied to the components. - This reduced the JavaScript cost of moving many comment pins simultaneously. ## Results - Scrolling comments became roughly three times faster. - The improvements brought performance closer to the 60fps target. - Figma planned to continue improving performance as files and comment counts scale. The main lesson is to profile both browser execution and React rendering separately. For highly interactive views, performance depends not only on optimizing the visible components, but also on ensuring that unrelated parts of the application do not re-render in response to high-frequency state updates.

React TypeScript Webassembly Webgl+2

figmaSep 5, 20192 min readCurated summary

An in-depth sneak peak at what 5 plugin developers are cooking up | Figma Blog

Figma’s first Plugin Show & Tell highlighted the creativity and practical value emerging from its newly opened plugin ecosystem. The livestream featured five developers demonstrating tools for design-system quality checks, spell checking, icon management, documentation, typography, and even voice control. Figma encouraged developers to explore its Plugin API, build tools for their own workflows, and participate in future community events. ## Community Plugin Showcase - The event was created to: - Promote community-built plugins. - Encourage developers to experiment with the Figma Plugin API. - Give users an early look at upcoming tools and features. - The recorded livestream included live demos from five plugin developers. ## Design Quality and Productivity Tools - **Toybox Roller**, presented by Jono Kolnik, helps identify and correct design errors and inconsistencies against an organization’s design system. - **Tekeste Kidanu’s Spell Check plugin** brings spelling assistance into Figma. - Tekeste also demonstrated integrating **Cleanmock** directly into Figma. ## Icons, Documentation, and Object Management - **Iconify**, presented by Vjacheslav Trushkin, provides access to hundreds of icon sets for use in both design work and production workflows. - Jackie Chui demonstrated several utilities: - Improvements to **Find & Replace**. - A plugin for adding documentation links to components. - **Paste to Fill**, which converts pasted content into image fills. - A forthcoming tool for managing margins and object sizing within frames using configurable presets. ## Typography and Voice Control - Andrew Goodwin showed a plugin for selecting and applying typography rules. - He also demonstrated a voice interface for controlling Figma. - The project aimed to map the entire Figma Plugin API to voice commands, allowing users to operate many Figma features verbally. ## Resources for Plugin Developers Figma directed developers to several resources: - Setup guides explaining plugin architecture, canvas communication, browser APIs, and development workflows. - Official Plugin API documentation. - Figma Plugin DS, a dependency-free HTML, CSS, and JavaScript design system modeled after Figma’s interface. - Open-source plugin examples on GitHub. - FigPlug for TypeScript, React/JSX, asset bundling, and manifest generation. - A community Slack workspace for questions and collaboration. The event demonstrates that Figma plugins can automate repetitive work, connect external data and services, and tailor Figma to specialized team workflows. Developers interested in extending Figma should start with the API documentation and open-source examples, or build a private plugin for internal needs.

React TypeScript JavaScript CSS+4

figmaAug 21, 20193 min readCurated summary

How to build a plugin system on the web and also sleep well at night | Figma Blog

Figma’s plugin system had to let untrusted third-party JavaScript interact with a powerful, browser-based design editor without compromising security, performance, or stability. The team evaluated several isolation strategies, ultimately favoring JavaScript Realms because they supported synchronous APIs and avoided the performance costs of a full interpreter. Figma later replaced that implementation with a JavaScript VM compiled to WebAssembly after a vulnerability was found in the third-party Realms shim. ## Why Plugin Isolation Was Difficult - Plugins needed access to Figma’s document model while remaining isolated from: - User data and credentials - Figma’s internal application state - Other plugins - The host page and browser APIs - Simply calling `eval(PLUGIN_CODE)` would execute arbitrary code in Figma’s main environment. - Figma’s architecture added constraints: - The editor relied heavily on WebGL and WebAssembly. - Parts of the interface used TypeScript and React. - Multiple users could edit files simultaneously. - Plugins also needed to remain performant and avoid breaking as Figma evolved. ## Attempt 1: The `<iframe>` Sandbox - The team first considered the browser’s standard isolation mechanism: sandboxed `<iframe>` elements. - An iframe could separate plugin code from Figma’s main page and restrict access using browser security policies. - Communication between the plugin and Figma would use mechanisms such as `postMessage`. - However, this created an important limitation: iframe communication is asynchronous. - Figma’s plugin API needed synchronous access to document operations, making an iframe-based architecture awkward and potentially expensive. - The iframe approach also introduced additional browser contexts and messaging overhead. ## Attempt 2: A JavaScript Interpreter Compiled to WebAssembly - The second approach was to run plugin code inside a JavaScript interpreter rather than the browser’s native JavaScript engine. - The interpreter could expose only explicitly approved Figma APIs, providing a strong security boundary. - Compiling the interpreter to WebAssembly offered a way to integrate it efficiently with Figma’s existing WebAssembly-heavy architecture. - The drawbacks included: - Interpreted JavaScript would be slower than native execution. - The interpreter would require ongoing maintenance and compatibility work. - Supporting the full JavaScript language and modern features would be difficult. - Although attractive from a security perspective, this approach appeared to impose too much performance and implementation cost at the time. ## Attempt 3: JavaScript Realms - Realms provided a separate JavaScript global environment within the same browser process. - Figma could execute plugin code in a distinct Realm while exposing a carefully controlled plugin API. - Unlike iframes, Realms allowed plugin calls to remain synchronous. - Unlike a custom interpreter, plugin code could use the browser’s native JavaScript engine. - The implementation required carefully controlling built-in objects and preventing plugins from escaping their isolated environment. - This approach offered the best balance of: - Native JavaScript performance - Synchronous API access - Isolation from Figma’s application state - A relatively small integration surface ## Later Security Change - After publication, Figma discovered a security vulnerability in the third-party Realms shim used by its original implementation. - The vulnerability was fixed before public disclosure, and Figma reported no evidence that it had been exploited. - Figma subsequently changed its sandbox to use a JavaScript VM written in C and compiled to WebAssembly. Figma’s experience shows that plugin systems require more than simply restricting access to browser APIs. The isolation boundary must also preserve performance and API usability, while being robust enough to withstand vulnerabilities in the underlying sandbox technology.

React TypeScript JavaScript Webassembly+3

figmaJun 26, 20192 min readCurated summary

What’s new on DesignSystems.com: June roundup | Figma Blog

DesignSystems.com’s June 2019 roundup highlights the growing depth and diversity of design-systems practice. The featured articles cover icon creation, agency collaboration, accessible React architecture, and white-label customization. Together, they show how design systems can support consistency while remaining adaptable to different products, teams, and users. ## Iconography from Creation to Handoff - Bonnie Kate Wolf’s guide explains how to create, organize, and implement icons within a design system. - Topics include: - Strokes and fills - Boolean operations - Icon organization - Preparing assets for developer handoff - The guide is intended for both beginners and experienced icon designers. ## Building Design Systems with Clients - Instrument shares an agency perspective based on work with companies such as Nike, Google, Airbnb, Sonos, and LinkedIn. - The agency emphasizes complete, scalable systems rather than one-off design solutions. - Its process depends on close collaboration with clients to establish a shared understanding of: - What a design system should provide - How reusable components will work - How the system can support multiple applications ## Accessible React Containers - Zendesk’s Garden design system introduced “containers” to share keyboard and accessibility behavior across React components. - These containers: - Render no user interface - Handle keyboard and mouse interactions - Support right-to-left layouts - The new open-source `react-containers` library separates these behaviors from Garden’s styling package. - The containers were rewritten to be smaller, more efficient, and more closely aligned with WAI-ARIA Authoring Practices 1.1. ## White-Labeling and User Customization - Dawn Labs developed a system that lets third-party users customize an application while preserving overall consistency. - Its implementation combines: - `styled-components` - `styled-system` - A GraphQL backend - Because users needed more control, the team created a styling escape hatch using global CSS injection and CSS variables. - This approach allows end users to customize the interface without requiring intervention from the original client. The roundup demonstrates that effective design systems must balance structure with flexibility. Teams can use shared standards, accessible component patterns, and controlled customization to create systems that scale across products and audiences.

React Design Systems Accessibility GraphQL+4

figmaNov 7, 20183 min readCurated summary

Using constraints & magic numbers to build responsive layouts in Figma | Figma Blog

LittleBits built a responsive design system to support four apps across mobile and tablet platforms with a small team and six-month deadline. They combined Figma constraints with an 8-pixel “magic number” and proportional scaling rules that were shared with their React implementation. This approach allowed one template per screen to adapt across devices with minimal redesign and engineering adjustments. ## Establishing an 8-Pixel Layout System - Existing designs were analyzed to identify recurring dimensions and spacing. - Most values were already close to multiples of 8, so 8 became the system’s base unit. - Common sizes included: - Buttons and form controls: 32, 48, 56, 64, and 96px - Text: 16, 24, 32, and 48px - Padding and gutters: 16, 24, and 32px - Larger cards: 240px high - Using a shared numeric scale helped harmonize typography, controls, margins, and padding. ## Combining Constraints with Scaling Rules - Figma constraints allowed elements to stretch, remain pinned to edges, or align with grid columns. - Constraints alone were not sufficient to make one layout work equally well on small phones, larger phones, and tablets. - The team compared screen dimensions, calculated proportional relationships, and rounded the ratios into practical whole-number scaling rules. - These rules were implemented in React alongside normal layout constraints. - Designers used Figma’s Scale tool and frame resizing to preview how a single template would appear on different devices. - Testing showed that tablet and small-phone layouts worked well without extensive device-specific adjustments. ## Designing Content for Different Aspect Ratios - To avoid maintaining separate video and animation files for each screen size, content was produced in a 4:3 format. - Important content was placed inside safe areas so it could be cropped cleanly for 16:9 displays. - This allowed the same media assets to support multiple screen dimensions. ## Handling Text and Internationalization - The 8-pixel system was treated as a guideline rather than an absolute rule. - Smaller text sizes sometimes used 4-pixel increments, such as 12px and 20px, because minor size changes had a significant visual impact. - The app was translated into six languages, including German, where longer words could exceed available space. - Code automatically reduced text to the next smaller heading size when it did not fit. - Additional heading sizes were introduced to support these adjustments while preserving smooth transitions between heading levels. ## Practical Scope of the System - The app mostly used straightforward layouts with centered elements and two- or three-column structures. - The team did not need complex responsive patterns beyond proportional scaling and basic constraints. - The combination of a consistent spacing scale, reusable templates, Figma constraints, and shared React rules provided an efficient foundation for responsive design.

React Figma Design Systems Responsive Design+2

figmaNov 5, 20182 min readCurated summary

Figma year in review: 2018 | Figma Blog

Figma’s 2018 review describes a shift from building a collaborative design tool to building an open platform and global community around it. After launching publicly in 2016 and raising $25 million in Series B funding, Figma expanded its API, attracted businesses and developers, and grew adoption among large organizations. The company concludes that partnerships, integrations, and community initiatives will remain central to its growth. ## From Product to Community - Figma marked roughly two years since its public launch in September 2016. - In 2018, its focus expanded beyond the core product to include: - The Figma Platform - API-powered integrations - Community events and resources - Adoption across departments in major organizations - Microsoft used Figma’s API to automate parts of its developer handoff process. ## The Figma Platform - Figma launched what it called the first web API for a design tool. - Its web-based architecture enabled integrations that would have been difficult with isolated desktop software. - Companies such as Uber and GitHub used the API to customize their design workflows even before the public launch. - Seven months later, businesses were being built on the platform, including paid services. ### Community-built tools - PDF exporting - Style-guide generation - Find-and-replace tools for text and layer names - JavaScript libraries for working with the Figma API ### Commercial integrations - Avocode and Zeplin connected Figma designs to developer handoff workflows. - Principle added advanced animation capabilities. - Relay for Figma pushed designs directly into codebases. - Pagedraw converted Figma designs into React. - Overflow synchronized designs for user-flow diagrams. - Haiku converted designs into production-ready components. Figma expected partnerships and additional integrations to become an even larger focus in 2019. ## Building a Global Community - Figma hosted design-system meetups in cities around the world, initially covering eight cities and later reaching 17 countries. - Events connected designers and encouraged detailed discussions about systematic design. - Figma launched DesignSystems.com to share practices and stories from teams at companies including Airbnb, GitHub, Braintree, and Segment. - The company viewed community connections and shared knowledge as an extension of its open-platform strategy. Figma’s 2018 direction was clear: continue investing in an accessible web-based tool while enabling an ecosystem of integrations, businesses, and designers around it.

React Figma Design Systems JavaScript+3

figmaOct 1, 20182 min readCurated summary

Introducing: Figma’s first API Challenge | Figma Blog

Figma announced a $15,000 API challenge to encourage developers to build an open-source Figma-to-Sketch converter. The contest reflected Figma’s goal of supporting an open design ecosystem, even when that meant exporting files to a competitor. However, after community concerns, Figma paused the challenge and ultimately cancelled it in November 2018. ## Open Design Platform and API Challenge - Figma wanted to make it easier for designers to move projects between tools. - The challenge focused on building a Figma-to-Sketch exporter using Figma’s read API. - Figma positioned this as a natural extension of its existing Sketch import support. - The company was also responding to community-built API projects, such as style-guide generators and Alexa integrations. - Future challenges were intended to reward developers who open-sourced useful Figma integrations. ## Evaluation Criteria - Submissions had to export two test files: - A basic file containing common Figma objects. - A more complex file involving typography, components, styles, and prototypes. - The basic file was expected to have clearer correctness criteria. - The advanced file required subjective judgment because Figma and Sketch do not always have equivalent one-to-one features. - Judges would consider: - Accuracy of the exported designs. - Ease of use. - Creativity in translating incompatible features. - Code quality and GitHub documentation. - Code quality and documentation accounted for 5% of the score. ## Rules, Prizes, and Submissions - First place would receive $10,000; second place would receive $5,000. - Teams could include up to three people. - Entrants generally had to be over 21 and located in an eligible country. - Projects were submitted through a Google Form. - Each project needed a GitHub repository containing a README and MIT License. - The planned contest period was October 2 through November 16, 2018. ## Judges and Community Focus - The judging panel combined design expertise with experience building tools and community resources. - Members included Emily Plummer, Raph D’Amico, Cat Noone, and Roy van Rooijen. - Their backgrounds covered design systems, interaction design, accessibility tools, plugins, and design-tool development. ## Cancellation - Figma initially announced that the challenge would be paused and potentially relaunched after community feedback. - On November 19, 2018, the company said it would not proceed with any version of the challenge at that time. The challenge demonstrated Figma’s ambition to promote interoperability and an open platform, but its eventual cancellation showed the importance of addressing community concerns before incentivizing integrations involving a direct competitor.

React Design Systems Open Source JavaScript+4

figmaAug 15, 20183 min readCurated summary

Learn how a Microsoft designer built an Icon Library in his spare time | Figma Blog

Jackie Chui, a Microsoft designer, built a browser-based library containing more than 4,000 company icons in just three weeks. The tool unified icons across design applications, made them searchable through designer tags and engineering class names, and supported reverse searches using pasted icons. Its success came from focusing on practical user needs, leveraging familiar web technologies, and distributing a simple first version quickly. ## Researching Users and Existing Tools - Jackie interviewed Microsoft designers and observed their workflows to identify problems with existing icon management. - He evaluated IconJar, which offered organization and copy/paste functionality but lacked: - Shared, crowdsourced tagging - Browser and cloud access - Windows compatibility - These limitations led him to build a custom internal solution after hours. ## Designing and Building the Library - Jackie first created the interface in Sketch, borrowing ideas from IconJar and applying Microsoft’s Fabric design language. - With existing HTML, CSS, and JavaScript experience, he used Meteor.js to build both the frontend and backend. - A Meteor React tutorial helped him adapt a simple to-do-list database into an icon database. - Working on a concrete problem allowed him to learn development concepts while building the product. ## Extracting and Organizing Icons - Microsoft’s icons were stored in a font file, requiring users to copy and paste special Unicode icon characters into their designs. - Jackie extracted the icon files and retrieved each icon’s Unicode character. - He found Microsoft documentation containing the corresponding engineering class names. - The names were collected in Excel, converted to JSON, and imported into the application. - The resulting library let designers search for icons and copy their characters from one central location. ## Distribution and Adoption - Jackie hosted the application on Microsoft Azure. - He initially emailed the link to his team, after which word-of-mouth spread it throughout the design studio. - Users helped identify bugs and suggest features for version two. - The library quickly became part of many designers’ regular workflows. ## Future Plans - Jackie planned to convert all 4,000-plus icons into Figma components with a single click. - This would let Microsoft teams organize and search icons directly in Figma rather than through a separate browser tool. - He also hoped to release the converter more broadly so anyone could turn an icon font file into Figma components. The project demonstrates that an effective internal tool can start with focused user research, modest technical foundations, and a rapid first release. A browser-based, searchable library is a practical way to eliminate design-tool silos and create a shared source of truth for icons.

React Figma JavaScript CSS+4

figmaApr 25, 20182 min readCurated summary

Introducing: Figma to React | Figma Blog

Figma introduced an open-source Figma-to-React converter that uses the Figma API to turn designs into React components. The project aims to keep visual design in Figma while preserving application functionality in separate code, allowing designers to update interfaces without overwriting custom logic. It also seeks to make functional code reusable across multiple designs, much like reusable React components. ## Motivation and Goals - The converter builds on growing interest in automatically transforming Figma documents into React code. - Figma identified two main objectives: - Keep component design primarily in Figma so design updates can be synchronized to a website or app. - Separate generated visual code from custom functional code, preventing design updates from overwriting application behavior. - Existing functional code should be attachable to new designs, enabling reuse across different UI layouts. - Figma open-sourced the implementation in its `figma-api-demo` GitHub repository. ## From Figma to CSS - The first technical challenge is accurately reproducing the appearance of Figma designs in React components. - The example used is a sortable list interface with multiple list items, icons, and a dark visual style. - The converter must translate Figma’s visual properties into CSS and React structure. - The article notes that there are multiple possible strategies for reproducing a design, setting up a discussion of the implementation choices that follow.

React JavaScript CSS Design To Code+2

figmaApr 18, 20182 min readCurated summary

Want Figma API inspiration? Here’s 8 community-powered projects | Figma Blog

Figma’s 2018 Web API launch quickly inspired developers and designers to build integrations beyond the core product. The projects showcased range from no-code utilities, such as PDF export and style-guide generation, to developer tools for GraphQL, React rendering, and design-to-code workflows. Together, they demonstrate the API’s potential to connect Figma with everyday design and engineering processes. ## Integrations for Designers - **PDF exporter:** Gweltaz Calori created a website that exports selected Figma frames as PDFs from a pasted file URL. The project is open source on GitHub. - **Style-guide generator:** Freighter’s tool analyzes a Figma document and generates a style-guide page containing its fonts, colors, and other styles. - **Alexa integration:** Jon Gold built a voice interface capable of reading Figma comments through Alexa, illustrating unconventional uses of the API. ## Tools for Developers - **Figma.js:** Jon Gold also released an unofficial JavaScript wrapper to simplify building Figma API integrations. - **GraphQL connector:** Bernardo Raposo, with Sara Vieira, used the JavaScript library to create an open-source connector that lets developers query Figma through GraphQL. - **Figma-to-React workflows:** PageDraw introduced a React integration, while Sara Vieira demonstrated rendering React components directly from Figma through the GraphQL connector. - **Additional converter:** Florian Nagel built another Figma-to-React converter, with plans to open-source it. ## Broader Implications - The API makes design-to-development handoff easier to automate. - Community projects show potential for exporting Figma designs into other formats and frameworks. - Open-source libraries and integrations allow others to build on early experiments rather than starting from scratch. - These are third-party projects, so users must consider their permissions, reliability, and ongoing maintenance. Figma’s early API ecosystem suggests strong potential for automated design workflows, especially integrations that translate Figma files into documentation, code, and developer-ready assets.

React JavaScript Design To Code GraphQL+2

figmaDec 14, 20173 min readCurated summary

18 designers predict UI/UX trends for 2018 | Figma Blog

The article gathers predictions from 18 designers about UI/UX in 2018, emphasizing that the field should improve users’ experiences rather than prioritize novelty or designer ego. Common themes include accessibility, ethical responsibility, collaboration, and closer integration between design and development. It also warns that efficiency and standardized systems can become harmful when adopted without critical thought. ## Accessibility and Inclusive Design - Designers argue that accessibility should become a central responsibility rather than an afterthought. - Common problems include: - Using ultra-light gray text for essential content - Adding unnecessary animation - Making interfaces harder to understand for visual flair - Inclusive design is described as an important trend that the industry needs, even if it is unlikely to attract attention or headlines. - The article suggests that many teams avoid accessibility work because it requires sustained effort rather than producing immediately visible results. ## Design Collaboration Inspired by Engineering - Design teams may begin working more like engineering teams. - Possible developments include: - Formal design reviews similar to code reviews - Design tools that identify inconsistencies like code linters - Open-source design patterns and shared UX standards - This approach could make collaboration more systematic and help establish common practices for user experience and information design. ## Ethics and Designer Responsibility - Designers are encouraged to recognize the influence their work has on people’s behavior and decisions. - UX choices should be evaluated for their ethical consequences, not only their usability or business value. - The broader prediction is that designers will become more accountable for how products affect users and society. ## Risks of Overreliance on Design Systems - Standardized systems such as Material Design and Microsoft’s Fluent Design may become increasingly dominant. - One concern is that designers will adopt these systems automatically without questioning whether they fit a product’s users or context. - Design systems can improve consistency, but they should not replace independent judgment or thoughtful problem-solving. ## Convergence of Design and Development Tools - Design and development tools are expected to become more integrated and centralized. - Technologies such as CSS Grid, custom variables, Vue, and React could make implementation more efficient and flexible. - Greater efficiency should create more time for designers to focus on responsible design and more inclusive experiences. - The article frames technical progress as valuable only when it supports better outcomes for users. Overall, the predictions recommend treating accessibility, ethics, and inclusion as core design requirements—not optional trends—while using collaboration frameworks, design systems, and new development technologies thoughtfully.

React Design Systems User Experience Accessibility+4

figmaApr 26, 20172 min readCurated summary

5 books that shaped the design approach of Airbnb’s Jon Gold | Figma Blog

Jem Gold’s design approach combines systems thinking, human-centered technology, disciplined focus, mindfulness, and functional programming. The five books she recommends show how design can be treated as a generative process—one that connects creative practice with engineering and tools that augment human ability. ## Designing Programmes: Design as a System - Karl Gerstner’s *Designing Programmes* presents design as a process that generates assets rather than relying on humans to create every final output manually. - Though focused on layouts, logos, and typography, its ideas remain relevant to modern UI and design systems. - Gold values the concept of a flexible pipeline that people can shape, with the system producing consistent results. ## 10% Happier: Creating Space for Better Decisions - Dan Harris’s memoir about meditation influenced Gold’s design process and outlook. - Meditation helps her avoid immediate, visceral reactions and take time to investigate the best response. - She especially appreciates Harris’s skepticism toward mystical or “woo-woo” claims, making the book a practical introduction to meditation. ## The Dream Machine: Computers as Creative Partners - *The Dream Machine* explores J. C. R. Licklider’s vision of “man-computer symbiosis,” in which computers enhance human intelligence. - It describes researchers who rejected IBM’s slow, punch-card-based model of computing in favor of interactive systems people could enjoy using. - Gold identifies with their rebellious belief that technology should augment human creativity rather than merely automate routine tasks. ## Deep Work: Protecting Creative Focus - Cal Newport’s *Deep Work* argues that social media fragments attention and prevents sustained, original thinking. - Gold responded by eliminating social media for a month and scheduling dedicated blocks for creative projects. - When she felt the urge to check distractions, she replaced the habit with activities such as running or reading. - The practice helped her preserve focus and create space for ideas to develop. ## Functional Programming: Building from Small Primitives - *Professor Frisby’s Mostly Adequate Guide to Functional Programming* introduces functional programming through a short, approachable, free online book. - The paradigm breaks problems into small, composable units that can be rearranged and combined. - Gold applies this principle to design systems: instead of starting with a large page and breaking it down, designers can begin with basic primitives and build upward. - This approach connects programming concepts directly to scalable, reusable design work. Together, these books recommend a design practice built from composable systems, deliberate attention, skepticism, and technology that expands human creativity.

React AI Design Systems Typography+2

figmaFeb 14, 20173 min readCurated summary

Team Libraries in Figma | Figma Blog

Team Libraries bring shared, synchronized components to Figma, addressing the difficulty of maintaining design systems across separate files. The feature builds on Figma’s components, constraints, and web-based collaboration to create a single source of truth that teams can reuse and update efficiently. Its workflow—Publish, Insert, and Update—combines engineering-style structure with an accessible design workflow. ## The Problems with Traditional Design Tools - Many design tools were modeled on print and illustration software rather than interactive applications. - They lack meaningful support for application behavior, platform constraints, and reusable interface structures. - Copying symbols between files creates disconnected versions that must be updated manually. - Large organizations such as Facebook, Google, and Airbnb have had to build custom tools and dedicate staff to maintaining design systems. - Designers need synchronized, compounding component structures to create scalable systems. ## Bridging Design and Dynamic Interfaces - Figma’s earlier features established the foundation for reusable design systems: - Reliable vector editing - Constraints that reflect system behavior - Dynamic, reusable components - Team Libraries extend these capabilities across files and team members. - Because Figma operates online, shared components have effectively no synchronization delay. - Teams can reuse structured components across devices, platforms, layouts, and user flows. ## An Engineering-Inspired Design Workflow - Figma draws on software concepts such as modular composition and frameworks like React. - Structuring interfaces from discrete, clearly defined parts makes products easier to maintain. - The feature adapts engineering principles for designers rather than copying programming workflows directly. ## Publishing Components - Designers select components and choose **Add to Library** in the inspector sidebar. - Multiple components can be collected and reviewed before being published. - Permissions separate the source of truth from its consumers: - Editors of the source file can modify the original components. - Anyone with view access can use the published components. - This lets specialized teams control assets such as icons, colors, or brand guidelines while others reuse them without changing the rules. ## Inserting and Nesting Components - Published components are available in any file for users who can view the source file. - Users insert them through Figma’s components tool. - Components can be nested inside larger components or modules. - Nested structures allow teams to build complex views from reusable source elements while preserving a predictable single source of truth. ## Updating Shared Components - Changes are made to the original component and published again. - Figma provides a confirmation step and a visual diff showing what changed. - Deleting a component from the source file and publishing removes it from the team library. - The update process includes an additional safeguard because changes may affect multiple design explorations and could otherwise cause users to lose work.

React Figma Design Systems User Interface+3