React

63 posts

figmaJun 16, 20252 min readCurated summary

Make your site interactive with code layers | Figma Blog

Figma’s new code layers let designers add custom React-powered interactions directly within Figma Sites. They bridge the gap between static canvas designs and production-like experiences by combining AI-assisted coding, direct code editing, and reusable components. The feature is intended to make advanced interactions—such as drag-and-drop systems, animations, calculators, maps, shaders, and 3D effects—accessible without external developer support. ## Customizing Existing Designs - Code layers extend Figma Sites’ built-in responsive elements and interactions. - Designers can convert an existing element into a code layer through the Figma Make icon in the Design panel. - AI chat can then generate or modify behaviors such as: - Spinning or bouncing animations - Animated counters and text effects - Loan calculators and price estimators - Hover effects, ripples, and color changes - Code layers can be duplicated with **Command D** to create and compare multiple interaction variations. - Example use case: a flower shop could let visitors duplicate, drag, rotate, and layer flower images to create custom bouquets. ## Creating Code Layers from Scratch - Designers can use the Make tool or press **E** to draw a standalone code layer on a blank canvas. - A modal opens for generating the layer through AI prompts or writing code directly. - Suggested prompts and starter components—such as buttons, image galleries, and navigation menus—provide ready-made starting points. - These components can be used as-is or customized to match an existing design. ## Reusable and Extensible Components - Code layers support customizable properties, including strings, numbers, and references to other components. - AI can generate these properties automatically, or users can request specific controls. - A code layer can be converted into a reusable Figma component for use across pages, projects, and team design systems. - Designers can import npm packages such as `motion` and `@react-three/fiber` to add advanced animation, 3D rendering, and other functionality. ## Code Layers Compared with Figma Make - **Figma Make** is suited to building a functional app from a prompt without relying heavily on precise canvas design. - **Code layers in Figma Sites** are designed for adding custom interaction and motion to an existing visual design. - Together, the tools support both prompt-first development and design-first experimentation. Code layers are available to all Figma Sites users, offering a practical way to prototype and publish richer web experiences directly from the Figma canvas.

React AI Prototyping Web Development+4

discordJun 12, 20253 min readCurated summary

Discord Patch Notes: June 3, 2025

Discord’s June 3, 2025 patch focuses on performance, reliability, media playback, and cross-platform consistency. Major improvements include ARM infrastructure migration, faster video startup, better mobile image compression, persistent voice-message playback, and early adoption of shared Rust components. The release also includes framework upgrades and a broad set of UI, navigation, billing, accessibility, and platform-specific bug fixes. ## Infrastructure and Performance - Discord is migrating parts of its infrastructure to ARM hardware. - The change has reduced per-core load and improved latency. - ARM machines also lower energy consumption. - Keyframe-generation changes reduced video and stream startup latency by more than 10% on average. - Discord migrated one core store to a shared, multi-platform Rust implementation. - Early results showed improvements in memory and CPU usage, crashes, and other reliability metrics. - More stores and APIs are planned for migration. - Desktop clients were upgraded to Electron 35. - Mobile clients moved to React Native 0.78, while all clients upgraded to React 19, with incremental performance improvements and no significant regressions. ## Voice, Images, and App Links - Voice messages on desktop and web now support playback-speed controls. - Playback position is preserved when users close the app or navigate away. - Mobile image compression now adapts to source resolution. - Lower-resolution images receive higher-quality embeds. - Median upload latency has decreased across platforms. - Discord revamped app-link handling to resolve Android linking failures and improve compatibility with modern apps. ## General Bug Fixes - Fixed an iOS Billing Settings issue involving an empty entry field and moved Manage Nitro to the top of the page. - Fixed Android poll results that could not be swiped horizontally. - Soundboard uploads now work correctly in Firefox. - Corrected mobile profile scrolling that exposed blank space. - Fixed multi-line status rendering, Custom Status emoji alignment, and unreadable light-mode text. - Starting a Desktop settings search with “M” no longer freezes the application. - Mac popouts now correctly render Unicode emojis in full-screen mode. - Fixed duplicate server entries caused by lurking through Discovery. - Corrected server settings save prompts, profile badge previews, folder rendering in Safari, and profile banner updates on iOS. - Fixed Soundboard picker placement, event-link copying, Shop navigation, 2FA login-state messaging, and Expression Picker spellcheck replacement. - Removed a redundant Linux title bar and corrected channel-list alignment for servers with many channels. - Profile edits now prompt consistently for saving across platforms. - Fixed stale forwarding-search results, invite-modal corner rendering, light-mode member text, overlay popups, privacy-page dividers, folder mention badges, and stream-invite display names. - Improved Discovery scaling for different window sizes. - Fixed “Go to Shop” links from avatar decoration and profile-effect previews. - Corrected rendering issues involving passkey backup codes and several additional interface elements. The changes had been merged but might still be rolling out by platform. Users encountering remaining issues can report them through Discord’s community bug megathread or test upcoming iOS builds through TestFlight.

React Android iOS Rust+3

figmaApr 15, 20253 min readCurated summary

Version Control: Three Ways Figma Explored Horizontal Scrolling | Figma Blog

Figma’s request for horizontal scrolling in the Layers panel exposed significant design and engineering complexity. The panel contains interactive, virtualized layers whose names and nesting change dynamically, so scrolling could easily obscure hierarchy or disrupt users’ mental models. Through three unshipped prototypes, the team learned that preserving context and preventing accidental actions mattered more than applying seemingly simple scrolling behaviors. ## Why Horizontal Scrolling Was Difficult - Nested layers can extend beyond the panel, requiring users to move horizontally to see their full hierarchy. - Layers are interactive: users can hide, lock, collapse, and expand them while scrolling. - Virtualization renders only visible layers for performance, meaning newly visible rows may have different text lengths. - The design needed to communicate that more content existed without making the hierarchy harder to understand. - Code-based prototyping with JavaScript, HTML, CSS, and React helped the team test behavior across thousands of layers and complex interactions. ## Version One: Indicators at the Panel Edges - The team explored showing icons at the top-left and bottom-right edges when layers moved out of view. - This symmetrical treatment was intended to help users understand their position in the hierarchy. - Engineering challenges arose because edge icons needed opaque backgrounds that covered layer text while scrolling. - Layer rows did not have enough positional knowledge to determine which areas should be covered or revealed. - The design also created a ragged edge where partially visible layer names ended, introducing visual clutter. - The experiment demonstrated that a symmetrical solution could create new problems, particularly around unused white space. ## Version Two: Automatically Scrolling to Selected Layers - Another prototype automatically scrolled the Layers panel to center a layer selected on the canvas. - Although this made the selected layer easy to find, it often moved the panel both vertically and horizontally. - Testers found the behavior disorienting because parent layers and surrounding context disappeared. - Figma compared the experience to a map suddenly jumping to another location while driving. - The team concluded that users need to retain their mental model of a layer’s name, location, and relationship to parent components. ## Version Three: Renaming Layers While Scrolling - Horizontal scrolling created ambiguity when a user began editing a layer name and then scrolled to another layer. - One possible behavior was to save the edited text automatically when scrolling away. - The team rejected this because scrolling was not a strong enough signal that the user intended to confirm the rename. - The issue highlighted the need to avoid turning navigation actions into irreversible edits. Figma’s experiments show that horizontal scrolling in a dynamic hierarchy is not merely a visual or mechanical feature. The best solution must preserve orientation, context, and user control while handling virtualization and interactive layer states.

React Figma User Interface JavaScript+4

figmaJun 25, 20243 min readCurated summary

Why Are We So Afraid Of Code As A Commodity? | Figma Blog

AI may commoditize code production, including language translation and design-to-code workflows, but that does not eliminate the need for engineers. The article argues that engineering’s lasting value lies in identifying the right problems, understanding users and constraints, and designing elegant, maintainable systems. AI should therefore be viewed less as a threat and more as a tool that expands creativity and shifts engineers toward higher-level decision-making. ## Code Generation Is Not the Same as Engineering - AI can increasingly: - Translate between programming languages, such as Python and C++. - Generate code more efficiently. - Convert designs into implementations using frameworks such as React, TypeScript, Kotlin, and Jetpack. - Design-to-code is comparable to translating between programming languages because modern design tools already represent designs in structured, code-like forms. - Producing code is only one part of engineering. Engineers must also: - Decide which problems are worth solving. - Choose appropriate solutions. - Create abstractions for reasoning about complex systems. - Balance correctness, simplicity, context, and constraints. - Framework-specific expertise becomes less valuable over time than first-principles reasoning about the common ideas underlying different platforms. ## The Art and Creativity of Engineering - AI is expected to automate rote work, potentially freeing engineers to focus on more creative activities. - There are often many viable ways to build a system; AI may expose additional approaches that engineers would not have considered. - Engineers remain responsible for evaluating tradeoffs among those options. - Technical implementation is presented as a creative discipline in which constraints can inspire better solutions and product decisions. ## Embracing Shifts in Engineering Roles - Engineering work begins before coding: - Teams discuss user needs. - They triage problems. - They align on what to build and how to approach it. - As AI handles more low-level implementation, coding will represent a smaller portion of an engineer’s responsibilities. - Engineers will spend more time prioritizing, aligning teams, interpreting context, and making product and system-level decisions. - The abstraction level of software development is rising as AI takes responsibility for increasingly lower-level parts of the technology stack. ## What AI Will Not Commoditize - AI still struggles to fully understand: - What users actually need. - The context surrounding a problem. - Conflicting constraints and product priorities. - How to compose intuitive, maintainable systems. - Engineers will continue to add value by reasoning from first principles and solving technical challenges from the ground up. - The central question is not whether AI automates design-to-code, but how engineers use that automation to work faster and explore better solutions. The practical recommendation is to embrace AI for repetitive implementation work while developing the higher-level skills that remain difficult to automate: problem selection, user understanding, system design, tradeoff analysis, and creative technical reasoning.

React Generative AI TypeScript Design To Code+2

figmaApr 15, 20242 min readCurated summary

What We Launched at Framework 2024 | Figma Blog

Figma’s Framework 2024 launches focus on increasing design-system adoption across organizations. The central argument is that creating a system is only half the challenge; teams must also make it useful and accessible to developers and other stakeholders. Code Connect, typography and gradient variables, and the Design System Analytics API are presented as tools for bridging design and code, improving consistency, and measuring adoption. ## Design System Adoption as the Central Challenge - Design systems have become more powerful and sophisticated, but that complexity can make organizational adoption harder. - Figma emphasizes that successful systems require more than components and documentation—they need an adoption strategy. - The new releases build on earlier updates such as variables, theming, state management, advanced prototyping, and Dev Mode. - Figma frames design-system advocacy partly as a marketing problem: teams must persuade designers and developers to use the system consistently. ## Code Connect Bridges Design and Code - Code Connect brings production-ready code snippets directly into Figma’s Dev Mode. - Developers can find the implementation for a design-system component without searching through separate documentation. - Copying the relevant snippet is intended to reduce inconsistencies and make the design-to-code process faster. - The beta supports React, iOS, and Storybook, with additional frameworks and platforms planned. - Bumble, GitHub, and HP shared their design-system challenges and early experiences with Code Connect. ## Typography and Gradient Variables Expand Token Coverage - Figma describes typography as an essential part of a complete design system that was previously difficult to represent with variables. - Typography variables allow teams to define font scales once and apply them consistently throughout a product. - They can support platform-specific adjustments and accessibility goals, including WCAG-compliant type scales. - Gradient variables, introduced alongside typography variables, further align Figma variables with the range of design tokens teams need. ## Analytics for Measuring Adoption - Figma also announced the Design System Analytics API, referred to in the introduction as the Library Analytics API. - The API is intended to help design-system teams understand usage across an organization. - By measuring adoption, teams can identify where systems are being used effectively and where additional education, improvements, or outreach may be needed. Figma’s overall recommendation is to treat a design system as an organizational product: provide developers with usable code, cover essential tokens such as typography and gradients, and use analytics to guide adoption efforts.

React Figma Design Systems Design Tokens+3

figmaApr 10, 20242 min readCurated summary

Codegen Plugins (And Other Tips) for Automating Design to Code | Figma Blog

Codegen in Figma’s Dev Mode is intended as a starting point for design implementation, not a complete replacement for developer judgment. Figma provides built-in snippets, while custom plugins extend code generation for different frameworks, languages, and team conventions. The post highlights several tools that can accelerate design-to-code workflows across web and mobile projects. ## Codegen as a Design-to-Development Starting Point - Codegen automatically generates code from defined design rules or specifications. - Figma argues that generated code should augment—not automate away—the design and development process. - Dev Mode creates code snippets for selected canvas objects in the inspect panel. - Users can choose different programming languages and measurement units. - Teams with mature design systems can build custom codegen plugins to match their conventions. ## Anima: Customizable React and HTML Generation - Exports Figma components into React or HTML with CSS, SCSS, or Tailwind. - Produces interactive, responsive, and maintainable snippets. - Detects repeated components to reduce duplication. - Learns team conventions from added code snippets. - Supports prompts for animations and style-specific adjustments directly in Dev Mode. ## Builder: AI and Code Components - Generates React, Svelte, and HTML using AI. - Can incorporate a team’s existing code components to better align design and implementation. - Allows users to refine output conversationally and train it to match their coding style. - Automatically adapts designs for responsiveness. - Provides a separate web interface for experimenting with generated code outside Figma. ## Figma to Code: Open-Source Multi-Platform Output - Converts designs into responsive web or mobile code. - Supports HTML, Tailwind, Flutter, and SwiftUI. - Lets users preview Tailwind output and copy it into their code editor. - Is available as a free, open-source Figma Community plugin. ## Locofy.ai: Interactive Web and Mobile Code - Generates code for components and full screens in React, HTML/CSS, Next.js, Gatsby, and Vue. - Supports design optimizations such as auto layout and frame grouping. - Adds interactivity through semantic HTML tags, libraries, and actions. - Produces responsive layouts, reusable components, props, and human-readable class names. - Enables teams to share prototypes, bind data, and export code or Storybook files. - Supports direct GitHub synchronization with automatic merging and conflict resolution. The practical recommendation is to use codegen to reach a useful first draft faster, then have designers and developers refine the output against the project’s design system, architecture, and coding standards.

React Figma Design To Code HTML+3

figmaJan 30, 20243 min readCurated summary

Everything You Need to Know About Dev Mode | Figma Blog

Figma built Dev Mode to make the transition from design to code more efficient for developers, who now represent roughly one-third of its weekly active users. Rather than separating developers into different tools or files, Figma created a dedicated space within the same collaborative environment. After an open beta shaped by extensive user feedback and more than 200 updates in its first two months, Dev Mode moved out of beta with a focus on clearer handoff and developer-centered workflows. ## Why Figma Built Dev Mode - Developers were already using Figma alongside designers, product managers, and other collaborators, despite Figma not being optimized for their workflows. - Figma wanted to support varied development roles, including: - Front-end developers working with design systems - Design systems engineers building components - Developers implementing content layouts and exporting assets - In 2021, Figma acquired Visly, a team of eight designers and engineers experienced in React UI development and developer tooling. - The Visly team emphasized that developers should not have to learn every interaction in design mode; the experience should be tailored to their needs. ## An Integrated Development Workspace - Figma considered both fully separate files and tightly integrated design and development experiences. - It ultimately chose a dedicated mode inside Figma: - Developers get tools and workflows optimized for implementation. - They retain access to the design context and collaboration surrounding the work. - The approach avoids forcing teams to switch tools or lose important information during handoff. - Dev Mode launched as an open beta at Config 2023, with customer feedback driving rapid improvements and over 200 requested updates delivered in the first two months. ## Communicating Design Intent - Traditionally, designers had to manually create measurements, callouts, and organized specifications for developers. - Dev Mode introduces annotations that remain connected to the design and update as the design changes. - Designers can: - Click and drag to measure - Highlight important details without cluttering the canvas - Add live specifications and contextual notes - Automate or customize annotations through plugins - Designers can mark a section as “ready for development” without creating a separate file or page. - Developers can use diffing tools to compare changes between versions and stay current with design updates. ## Practical Impact Dev Mode is intended to make design handoff less manual and more collaborative by giving developers a purpose-built workspace without removing them from Figma’s shared context. Teams can use annotations, readiness labels, and frame comparisons to reduce ambiguity and keep implementation aligned with evolving designs.

React Figma Design Systems Design To Code+3

figmaNov 21, 20233 min readCurated summary

Dev Mode: Building a Design Tool that Works Harder for Developers | Figma Blog

Figma built Dev Mode to make developers first-class participants in product design rather than secondary users of a designer-focused tool. The team initially emphasized code generation, but real-world differences in teams, workflows, and codebases exposed its limitations. By combining developer research, the acquisition of Visly, and a broader focus on inspection and collaboration, Figma shifted toward reducing the gap between design and code. ## Designing for Developers as Core Users - Figma’s multiplayer canvas was created for entire product teams, including product managers and developers. - Developers were already using Figma to explore work in progress, despite the tool not being optimized for their workflows. - By 2023, developers represented roughly one-third of Figma’s users. - The goal became a tailored developer experience that did not require developers to learn or navigate design-centric interactions. - Proposed directions included: - Component playgrounds - Code snippets - GitHub and Storybook integrations - Developer-specific resources - Design inspection and change comparison ## The Visly Acquisition - Figma acquired Visly in 2021, bringing in eight designers and engineers who had built a React UI development tool. - The Visly team contributed: - Extensive research into developer tooling - Practical experience with development workflows - A developer-oriented perspective and intuition - Their involvement accelerated Figma’s efforts and helped the company understand how developers work across different environments. ## Moving Beyond a Codegen-First Strategy - Early versions of Dev Mode focused on code generation: automatically translating designs into code according to predefined rules. - Codegen could save hours or even days when designs mapped cleanly to implementation. - Testing showed that successful code generation in controlled scenarios did not necessarily work in production. - Companies differ in their: - Team structures - Engineering practices - Toolchains - Codebases - Workflow conventions - These variations made it difficult to generate universally useful code, prompting the team to reconsider codegen as the central solution. ## Redefining Design-to-Code Handoff - Figma’s broader objective was to break down the traditional “handoff wall” between designers and developers. - Dev Mode was positioned as a dedicated space where developers could inspect designs, compare changes, work with VS Code, and access implementation-oriented information. - The team continued refining the product through beta feedback, including daily customer requests collected through an internal Slackbot. - Rather than assuming developers would live inside a design tool, Figma focused on making the parts of the design process they needed more accessible and useful. Dev Mode’s central lesson is that developer tooling must reflect real engineering practices, not just generate code from idealized designs. A practical developer experience combines accurate design context, collaboration, integrations, and workflow flexibility with code generation where it genuinely helps.

React Figma Github Dev Mode+3

figmaAug 21, 20233 min readCurated summary

Dev Mode fast follows: 200+ new features and fixes | Figma Blog

After two months of open beta, Figma released more than 200 Dev Mode features, improvements, and bug fixes based on over 5,000 pieces of community feedback. The updates improve design inspection, component workflows, code generation, file navigation, and integration with developer tools. Together, they make Dev Mode more practical for translating designs into implementation-ready code. ## New Dev Mode capabilities - Status labels can now be added to components, instances, and frames—not just sections—to indicate development readiness. - Layout grids, rulers, and outline mode are available through the View menu and familiar Design Mode shortcuts. - Detached components can be compared with their main components to identify differences. - Android XML and iOS UIKit have been restored as code-generation options. - The Inspect panel now supports the `UIColor` format. - Version history allows users to inspect previous design iterations. ## Usability and performance improvements - Components from external libraries display the library name. - Nested component properties and component modes, such as light and dark themes, are available in the component playground. - `rem` units can be applied specifically to text while other properties remain in pixels. - Multiple canvas objects can be selected and exported together using Shift-click. - Figma files and notifications can surface in VS Code through Figma’s VS Code integration. - Typography previews expose style name, font size, and line height, which can be copied directly. - Individual text portions can be inspected on the canvas. - The Layers panel can be resized vertically. - Figma suggests matching design-system variables when raw values resemble existing variables. - Values can be inspected as Figma properties as well as code snippets. - Source files such as images can be downloaded. - Alternative unit preferences are easier to find. - Section-level links are grouped by frame. ## Code-generation updates - Holding Shift copies all available code snippets at once. - CSS generation supports directional properties such as `padding-top` and `padding-left` when only one padding value is defined. - Snippets consistently include `font-style`, `line-height`, and `font-weight`. - Line height is shown in both percentage and pixel formats. - CSS codegen supports OpenType features including `font-feature-settings`, `font-variant-numeric`, and `font-kerning`. - Variables can be used for auto-layout constraints such as minimum and maximum dimensions and vertical gaps in wrapping layouts. - Text layers containing multiple styles generate separate CSS for each style. - The Figma Community now offers nearly 80 code-generation plugins, including tools for Tailwind, React, and Vue. ## Bug fixes and navigation - Users can switch between Design Mode and Dev Mode with tab navigation. - Alternative units now display correctly in hints and tooltips. - The release also includes additional fixes, including smoother handling of gradients in text. Figma’s fast-follow release shows that Dev Mode is being shaped around developer feedback. Teams using it should revisit their workflows and integrations to take advantage of improved inspection, code export, component exploration, and VS Code support.

React Figma CSS Dev Mode+4

figmaJul 18, 20232 min readCurated summary

The Shared Language of Props | Figma | Figma Blog

Design and engineering use the same component vocabulary, but often attach different meanings to terms such as “property,” “variant,” and “button.” Figma properties primarily describe visual variations, while code props may also control behavior, events, data, and rendering. Effective collaboration therefore requires translating concepts across environments rather than assuming identical names imply identical implementations. ## Components and Properties as Shared Concepts - Components are reusable elements governed by rules describing how they can look and behave. - Properties, or “props,” define the possible expressions of a component, including: - Variants - Boolean values - Instance swaps - Text values - In Figma, properties are used mainly to represent visual differences. - In code, props can also represent non-visual concerns such as event handlers and data. - A shared term can conceal different assumptions when designers and developers work in different tools and contexts. ## A Button Is Not the Same Everywhere - Designers and developers both work with buttons, but prioritize different concerns: - Designers focus on visual consistency and maintainability across design files. - Developers focus on interactivity, rendering, accessibility, and implementation. - A Figma button and a code-based button may share a name without sharing the same API or purpose. - Migrating a React and TypeScript application to a design-system-based frontend exposed conflicts between Material UI conventions and the organization’s custom design system. - The component library aimed to be intuitive and lightweight for full-stack engineers who primarily connected frontend and backend systems. ## Divergent Component Models - The design system contained two Figma components: - `Button` - `IconButton` - The codebase contained five button components. - Figma’s `Button` and `IconButton` did not use the same inheritance or primitive-component structure as the codebase. - Some properties, such as size and color variants, were duplicated in Figma because that structure better represented the design model. - Although the components shared names and broad concepts, they did not share the same purpose or complete set of properties. Teams should treat design and code components as related models rather than identical ones. Clear translation of property names, meanings, and responsibilities can preserve each environment’s strengths while reducing misunderstandings during implementation.

React Figma Design Systems TypeScript+3

figmaJul 12, 20232 min readCurated summary

How Thumbtack structures their design system | Figma Blog

Thumbtack structures its Thumbprint design system as three layers: design tokens, atomic CSS, and reusable UI components. Each layer trades some flexibility for greater productivity, consistency, accessibility, and quality. The approach lets developers choose the highest-level solution that fits their needs while retaining lower-level escape hatches for custom or native experiences. ## Three-Layer Architecture - **Thumbprint Tokens** - The foundation shared by web and native clients. - Defines granular properties such as colors, typography, spacing, sizing, radii, and shadows. - Offers the greatest flexibility but the least built-in structure. - **Thumbprint Atomic** - An atomic CSS library built on the tokens. - Enables developers to build interfaces without writing custom CSS. - Includes utilities such as aspect-ratio classes for maintaining proportions in responsive or embedded media. - **Thumbprint Components** - Provides accessible, prebuilt implementations of common patterns, including alerts, buttons, date pickers, and star ratings. - Improves development speed, consistency, and accessibility. - Developers can fall back to Atomic or Tokens when no suitable component exists. ## Layered Components and Tokens - Individual layers can contain their own sub-layers for added flexibility. - Thumbprint’s modal system separates: - `ModalCurtain`, which supplies core usability and behavior without visual styling. - `Modal`, which adds the standard visual design on top of `ModalCurtain`. - Developers generally use the more prescriptive `Modal`, but can use `ModalCurtain` for unusual requirements. - Tokens can also inherit from one another. For example, a semantic token such as `button-cta-background-color` may derive from a broader token like `cta-background-color`, which ultimately maps to a raw value such as `blue-400`. - Users are encouraged to select the highest abstraction appropriate for their use case. ## Why the Structure Helps - Higher layers reduce repeated work and improve consistency. - Lower layers preserve flexibility for custom product needs. - Components allow engineers to focus on product functionality instead of rebuilding common UI patterns. - Layered primitives provide a controlled way to support exceptions without abandoning the design system. - The architecture is intended to simplify maintenance and save time for both developers and end users. Thumbprint’s model demonstrates that a design system does not need to choose between standardization and flexibility. A layered structure provides strong defaults while preserving lower-level tools for cases that require customization.

React Design Systems Accessibility Design Tokens+3

figmaMay 15, 20232 min readCurated summary

Announcing FigJam screen reader support | Figma Blog

FigJam now supports screen readers and keyboard-only navigation, enabling users to read and create much of a file’s content. The release focuses on making canvas-based collaboration more inclusive while acknowledging that some features remain inaccessible. Figma’s approach relied heavily on user testing, careful iteration, and reusable accessibility patterns. ## What the Update Enables - Users can move focus around the FigJam canvas and through menus and screens. - Screen readers can interpret: - File structure and canvas hierarchy - Shapes containing text - Stickies and tables - Image alt text - Users can create, edit, and read content without relying on a mouse. ## Expanding Accessibility to Collaborative Work - FigJam was prioritized because it brings entire teams together for brainstorming, alignment, and decision-making. - Its relatively surface-level interface provided an opportunity to address accessibility before tackling Figma Design’s more complex menu and interaction structure. - The goal is to make collaboration inclusive for as many team members as possible. ## Designing Without Established Canvas Patterns - Unlike conventional websites and widgets, canvas-based tools have relatively few established ARIA patterns or accessibility best practices. - Figma first had to determine which capabilities were essential for effectively using FigJam with assistive technology. - The team worked with Fable and users of assistive technologies to test designs and gather feedback. - User journeys helped define a practical set of core features for the initial release. ## Learning Across Keyboard and Screen Reader Setups - Different screen readers, settings, and keyboard layouts create thousands of possible interaction combinations. - Beta interviews revealed new usage patterns and accessibility issues that informed the product. - Improvements also benefited Figma’s broader codebase, including reusable ARIA labels and tags for React components. - Remaining unsupported features include cursor chat, stamp adjustments, voting, the emote wheel, widgets, and editing freeform vector elements such as lines, highlights, washi tape, and marker drawings. Figma’s release is a meaningful foundation for accessible FigJam collaboration, but users should expect continued gaps as the team expands support to more interactive and multiplayer features.

React Figjam Keyboard Navigation Screen Readers+2

datadogSep 29, 20223 min readCurated summary

DRUIDS, the design system that powers Datadog

Datadog created DRUIDS in 2018 to provide consistent UX patterns across its rapidly expanding observability platform. The system succeeds only if designers and developers trust and use it, so its documentation and tooling are designed to be easy to understand, implement, and contribute to. Datadog’s approach connects design, source code, documentation, and development workflows into a shared source of truth. ## Easy to Understand ### Fast Navigation and Discovery - The DRUIDS documentation supports Cmd+K (or Ctrl+K) quick navigation for finding components, patterns, icons, logos, and other resources. - The “DRUIDS Loupe” lets Datadog employees inspect components directly on product pages. - Hovering over an inspected component reveals links to its source code, Figma files, and documentation. ### Connected Documentation - Component pages link to GitHub, Figma, and VS Code. - JSDoc comments provide descriptions and links back to DRUIDS documentation inside VS Code. - Figma also links back to relevant components and guidance. - These connections minimize dead ends and keep supporting context close to where people are working. ## Easy to Implement ### Editable Playgrounds - DRUIDS treats React, TypeScript, and CSS implementation as the source of truth because code defines the actual browser experience. - Interactive playgrounds let users explore component props, test variations, and copy production-ready code. - A Code Sandbox page allows multiple components to be combined into live prototypes. - Stateful internal URLs make it easier to share ideas and reproduce bugs. - The tools also help teams without dedicated frontend specialists build internal applications using familiar Datadog patterns. ### Auto-Generated API Documentation - Each component includes an API table listing its props, allowed values, and descriptions. - The tables are generated directly from source code rather than maintained separately. - This prevents documentation from drifting away from the implementation across more than 150 components. - Clear, meaningful prop names improve predictability for both designers and developers. ## Easy to Contribute Back ### Contribution Guidelines - DRUIDS is intended to evolve as Datadog’s products and customer needs change. - Internal contribution guidelines define expectations for core design, structure, prop naming, documentation, styling, responsiveness, accessibility, and testing. - The guidelines aim to reinforce quality without making contributions burdensome or intimidating. ### CLI Tooling - A command-line wizard generates the standard structure for new components, including code, tests, and documentation examples. - For example, `yarn component button` creates the scaffolding for a button component. - Automating boilerplate lets contributors focus on design, user experience, and performance. Datadog’s central recommendation is to treat a design system as more than a component library: it should connect users, designers, and developers through consistent patterns, live examples, source-linked documentation, and lightweight contribution workflows.

React Figma User Experience TypeScript+4

datadogJun 6, 20223 min readCurated summary

Engineering Spotlight: Tay Nishimura

Tay Nishimura’s career shows that succeeding in tech is often less about fitting a standard engineering mold and more about finding work that matches one’s strengths. Although she initially struggled with the speed and coding demands of software development, her rigor, visual thinking, and careful approach became valuable in site reliability engineering. Her transition was enabled by self-directed learning, community education, and ToyNet, an open source networking simulator that demonstrated her practical abilities. ## Entering Tech from Mathematics - Tay began as a mathematics major focused on real analysis, then added computer science after advice from a professor. - Internships at Amazon and Google introduced her to the technology industry. - She found a sharp contrast between academia and industry: - School rewarded theoretical rigor. - Industry emphasized practical, fast, and agile solutions. - Tay also felt like an outsider because she had little exposure to computers growing up. ## Struggling with Traditional Software Engineering - Coding did not come naturally to Tay’s visual way of thinking. - She translated code into drawings to understand and modify it, then converted those ideas back into code. - This process produced high-quality, careful work but made her slower than colleagues expected. - A manager suggested product management and site reliability engineering as possible alternatives. - Tay discovered that her deliberate pace was useful for SRE work, particularly when evaluating failure modes and making critical changes. - Because her company offered no path into those roles, she eventually left rather than continue facing increasing stress. ## Discovering Networking and Technical Program Work - Tay’s next role had a software engineer title but involved work closer to product or technical program management. - She learned that job titles and responsibilities vary significantly between companies. - With better work-life balance, she began studying computer networking in her free time. - She created visual diagrams and learning modules to explain switches, routers, and packet flows. - These efforts became Project Reclass, a nonprofit teaching technical skills to incarcerated people and military veterans. - The program used improvised equipment, such as fake routers and switches, to teach concepts in environments where real networking hardware was unavailable. ## Building ToyNet During the Pandemic - After her company laid off its entire office during COVID-19, Tay decided to pursue SRE directly. - When prisons suspended in-person education, Project Reclass adapted by creating a digital networking simulator. - Tay architected ToyNet, an open source platform built with: - React - A Flask backend - Containerized Mininet instances for network emulation - Users can connect simulated routers, switches, and hosts, configure IP addresses, and run commands such as `ping` and `arp`. - ToyNet was designed to work for incarcerated learners with restricted internet access. - Deploying it in the cloud also gave Tay practical experience that helped compensate for limited professional cloud experience. - Companies interested in the project were more likely to advance her through the interview process, eventually leading to Datadog. ## Finding the Right Environment at Datadog - At Datadog, Tay learned Kubernetes, chaos engineering, network traffic control, and Go. - She found that her rigor and visual thinking were assets rather than liabilities. - While learning Datadog’s Chaos Controller codebase, she mapped files and dependencies by drawing boxes and arrows. - Her experience suggests that engineers do not need to learn or reason in a single conventional way; the right environment can turn an apparent weakness into a strength. Tay’s path recommends experimenting broadly, studying independently, and building concrete projects that reveal how you think and solve problems. The most suitable tech role may emerge only after moving between companies and disciplines rather than forcing yourself to succeed in an ill-fitting position.

React Kubernetes Open Source Cloud Computing+4

figmaOct 13, 20213 min readCurated summary

LiveGraph: real-time data fetching at Figma | Figma Blog

LiveGraph is Figma’s in-house real-time data-fetching layer built on PostgreSQL. It lets frontend developers declare live data views with GraphQL-like queries, while LiveGraph reads PostgreSQL’s replication stream to deliver updates within milliseconds. Figma built it to replace fragile, manually maintained client events and to support real-time subscriptions at large scale without relying on polling or a new database technology. ## Problems with Figma’s Earlier Real-Time Architecture - React clients initially loaded large data sets through Ruby HTTP endpoints and stored them in Redux. - Backend code manually emitted events whenever database records changed. - Frontends subscribed over WebSockets and applied those events to client state. - As data volumes grew, Figma split requests into incremental loads, making data ownership and availability harder to reason about. - Complex changes—such as permission updates affecting many resources—were difficult to represent with individual events. - Events could arrive out of order or fail to correspond reliably with database writes, causing client state to diverge from server state. ## Why Figma Chose Live Queries - Figma wanted developers to define data subscriptions declaratively rather than manually coordinate fetches and update events. - GraphQL provided a natural interface for describing the relevant portion of the object graph. - LiveGraph uses “live queries,” which keep query results synchronized, rather than GraphQL subscriptions in the narrower sense of consuming event streams. - The system is a query and data-fetching layer over existing PostgreSQL infrastructure, not a replacement persistence layer. ## In-House System Versus Existing Tools - Figma’s multiplayer service handles collaborative writes and conflict resolution within individual files, whereas LiveGraph focuses on reading application data. - Systems such as Hasura, Prisma, and PostGraphile offered GraphQL subscription features but were not designed primarily for Figma’s scale of concurrent live subscriptions. - Polling was rejected because it increases database load and requires developers to choose polling intervals for each query. - Figma’s collaborative product made real-time data central enough to justify building and operating a specialized internal system. - The company did not claim LiveGraph was universally superior; its value came from matching Figma’s specific scale and requirements. ## Replication-Stream-Based Updates - LiveGraph executes queries directly against PostgreSQL. - It tails the database replication log to detect changes instead of repeatedly polling tables. - Reading the replication stream enables update latency measured in milliseconds. - Because the system must process the complete volume of database changes, its architecture needs to distribute updates across machines and database shards. - This approach separates the complexity of detecting database changes from product code, allowing frontend engineers to work with declarative JSON data views. ## Frontend API - Product developers send GraphQL-like queries and receive results as JSON trees. - A schema defines server-side entities and relationships, while views expose queryable subsets of that graph. - The frontend can therefore request the data it needs and rely on LiveGraph to keep the result synchronized as the underlying PostgreSQL data changes. LiveGraph’s central recommendation is architectural: derive live client views from the database’s authoritative change stream rather than maintaining a parallel network of hand-written events. For organizations with similar scale and real-time requirements, this can improve consistency and simplify product development, though Figma’s in-house approach was justified by its unusually collaborative workload.

React PostgreSQL TypeScript GraphQL+4