HTML | Techlist.io

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.

Read original

HTML Figjam React JavaScript+4

figmaMar 29, 20212 min readCurated summary

Behind the scenes of creating the official Figma kit for Tailwind UI | Figma Blog

Tailwind Labs created an official Figma kit to meet strong customer demand for Tailwind UI designs. Building it required translating more than 400 responsive code components into over 1,400 Figma components and 10,000 elements, with the final code serving as the pixel-perfect reference. The project showed that a production design kit needs rigorous structure, naming, responsive modeling, and reusable variants—not just visual accuracy. ## Building a Design File as a Product - Unlike exploratory product files, a commercial design kit is itself the final deliverable. - Every decision affects usability, including: - Layer names - Component structure - Page organization - Variant behavior - The team used the finished HTML and Tailwind CSS components as the standard the Figma files needed to match. ## Consistent Layer Naming - Consistent names allow Figma overrides to persist when users swap component instances or variants. - For example, a button’s text layer was always named “Text,” allowing customized text to carry over when changing button sizes. - This becomes especially valuable in complex components containing icons, headings, paragraphs, and links. ## Mirroring HTML Structure in Figma - Auto Layout, layout grids, and constraints let Figma layers approximate HTML structure and browser layout behavior. - Matching design and code architecture helps designers and developers share an understanding of what layouts can support. - It also exposes recurring implementation patterns, such as responsive padding and centered max-width containers, which developers can turn into reusable layout utilities. ## Using Variants to Simplify Components - Instead of maintaining dozens of separate components, the team combined options into configurable variants. - A single Badge component could cover type, size, theme, and optional secondary elements. - Variant properties were named consistently with code component properties, using terms such as: - Type - Size - Theme - Position - Breakpoint - State - Variants made components more discoverable and reduced duplication. - The completed kit contained 1,430 components averaging seven variants each; without variants, it would have exceeded 10,000 components. ## Scale and Quality Control - Over several months, the team built and rebuilt more than 1,400 components and 10,000 distinct elements. - The project emphasized detailed auditing and pixel-level consistency, although the provided article excerpt ends before describing that process. The main recommendation is to treat a shared Figma kit like a carefully engineered product: align it closely with the codebase, establish naming and structural conventions early, and use variants to keep a large responsive system manageable.

Read original

HTML Figma Design Systems CSS+3

figmaNov 18, 20202 min readCurated summary

Behind the feature: the making of the new Auto Layout | Figma Blog

Figma’s new Auto Layout evolved from a long-standing idea into a more flexible system for creating responsive designs. The team sought to combine flexbox-inspired power with an approachable interface, defining Auto Layout as “a thoughtful subset of flexbox.” The result was a feature designed to reduce manual resizing while preserving usability for designers who may not know CSS deeply. ## The Need for Automatic Resizing - Before Auto Layout, designers had to manually resize buttons, reposition neighboring elements, and adjust containers whenever content changed. - This repetitive work made responsive design systems difficult to build and maintain. - Figma had considered automatic layout since its early designs, but the concept remained unimplemented until Maker Week in 2018. - During Maker Week, product director Sho reimagined the feature in prototypes, eventually leading to a dedicated team focused on making Auto Layout real. ## Designing a Thoughtful Subset of Flexbox - The team drew inspiration from CSS flexbox because it could help align design workflows with implementation in code. - They intentionally avoided reproducing all of flexbox’s complexity. - Their guiding principle was to create “a thoughtful subset of flexbox” that remained easy to learn and use. - Core capabilities included: - Enabling vertical or horizontal layout on a frame. - Setting spacing between items. - Automatically sizing frames to hug their contents along the main axis. - Allowing fixed or content-based sizing on the counter axis. - Giving individual components independent alignment within their container. ## Prototyping and Team Alignment - The designer, Marcin, built an early prototype entirely in HTML. - The prototype helped the team experience the feature early and resolve interaction details before implementation. - It informed decisions about frame-handle decoration, dragging behavior, and visual outlines. - This shared prototype helped product, design, and engineering align around both the feature’s behavior and its usability. Figma’s approach shows that a successful layout tool does not need to duplicate the full complexity of web technologies. By selecting the most useful flexbox concepts and presenting them through an intuitive editor, Auto Layout made responsive design more practical while keeping the experience accessible.

Read original

HTML Figma Design Systems CSS+3

figmaDec 4, 20192 min readCurated summary

Design more, resize less, with Auto Layout | Figma Blog

Figma’s Auto Layout brings structural concepts from CSS flexbox into a free-form design environment. It reduces repetitive resizing and repositioning by making frames respond automatically to their content, while preserving designers’ ability to explore layouts freely. The result is a workflow that feels closer to production code without sacrificing visual experimentation. ## Bridging Design and Development - Traditional Figma designs require manual updates when content changes, such as resizing a button and repositioning neighboring elements. - HTML/CSS and SwiftUI handle these relationships automatically, but are less suited to rapid, free-form design exploration. - Auto Layout combines both approaches by adding flexible, code-inspired layout behavior as a property of any Figma frame. ## How Auto Layout Works - Items inside an Auto Layout frame are arranged vertically or horizontally. - The frame automatically sizes itself based on its contents. - Frames can include padding, fills, strokes, and corner radii, allowing designers to create buttons without extra layers. - Changing button text automatically resizes the button and adjusts surrounding elements. - Spacing is controlled at the container level rather than independently between every pair of items. ## Lists, Menus, and Design Systems - Auto Layout simplifies repeated interface elements such as lists and menus. - Items can be reordered through drag and drop instead of manually repositioning them. - Existing components and design-system elements can be converted using **Shift + A** or the Option menu. - The feature supports more generic components that adapt to different content instead of requiring separate variants. ## Nested Frames and Safeguards - Auto Layout frames can be nested to build complex interfaces, similar to nested HTML `div` elements. - Designers can edit content or move elements in and out of layout frames. - Figma includes safeguards against unintended actions, such as placing a large image inside a button. - Holding **Command** on macOS or **Ctrl** on Windows overrides these safeguards when needed. Figma recommends trying Auto Layout through its playground file, video, and documentation. The initial release was presented as a starting point, with further improvements expected based on user feedback.

Read original

HTML Figma Design Systems Responsive Design+3

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.

Read original

HTML React TypeScript JavaScript+4

figmaJul 31, 20193 min readCurated summary

Automate work. Bring in data. Extend what’s possible with Figma Plugins. | Figma Blog

Figma introduced plugins to make the platform more extensible, reliable, and accessible to both designers and developers. The goal was to let anyone with basic HTML and JavaScript skills build tools that automate repetitive work, bring real-world content into designs, and address needs such as accessibility. After six weeks of beta testing, more than 40 community plugins were publicly available, with private distribution also supported for organization customers. ## Why Figma Built a Plugin Platform - Designers already depended on plugins, but many were unreliable or insecure because they used unsupported APIs. - Designers without coding skills had to wait for someone else—or for engineering resources—to build the tools they needed. - Figma designed its plugin architecture to be: - Secure - Stable - Performant - Familiar to web developers - The company’s guiding idea was that anyone who could build a basic webpage should be able to create a Figma plugin. - Building a plugin system for a web-based design tool required significant architectural investment, intended to encourage more creators and experimentation. ## Plugin Availability and Distribution - Plugins became available to the entire Figma community after the beta. - Users could browse plugins within Figma and install them with one click. - Plugins could be launched from a design file’s right-click menu. - Figma Organization customers could: - Build private plugins - Distribute them across their company - Curate approved plugins - Install plugins on behalf of users ## Utility Plugins for Repetitive Tasks - **Similayer**, created by David Williames, selects layers with similar properties so designers can edit them in batches. - **Super Tidy**, created by Ismael González-Nicolás, renames frames and reorganizes them in the layers list. - These tools reduce manual “pixel-pushing” and help designers keep files organized. ## Generative Plugins for Content and Visuals - **Unsplash** lets designers insert Unsplash images directly into Figma files. - **Content Reel**, created by Microsoft, populates designs with searchable text, avatars, and icons. - These plugins help designers work with more realistic and contextual content instead of placeholders. ## Accessibility Plugins - **Contrast Checker**, from Stark, checks whether colors, visuals, and typography have sufficient contrast and readability. - **Color Blind**, created by Sam Mason de Caires, previews designs through eight types of color vision deficiency. - Together, these plugins help designers identify accessibility problems that may otherwise be difficult to notice. Figma’s plugin launch positioned extensibility as a core part of the product: designers could automate workflows, use realistic content, improve accessibility, and create custom tools instead of waiting for platform features or engineering support.

Read original

HTML Design Systems Accessibility JavaScript+3

figmaJun 10, 20192 min readCurated summary

Plugins are coming to Figma | Figma Blog

Figma announced the beta of its plugin platform, inviting developers to build tools that extend and improve design workflows. The initiative follows the success of Figma’s HTTP API and aims to make plugins powerful while preserving platform stability, security, performance, and compatibility. Figma initially planned a limited beta, with broader access and community-created plugins to follow. ## Opening the Figma Platform - Figma had previously launched an HTTP-based API for exporting design data and connecting Figma with other tools. - Customers used the API to: - Export icons through custom Slack commands. - Push design updates into development environments. - Maintain and distribute GitHub’s Octicons SVG library. - Independent designers and developers had also begun creating spaces for sharing Figma-related functionality. ## Designing a Stable Plugin System Figma recognized that plugins can create compatibility, security, and performance challenges. Rather than exposing internal APIs—which may change frequently—it designed dedicated third-party APIs intended to remain stable as Figma evolves. The company established several principles: - Plugins should be intuitive for all designers. - Anyone capable of building a website should be able to create a plugin. - Developers should be able to use popular programming languages. - Plugins should not harm Figma’s performance or user experience. - Figma would fully support and maintain the APIs used by plugins. ## What Plugins Could Do During the beta, developers could create plugins to: - Automate repetitive design tasks. - Speed up design workflows. - Import real-world data into Figma files. - Share plugins with teammates. Because Figma is web-based, the company expected plugins to be relatively easy to build and maintain for developers familiar with HTML and JavaScript. ## Beta Access and Future Availability - The beta was limited to a selected group of users. - Applicants were prioritized based on the ideas they wanted to build. - Figma intended to use the beta to stress-test and refine its plugin APIs. - Broader access was planned for the future. - Non-coders would eventually be able to use community-built plugins. Developers with basic web-development skills and a plugin idea were encouraged to apply for the beta.

Read original

HTML JavaScript Web Development Figma Plugins+2

figmaApr 1, 20193 min readCurated summary

Pairing is the key to evangelizing your design system | Figma Blog

A successful design system depends on relationships and culture, not just tools, documentation, or component libraries. Robin Rendle argues that pairing directly with designers is the most effective way to build trust, discover system problems, and encourage adoption. Working together turns the system team from a source of criticism into a practical partner that helps teams move faster. ## Treat the Design System as a Cultural Project - Early efforts focused on creating a UI kit and component library, assuming better tools would solve inconsistency. - The author learned that design systems reflect relationships between designers, engineers, product managers, and customers. - Gusto complemented its technical work with: - A Slack channel for questions and feedback - Design system office hours - An introductory UI kit for new employees - These initiatives helped, but pairing proved more effective because it involved working directly with people. ## Pairing Is User Research - Side-by-side collaboration reveals: - Which components and patterns are confusing - Where documentation is incomplete - What feels awkward or works well - Which user needs the design system is failing to address - Pairing replaces assumptions with direct observation of how people actually use the system. - Sessions also help the team evaluate whether: - Designers and engineers know the component library exists - They understand current HTML, CSS, and accessibility practices - Components are being explained in terms of organizational benefits - Useful designs should become official reusable patterns - Unlike office hours, pairing reaches people before they necessarily recognize that they need help. ## Pairing Turns Critique into Collaboration - Design system guidance should feel like accelerating someone’s work, not restricting creativity. - New systems are often complex, poorly documented, and full of hidden constraints: - Limited color choices - Existing components that designers may not know about - Accessibility requirements - Technical limitations embedded in the codebase - Simply imposing these rules can make the design system team seem controlling, causing people to ignore documentation or work around the system. - Pairing creates a more productive conversation where the design system team shares institutional knowledge while learning what product teams need. - Both sides benefit: product teams work faster and learn reusable patterns, while the system team gains insight into real-world requirements. ## Pairing Builds Design System Advocates - Designers and engineers who receive direct, helpful guidance are more likely to understand and support the system. - Personal collaboration builds trust and makes adoption feel like an advantage rather than an obligation. - Each pairing session can turn participants into advocates who carry the system’s practices and rationale back to their teams. Design system teams should prioritize pairing as an ongoing form of user research, education, and relationship-building. The strongest systems are not merely documented and enforced; they are developed collaboratively with the people expected to use them.

Read original

HTML Figma Design Systems Accessibility+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.

Read original

HTML Figma React JavaScript+4

figmaApr 17, 20182 min readCurated summary

5 steps to nailing your portfolio presentation in design interviews | Figma Blog

A strong portfolio presentation is less about showing every project and more about communicating your strengths clearly and engagingly. New designers often lose interviewers by starting too ambitiously, overexplaining complex work, or failing to clarify their individual contribution. The article recommends presenting authentic projects with a simple structure, while avoiding attempts to imitate the interviewing company’s brand. ## Start with a Clear Introduction - Begin slowly by stating your name and primary design strength. - Focus on the area that best distinguishes you, such as: - Typography - UX/UI design - Communications design - Motion graphics - Front-end development - Acknowledge other skills without presenting yourself as an expert in everything. - Experienced designers with broad expertise can instead emphasize their range. ## Lead with Work You Care About - Choose the project you loved most rather than the one that took the longest. - Passionate, playful projects tend to feel more authentic. - These projects reveal your design sensibility and personality more effectively than large, overly complicated assignments. - Save secondary or less personally meaningful work for later. ## Explain Each Project with the Four Ws Keep project explanations concise. Provide the context, problem, process, outcome, and then allow interviewers to ask for more detail. - **What:** Briefly explain what the project is, using language accessible to everyone in the room. - **Who:** Clearly identify your role and distinguish your contribution from that of teammates. - **Why:** Describe the problem or need the project addressed, especially for work created for a client or organization. - **Where:** Explain how the design was used and what impact it had. Include metrics such as signups or other results when possible. - If the project was never implemented, explain how it might have created value. ## Be Careful with the Interviewing Company’s Brand - Using the company’s visual identity in your presentation may seem flattering, but it can easily become inappropriate. - You may not know the company’s brand guidelines and could unintentionally misrepresent its design system. - The designers who created the company’s branding may be among the people interviewing you, making inaccurate imitation especially risky. A successful portfolio presentation should be focused, personal, and easy to follow. Lead with work that reflects genuine enthusiasm, explain your role and results plainly, and let the interview panel guide deeper discussion through questions.

Read original

HTML Figma CSS Typography+3

figmaDec 7, 20163 min readCurated summary

Components in Figma | Figma Blog

Figma’s 2016 Components release applies software-engineering ideas such as composition, inheritance, and overrides to interface design. Components let designers reuse shared elements as linked instances, so updates remain consistent while local customizations are preserved. The result is a design workflow that supports both systematic reuse and creative flexibility. ## Designing with Components - Components help designers break complex interfaces into smaller, understandable parts. - Reusable elements can appear in multiple locations, at different sizes and with local modifications. - Unlike duplicated copies, component instances remain connected to their source. - Updates to the original component are automatically reflected across all instances, improving consistency and reducing repetitive work. - Examples include repeated address-book rows containing shared typography, spacing, icons, and graphics. ## Figma’s Design Goals Figma aimed to make Components: - Easy for new users to learn. - Powerful enough for advanced design systems. - Flexible throughout the design process. - Low-overhead, so systematic design improves speed without limiting experimentation. ## Creating and Using Instances - Any frame or selected object can be converted into a component through the toolbar. - Duplicating, copying, pasting, or Alt-dragging a component creates instances rather than independent copies. - Instances can move independently on the canvas while retaining their connection to the source component. - Changes made to the main component propagate immediately to its instances. - Certain internal properties, such as the position and size of nested objects, are restricted to make components easier to maintain. ## Style and Property Overrides - Instance changes are treated as overrides of the original component’s properties. - Designers can override fills, strokes, colors, widths, and properties of nested layers. - Overrides remain intact when the source component changes. - Properties that were not overridden continue to update from the source component. - Overrides can be removed with the “Reset Instance” action. ## Complex and Nested Components - Components can contain instances of other components. - Combining nested components makes it possible to build larger systems from smaller, reusable parts. - Designers can add instances to an existing component or create a new component from selected instances. - Nested components are intended to work like other Figma objects, keeping complex systems manageable. ## Constraints - Components can be combined with Figma’s Constraints feature. - Constraints allow elements to respond to changes in size and position. - Together, components and constraints support reusable designs that adapt more intelligently across layouts. Components provide a practical bridge between design and software development: create shared building blocks once, reuse them widely, and preserve controlled customization through overrides. Teams building consistent, evolving interfaces can use them to reduce duplication while keeping designs adaptable.

Read original

HTML Figma Design Systems React+4

figmaAug 22, 20162 min readCurated summary

Introducing Figma’s Integration with Framer | Figma Blog

Figma announced a one-click integration with Framer in August 2016, responding to strong user demand for better prototyping workflows. The integration lets designers import Figma assets directly into Framer instead of exporting layers individually and uploading them manually. Together, the tools connect Figma’s rapid UI design and iteration with Framer’s expressive, code-based prototyping. ## The Need for Better Prototyping - Static mockups are insufficient for designing mobile and interactive experiences. - Designers need to: - Design within the context where a product will be used. - Demonstrate how screens respond to user input. - Add motion, transitions, and other interactive details. - Earlier workflows often required After Effects or manually building HTML, JavaScript, and CSS prototypes. - These approaches were cumbersome, involving remote servers, FTP uploads, mobile testing over 3G, and browser compatibility issues. ## Figma and Framer Integration - Figma users can import assets into Framer with one click. - The integration removes the need to export and upload layers individually. - It creates a faster path from visual UI design to interactive, code-based prototypes. - The feature was especially significant because Framer was the prototyping tool most frequently requested by Figma users. ## Complementary Strengths - Figma supports quick UI design and team iteration. - Framer enables open-ended, code-based prototypes, particularly for complex single-page interactions. - The combined workflow helps designers move ideas into code faster, test them in realistic interactions, and ship better products sooner. - The partnership also reflects Figma’s belief that code-based prototyping can be accessible to a broader generation of designers. The integration was intended to make prototyping more efficient by combining Figma’s collaborative design workflow with Framer’s flexibility and expressive coding environment.

Read original

HTML Figma Prototyping JavaScript+4

figmaDec 14, 20153 min readCurated summary

Grid Systems for Screen Design | Figma Blog

Swiss grid design remains relevant to digital products, but traditional fixed-page tools do not handle fluid screen sizes well. The post argues that flexible grids can preserve visual coherence while adapting to different devices. Figma’s solution combines constraints, layout grids, and nested frames to create responsive design systems with precise alignment. ## From Fixed Pages to Fluid Screens - Swiss designers such as Joseph Müller-Brockmann and Karl Gerstner systematized printed-page layouts using rational grid structures. - Traditional grids assumed fixed page dimensions and precise control over typography, margins, and spacing. - Digital interfaces must accommodate changing screen sizes, shapes, and pixel densities. - Designers often compensate with multiple artboards, repetitive adjustments, or guesswork when tools are built around static layouts. ## The Core Building Blocks Figma proposes three complementary features: - **Constraints:** Define how an object responds when its containing frame changes size. - **Layout grids:** Provide detailed alignment and sizing rules across a design. - **Nested frames:** Allow different parts of a design to use their own layout systems. The greatest flexibility comes from combining all three rather than using them independently. ## Constraints for Responsive Behavior - Objects can be anchored to the left, right, or center of a frame. - Objects can also stretch to fill available space. - Constraints provide a basic way to preserve relationships as a frame expands or contracts. ## Stretchable Layout Grids - Grids provide more granular control than simple edge or center constraints. - A box spanning two grid columns can grow or shrink while remaining aligned to those columns. - Column grids can organize text, toolbar icons, and other interface elements—not just web-page content. - Stretching grids allow layouts to respond naturally to changing screen dimensions. ## Frames Within Frames - Nested frames let different sections of a design use separate grids and alignment rules. - This makes it possible, for example, to keep toolbar icons aligned to one grid while allowing the main content to follow another layout. - Frames provide more functionality than static artboards because they support responsive relationships and hierarchical layout systems. - The structure resembles nested HTML `<div>` elements, making it closer to how designs are implemented in code. ## Toward Better Design Tools - Responsive layout systems are only a starting point for improving digital design tools. - The post encourages designers to reassess inherited conventions and look to historical design practices for useful ideas. - Modern tools should combine the coherence of traditional grids with the flexibility required by variable screens. Figma’s recommended approach is to build designs from nested frames, stretchable grids, and well-defined constraints, creating systems that remain organized without being tied to a single screen size.

Read original

HTML Figma Design Systems Responsive Design+3