swiftui-layout-components
Build SwiftUI layouts using stacks, grids, lists, scroll views, forms, and controls. Covers VStack/HStack/ZStack, LazyVGrid/LazyHGrid, List with sections and swipe actions, ScrollView with ScrollPosition and scroll-driven reveal surfaces, Form with validation, Toggle/Picker/Slider, .searchable, and…
Install / Use
npx skills add dpearson2699/swift-ios-skills --skill swiftui-layout-componentsInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
Development & EngineeringSupported Platforms
Tags
Our assessment of swiftui-layout-components
swiftui-layout-components scores 87/100 on our quality scale, 2207th of 4,698 Development & Engineering skills we index (top 47%).
Its SKILL.md is 11 KB long, well organised into 16 sections with 10 code examples: a thorough specification that gives an agent plenty to work with.
With 1,143 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
- Our last check on 2026-11-02 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 86/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
swiftui-layout-components compared with similar skills
All 4 of these similar skills score higher than swiftui-layout-components; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| swiftui-layout-components (this skill)by dpearson2699 | 87 | 1.1k | 4mo ago | SKILL.md |
| taste-skillby Leonxlnx | 100 | 116.8k | 8d ago | CLAUDE.md |
| ai-job-searchby ai-job-search-dev | 100 | 72.1k | today | CLAUDE.md |
| claude-howtoby luongnv89 | 100 | 47.3k | 2d ago | CLAUDE.md |
| lobehubby lobehub | 100 | 85.6k | today | MCP Server |
Frequently asked questions
- How do I install swiftui-layout-components?
- Run
npx skills add dpearson2699/swift-ios-skills --skill swiftui-layout-components. The install tabs above show the steps for each supported agent. - Which AI agents does swiftui-layout-components work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is swiftui-layout-components safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 86/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is swiftui-layout-components still maintained?
- The repository was last updated about 4 months ago. That is recent enough to be usable, but agent tooling moves fast, so check the instructions against your agent's current version.
Skill content
View source on GitHubname: swiftui-layout-components description: "Build SwiftUI layouts using stacks, grids, lists, scroll views, forms, and controls. Covers VStack/HStack/ZStack, LazyVGrid/LazyHGrid, List with sections and swipe actions, ScrollView with ScrollPosition and scroll-driven reveal surfaces, Form with validation, Toggle/Picker/Slider, .searchable, and overlay patterns. Use when building data-driven layouts, collection views, paged detail reveals, settings screens, search interfaces, or transient overlay UI."
SwiftUI Layout & Components
Layout and component patterns for SwiftUI apps targeting iOS 26+ with Swift 6.3. Covers stack and grid layouts, list patterns, scroll views, forms, controls, search, and overlays. Patterns are backward-compatible to iOS 17 unless noted.
Contents
- Layout Fundamentals
- Grid Layouts
- List Patterns
- ScrollView
- Form and Controls
- Searchable
- Overlay and Presentation
- Common Mistakes
- Review Checklist
- References
Layout Fundamentals
Standard Stacks
Use VStack, HStack, and ZStack for small, fixed-size content. They render all children immediately.
VStack(alignment: .leading) {
Text(title).font(.headline)
Text(subtitle).font(.subheadline).foregroundStyle(.secondary)
}
Lazy Stacks
Use LazyVStack and LazyHStack inside ScrollView for large or dynamic collections. They create child views on demand as they scroll into view.
ScrollView {
LazyVStack {
ForEach(items) { item in
ItemRow(item: item)
}
}
.padding(.horizontal)
}
When to use which:
- Non-lazy stacks: Small, fixed content (headers, toolbars, forms with few fields)
- Lazy stacks: Large or unknown-size collections, feeds, chat messages
Grid Layouts
Use LazyVGrid for icon pickers, media galleries, and dense visual selections. Use .adaptive columns for layouts that scale across device sizes, or .flexible columns for a fixed column count.
// Adaptive grid -- columns adjust to fit
let columns = [GridItem(.adaptive(minimum: 120, maximum: 1024))]
LazyVGrid(columns: columns) {
ForEach(items) { item in
ThumbnailView(item: item)
.aspectRatio(1, contentMode: .fit)
}
}
// Fixed 3-column grid
let columns = Array(repeating: GridItem(.flexible(minimum: 100), spacing: 4), count: 3)
LazyVGrid(columns: columns, spacing: 4) {
ForEach(items) { item in
ThumbnailView(item: item)
}
}
Use .aspectRatio for cell sizing. Never place GeometryReader inside lazy containers -- it forces eager measurement and defeats lazy loading. Use .onGeometryChange (iOS 16+) if you need to read dimensions.
See references/grids.md for full grid patterns and design choices.
List Patterns
Use List for feed-style content and settings rows where built-in row reuse, selection, and accessibility matter.
List {
Section("General") {
NavigationLink("Display") { DisplaySettingsView() }
NavigationLink("Haptics") { HapticsSettingsView() }
}
Section("Account") {
Button("Sign Out", role: .destructive) { }
}
}
.listStyle(.insetGrouped)
Key patterns:
.listStyle(.plain)for feed layouts,.insetGroupedfor settings.scrollContentBackground(.hidden)+ custom background for themed surfaces.listRowInsets(...)and.listRowSeparator(.hidden)for spacing and separator control- Edge scrolling: use
List+ScrollPositionwith.scrollPosition($scrollPosition)for top/bottom scroll actions - Item or section jumps: use
ScrollView+ lazy stacks with.scrollTargetLayout()and stable targets for reliable jump-to-id behavior - Use
.refreshable { }for pull-to-refresh feeds - Use
.contentShape(Rectangle())on rows that should be tappable end-to-end - For layout review or migration guidance, lead with container choice and constraints; keep code snippets tiny, and defer spring, transition, and timing choices to
swiftui-animation
iOS 26: Apply .scrollEdgeEffectStyle(.soft, for: .top) for modern scroll edge effects.
See references/list.md for full list patterns including feed lists with scroll-to-top.
ScrollView
Use ScrollView with lazy stacks when you need custom layout, mixed content, or horizontal scrolling.
ScrollView(.horizontal, showsIndicators: false) {
LazyHStack {
ForEach(chips) { chip in
ChipView(chip: chip)
}
}
}
ScrollPosition: Enables declarative, bidirectional scroll position tracking and programmatic scrolling.
@State private var scrollPosition = ScrollPosition(edge: .bottom)
ScrollView {
LazyVStack {
ForEach(messages) { message in
MessageRow(message: message)
}
}
.scrollTargetLayout()
}
.scrollPosition($scrollPosition)
.onChange(of: messages.last?.id) {
withAnimation { scrollPosition.scrollTo(edge: .bottom) }
}
safeAreaInset(edge:) pins content (input bars, toolbars) above the keyboard without affecting scroll layout.
iOS 26 additions:
.scrollEdgeEffectStyle(.soft, for: .top)-- fading edge effect.backgroundExtensionEffect()-- mirror/blur at safe area edges (use sparingly, one per screen).safeAreaBar(edge:)-- attach bar views that integrate with scroll effects
See references/scrollview.md for full
ScrollPosition, paged reveal, zoom/crop conflict, and iOS 26 edge-effect
patterns.
Form and Controls
Form
Use Form for structured settings and input screens. Group related controls into Section blocks.
Form {
Section("Notifications") {
Toggle("Mentions", isOn: $prefs.mentions)
Toggle("Follows", isOn: $prefs.follows)
}
Section("Appearance") {
Picker("Theme", selection: $theme) {
ForEach(Theme.allCases, id: \.self) { Text($0.title).tag($0) }
}
Slider(value: $fontScale, in: 0.5...1.5, step: 0.1)
}
}
.formStyle(.grouped)
.scrollContentBackground(.hidden)
Use @FocusState to manage keyboard focus in input-heavy forms. Wrap in NavigationStack only when presented standalone or in a sheet.
Controls
| Control | Usage |
|---------|-------|
| Toggle | Boolean preferences |
| Picker | Discrete choices; .segmented for 2-4 options |
| Slider | Numeric ranges with visible value label |
| DatePicker | Date/time selection |
| TextField | Text input with .keyboardType, .textInputAutocapitalization |
Bind controls directly to @State, @Binding, or @AppStorage. Group related controls in Form sections. Use .disabled(...) to reflect locked or inherited settings. Use Label inside toggles to combine icon + text when it adds clarity.
Avoid .pickerStyle(.segmented) for large sets; use menu or inline styles. Don't hide labels for sliders; always show context.
See references/form.md for full form examples.
Searchable
Add native search UI with .searchable. Use .searchScopes for multiple modes and .task(id:) for debounced async results.
@MainActor
struct ExploreView: View {
@State private var searchQuery = ""
@State private var searchScope: SearchScope = .all
@State private var isSearching = false
@State private var results: [SearchResult] = []
var body: some View {
List {
if isSearching {
ProgressView()
} else {
ForEach(results) { result in
SearchRow(result: result)
}
}
}
.searchable(
text: $searchQuery,
placement: .navigationBarDrawer(displayMode: .always),
prompt: Text("Search")
)
.searchScopes($searchScope) {
ForEach(SearchScope.allCases, id: \.self) { scope in
Text(scope.title)
}
}
.task(id: searchQuery) {
await runSearch()
}
}
private func runSearch() async {
guard !searchQuery.isEmpty else {
results = []
return
}
isSearching = true
defer { isSearching = false }
try? await Task.sleep(for: .milliseconds(250))
results = await fetchResults(query: searchQuery, scope: searchScope)
}
}
Show a placeholder when search is empty. Debounce input to avoid overfetching. Keep search state local to the view. Avoid running searches for empty strings.
Overlay and Presentation
Use .overlay(alignment:) for transient UI (toasts, banners) without affecting layout.
struct AppRootView: View {
@State private var toast: Toast?
var body: some View {
content
.overlay(alignment: .top) {
if let toast {
ToastView(toast: toast)
.transition(.move(edge: .top).combined(with: .opacity))
.onAppear {
Task {
try? await Task.sleep(for: .seconds(2))
withAnimation { self.toast = nil }
}
}
}
}
}
}
Prefer overlays for transient UI rather than embedding in layout stacks. Use transitions and short auto-dismiss timers. Keep overlays aligned to a clear edge (.top or .bottom). Avoid overlays that block all interaction unless explicitly needed. Don't stack many overlays; use a queue or replace the current toast.
For modal routing, sheet detents, and full-screen presentation policy, hand off to the swiftui-navigation skill.
Common Mistakes
- Placing
GeometryReaderinside lazy containers defeats lazy loading; use.onGeometryChangewhen dimensions are needed. - Array indices make unstable
ForEachIDs and produce incorrect diffing. - Same-axis nested scroll views create gesture conflicts.
- Heavy custom or expanding
Listrows belong inScrollView+LazyVStack. - Large option sets should use menu or inline picker styles, not
.segmented. - Omit stack/grid
spacing:for platform-adaptive defaults unless a specific gap is intentional. - Drive a scroll reveal from one normalized progress value, not parallel booleans or a duplicate drag gesture.
- Keep per-frame scroll geometry local and avoid changing the geometry used to calculate progress.
Review Checklist
- [ ]
LazyVStack/LazyHStackused for large or dynamic collections - [ ] Stable
IdentifiableIDs on allForEachitems (not array indices) - [ ] No
GeometryReaderinside lazy containers - [ ]
Liststyle matches context (.plainfor feeds,.insetGroupedfor settings) - [ ]
Formused for structured input screens (not custom stacks) - [ ]
.searchabledebounces input with.task(id:) - [ ]
.refreshableadded where data source supports pull-to-refresh - [ ] Overlays use transitions and auto-dismiss timers
- [ ]
.contentShape(Rectangle())on tappable rows - [ ]
@FocusStatemanages keyboard focus in forms - [ ] Stack/grid
spacing:omitted unless a specific value is required - [ ] Scroll-driven reveals use one normalized progress value and keep geometry updates in a narrow subtree
- [ ] Conflicting zoom/crop interactions disable scrolling, and discrete visibility effects do not drive continuous animation
References
- Grid patterns: references/grids.md
- List and section patterns: references/list.md
- ScrollView and lazy stacks: references/scrollview.md
- Form patterns: references/form.md
- Architecture and state management: see
swiftui-patternsskill - Navigation patterns: see
swiftui-navigationskill
Related Skills
taste-skill
116.8kAgent skills that give coding agents taste: art direction, reference images and a browser check instead of generic AI pages
ai-job-search
72.1kThe job search that runs on your machine. AI job application framework built on Claude Code: evaluate postings, tailor CVs, write cover letters, prep interviews. Fork it and own it.
claude-howto
47.3kA visual, example-driven guide to Claude Code — from basic concepts to advanced agents, with copy-paste templates that bring immediate value.
lobehub
85.6k🤯 LobeHub - Super-Agents on Your Team. Add super-agents to the chats your team already uses.They take on work by themselves and get better every week.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
