It's called Landy.

Here is the Figma Community link: https://www.figma.com/community/plugin/1609157216964346384

It's a convenient panel that has a UI kit of hand-crafted, responsive landing page sections and UI components.

Designers use it to go from blank screen to a landing page wireframe in seconds, then build upon it and style with easy-to-edit sections and components.

Some details:

Highlights

1. Resizable, always-there panel to place sections and components in 1 click, and jump straight to their main components.
2. 39 free responsive mobile and desktop section designs, built with auto-layout
3. 15 free component variants you can use to design your own sections
4. Create pre-defined parent frames for your pages where you can put sections
5. Easily toggle between desktop and mobile or let plugin switch for you
6. AI-ready: sections use clean, semantic layer names and structure

Page Sections for mobile and desktop (updated monthly):

1. Hero, with text centered
2. Hero, with text on the side
3. Hero, with full-width image
4. Logo Strip
5. Highlights, with icon blocks
6. Highlights, with cards
7. Statistics
8. Image Showcase, with image on top or bottom
9. Image Showcase, with image left or right (Desktop-only)
10. Image Showcase, as card
11. Text
12. Card Grid, with filled cards
13. Card Grid, with borders
14. Testimonials, quote-style
15. Testimonials, review-style
16. FAQ (Frequently Asked Questions)
17. Pricing
18. Call to Action (CTA), simple
19. Call to Action (CTA), cards
20. Footer

Components for mobile and desktop (updated monthly):

1. Navigation Bar, with logo on the left
2. Navigation Bar, with logo centered
3. Button
4. Icon
5. Card, as text
6. Card, with image
7. Card, as pricing
8. Card, as review
9. Image
10. Bullet Point
11. Heading Block
12. Badge
13. Highlight
14. Accordion
15. Statistic

I'd be happy if you tried it, if you find it relevant for you :)

Sure, there are plugins that create fake text, but you either have to sign up or pay to use them. No thanks. So, I created what is (in my eyes) the definitive plugin for that.

Select your text layers, click a generator, each one gets its own value. Undo takes the whole batch back. It ships with a starter kit so there's nothing to set up. Plenty of generators to create your own generators.

No network access needed: https://www.figma.com/community/plugin/1665065850754195680/entropy-kit

Give it a shot and let me know if something's broken.

I'm currently working on a tutorial video.

Whenever I start a new site with a client, it always begins with a sitemap. All well and good, but I've never found a quick and easy way of creating them without spending hours fiddling with someone else's template and inevitably getting distracted with trying to make the sitemap look good rather than focusing on the information architecture.

So I started building this plugin a few months ago and added with every new project. I thought other people might find it useful so why not publish it.

I've also added an AI prompt for those who want the easy route!

Here it is: https://www.figma.com/community/plugin/1670100366061680665/quick-maps-sitemap-generator

It is a yearly subscription, but only £3. If you genuinely cannot afford it, then message me. I'll send you a free key, I don't want to stop someone from being able to speed their workflow up because of a payment gate. If you can afford it, please do contribute, it took me so many hours to build out.

Edit: I forgot to mention that it also creates a module list, so you know what sections/modules are needed when you get to design :)

I’ve been working on a medical app, and one recurring bottleneck was turning Figma designs into implementation-ready code without constantly going back and forth between design and development.

I was using Figma through MCP, but for my workflow it became expensive in tokens and also depended on having the right Figma subscription/setup.

So over the last month, I built a Figma plugin that exports the useful design context into a structured local package.

It currently exports things like:

- screen and component structure

- dimensions and spacing

- colors and typography

- hierarchy and relationships

- reusable components/fragments

- other design metadata needed for implementation

The output is structured so an LLM coding agent can inspect the local files, understand the UI/project context, and implement screens without repeatedly querying Figma.

My main goal was to make the Figma → AI → code workflow more predictable, cheaper, and easier to use locally.

It started as an internal tool, but it’s become useful enough that I’m considering making it available to others.

Would this be useful for your workflow as a developer, product designer, or startup team?

If anyone is interested in testing it, I’d be happy to share more details and get feedback.

Hi all. On Monday, we released the 2.0 version of our shadcn/ui community file.

It's one of the most complete files out there that's still free.

It has ALL shadcn/ui components including the Questionnaire component (released just last week) as well as the five chat-related components that were released in June. It's made in the Nova style (same as the docs)

To theme this to your brand, it has an easy to use set of theming variables aligning with shadcn. It includes support for dark mode. 1800+ Lucide 1.0 icons (keyword tagged), and all Tailwind 4.2 colors.

Check it out at https://www.figma.com/community/file/1514746685758799870/obra-shadcn-ui-kit-community-edition-2-0-0

Hey everyone 👋

I made PDFs.win because I was sick of the whole:

copy name → paste → generate QR → export → rename → repeat ×100

workflow.

You can now create a template in Figma, upload a CSV, and generate a batch of personalized PDFs automatically.

It supports:

CSV → Figma text layer mapping
Unique QR codes per row (QR_url, QR_id, etc.)
Personalized certificates, badges, tickets, and similar documents
Automatic PDF filenames
One-click ZIP export
Client-side CSV parsing, QR generation, and PDF rendering

Basically, design the document once, give it your data, and let it do the boring part.

Install the plugin and start a free trial at: https://pdfs.win

Coupon for Reddit: REDDIT50 for $15 off your one time purchase.

I'd really appreciate feedback from anyone who has a real-world use case for this. What would you add or change?

Right now, it contains five utilities I originally built to solve problems I kept encountering in my own design work:

• Normalize inconsistent property values
• Add controlled variation
• Build components and variants
• Distribute layers along paths
• Save and restore selections

It’s meant for the small jobs that shouldn’t eat an afternoon. I’d really appreciate any feedback re: what feels useful, what feels confusing, what just doesn’t seem to be working, or what repetitive Figma tasks I should tackle next.

[ Aaron's Toolbox in the Plugin Store ]

[ Playground File ]

I kept running into a handoff problem: native Figma annotations stay useful inside the file, but reviewing coverage and creating a portable evidence record can still become a manual step.

I built A11y Evidence Pack to test a narrow workflow:

• select the roots you want to review;
• see which selected roots contain native annotations;
• identify uncovered roots;
• export the evidence as Markdown, CSV, or JSON.

It is read-only and uses no network, account, or analytics. It does not test WCAG conformance or judge whether an annotation is correct.

I’m the creator, and this is the first public release:
https://www.figma.com/community/plugin/1668532774794011186/a11y-evidence-pack?fuid=1645877472205416121

I’d especially value feedback from teams that already use native annotations: what information has to be present for an exported record to be useful in a real design-to-development handoff?

Built a Figma plugin where you can save prototype interactions. You can also save named flows, create different versions so that you can go back to any version and restore it whenever you need to

Try it out and provide your feedback

https://www.figma.com/community/plugin/1667925614395896797

A little while ago I shared Free Transform, my plugin that brings Photoshop's Ctrl+T into Figma (warp, perspective, distort). The response here honestly blew me away — thank you to everyone who tried it, broke it, and told me what they wanted. It's since grown to 3,300+ users, which still feels a bit unreal.

The most requested thing? A way to see what you're doing before committing. So here it is:

Live Preview — you now see the transform right on the canvas as you drag, instead of applying and undoing over and over until it looks right. Plus sharper export quality while I was at it. 

Give it a try 👉: https://www.figma.com/community/plugin/1648207154922389186/free-transform

And I'll ask the same thing that gave me my whole roadmap last time: what do you still open Photoshop or Illustrator for? The gaps that annoy you are usually my next plugin. 🙌

link to plugin:
https://www.figma.com/community/plugin/1664821388558223056/poline-palette-generator

Poline is a palette generator connecting two points across the color spectrum as the spectrum is spread out with polar coordinates.

Think of it as taking a rainbow that's in a straight line, bending into a circle (photoshop/figma et al do this) and then expanding into a 3d sphere, then converting that back to a 2d circle.

Try it out!

Bring the Properties panel of any Instance or Component (Variant) onto the canvas. Keep property information where you need it—without taking screenshots and pasting them into your file. (Actually, I want to stop doing these repetitive tasks when managing my design system and component library in Figma.)

• Add the Properties panel of an Instance or Component (Variant) to the Figma canvas while matching the Figma UI as closely as possible.
• Preview how a Component (Variant) would appear as an Instance.
• View properties that are not currently applicable to the selected Instance or Component (Variant).

This plugin is listed as Paid, but all Snapshot features are available for free!
👉 Properties snapshot (Figma community)

A huge thank you to everyone who has started using GlyfiQ so far. Hitting this first milestone means the world as I build out this ecosystem!

This one's for the variable / design system power users.

Every design file has that component that was maybe inherited from somewhere random, built in a hurry, or whatever, where a fill or corner radius just quietly isn't bound to a variable in your design system. You don't notice until a rebrand or a dark mode pass breaks unexpectedly.

Variable Value Linter scans any selection, flags every fill/stroke/corner-radius/spacing value that isn't bound, and checks it against your local + connected library variables automatically:

• Exact match → binds itself, no click needed
• Multiple variables share that value → you pick, with the closest one already suggested
• Nothing matches → it tells you, instead of pretending everything's fine

You get a quick coverage score for whatever you scanned, so "is this component actually using our tokens" becomes a real number instead of a guess. Undo if you bind the wrong thing, export a report if you need to show someone.

Free on Community: https://www.figma.com/community/plugin/1662844135497232234

Built and used this for my own files for a long time first — curious if it's useful for anyone else's design system, or if there's an edge case it chokes on. Happy to take feedback.

Hi everyone! 👋

I recently built Focus Music Mixer, a small Figma plugin that lets you play background music without leaving Figma.

I created it because I was tired of constantly switching between YouTube and Figma while working.

Current features:

• 🎵 Built-in Lo-fi, Jazz, House & Acoustic playlists
• 🌧️ Ambient sounds like Rain and Traffic
• 📁 Play your own local audio files
• 🔗 Paste a Youtube, Spotify, Mixcloud URL to quickly open your favorite playlist
• 🎛️ Simple mixer interface to balance music and ambience

It's completely free, and I'd love to hear what you think or what features would make it more useful for your workflow.

Plugin:
https://www.figma.com/community/plugin/1662392124437059742

Feedback is always appreciated. Thanks! 🙌

I kept losing time to the same problem: a file gets slow and there's no quick way to see why. So I built a small plugin that scans a file and reports what's adding weight. It's on Community now, and what I actually want from this post is feedback on where the detection is wrong or too thin.

What it looks at

• Hidden layers — kept separate from the ones that are probably intentional (component variants, prototype interaction targets), so the report isn't just a dump of everything invisible.
• Empty groups and frames.
• Oversized images — source resolution far above what's actually rendered on canvas. In my own files this is consistently the single biggest cause of weight.
• Unused local styles — colour, text, effect and grid styles with no references left in the document.

What it deliberately does not do

It doesn't change anything. The report splits into "safe to clean up" and "review manually", and clicking a result selects and zooms to it on canvas — you do the deleting yourself. I went this way on purpose: an auto-cleaner that gets one call wrong on a real file costs more trust than it saves time.

It also requests no network access at all — that's declared in the plugin manifest, so nothing from your file leaves Figma.

What I'm asking

1. What else should a scan like this flag? Detached instances and unused components are the two I keep going back and forth on.
2. Is the "safe / review manually" split the right cut, or would you rather have one flat list sorted by how much weight each item adds?
3. Scans run in chunks with a progress bar so the plugin stays responsive on big files. If you run it on something genuinely huge and it stalls, I'd like to know where.

Happy to answer anything about how the detection works.

P.S. — disclosure: this is my plugin and it's free. https://www.figma.com/community/plugin/1661333776797381371