Reddit Community Analysis: r/SwiftUI

1. Data Sources & Methodology

• 274 unique posts after deduplication across 4 time periods (all-time, year, month, week), 14 raw JSON files (top_all ×4, top_year ×4, top_month ×4, top_week ×2 — week has fewer than 200 posts so only 2 pages returned content).
• Per-period breakdown
  • top_all — 100 posts, score range 145–824, median ~195
  • top_year — 100 posts, score range 77–824, median ~145
  • top_month — 100 posts, score range 2–279, median ~6
  • top_week — 45 posts, score range 0–279, median ~2
• Overlap: ~90 posts live in top_all only (historical canon); only 1 post appears in all four periods ("tracking calories shouldn't cost $8/month..." at 279, seeded the week). About 30 posts overlap all + year, and the month/week windows are almost completely decoupled from the all-time leaderboard — exactly the same pattern as sister subs r/swift and r/iOSProgramming.
• Date collected: 2026-04-10
• Subreddit subscribers: 58,902 (created 2019-06-03 — the youngest and smallest of the three main Apple dev subs)
• Score range & median (full dataset): 0 to 824; median ~88
• Top-25 threshold: 200; top-50 threshold: 160; top-100 threshold: 121
• Format mix: VIDEO 131 (48%), IMAGE 54 (20%), TEXT 42 (15%), LINK 35 (13%), GALLERY 12 (4%). This is the most video-heavy developer subreddit in the entire data/analyses/ set.
• Cross-subreddit score calibration (using other analyses in data/analyses/):
  • r/ClaudeAI peaks ~8,000 (viral AI tier)
  • r/programming peaks ~4,500
  • r/macapps peaks ~2,029
  • r/swift peaks ~1,223
  • r/iOSProgramming peaks ~1,017
  • r/SwiftUI peaks ~824 — the lowest-ceiling Apple-dev sub in the set. Only 1 post clears 800 all-time, only 3 clear 500, only 12 clear 300. If you're hoping for a 2,000-upvote tool launch, you are in the wrong subreddit.

Scope: this is a content-strategy and distribution guide for someone who wants to launch, promote, or build reputation through r/SwiftUI. It is not a sociological study of Apple UI developers.

2. Subreddit Character

r/SwiftUI is a small, craft-obsessed "show me the code" gallery where the top content is 30-second video clips of animations and Metal-shader experiments with a GitHub link in the caption. It is not r/swift (language debates + achievement posts) and it is not r/iOSProgramming (career advice + monetization + Saturday self-promo). It is a visual lab — a place where people come to watch beautiful UI snippets scroll by and say "how did you do that?" The top 50 is dominated by tutorial-style animation clips, recreated famous interactions (Apple's iCloud login, Cash App numpad, iPod click wheel, iMessage tab bar), and Metal-shader effects layered over SwiftUI views.

The mod team enforces exactly one rule that determines everything else in this sub: Rule 2 — "Only promote open source apps." Quoted verbatim from the sidebar: "To reduce spam and nurture a useful platform for beginners and experienced programmers, we only allow app promotion if the source code is provided too, preferably using a GitHub link." There is also a dedicated flair literally named "Promotion (must include link to source code)" — the rule lives inside the flair picker. Rule 3 — "Paid Content" — makes it concrete: "Selling code, templates or prebuilt apps is not allowed." Rule 6 — "This is not a design showcase" — closes the last loophole: "Whenever you want to showcase a design, please add source code to it, or general explanations on how it works." Together, these three rules produce a community where the default assumption is that every post must come with a GitHub repo, a code snippet in the selftext, or a detailed technical explanation. Posts that violate this are not ignored — they are downvoted into the friction tier.

The consequence: r/SwiftUI has the cleanest, highest-trust "show your work" culture of any dev subreddit I've analyzed. Compare the #1 all-time post — "Jelly Switch in Metal and SwiftUI" (824, ratio 0.99, 47 comments) — selftext is literally two sentences + a GitHub link. That's the canonical post. No screenshots of growth metrics, no App Store links without source, no "vibe-coded" announcements. When someone posts a closed-source product, the community politely tolerates it if the flair is honest and the effort is visible (see "For my first swift app, I built a native macOS image converter" at 809 — ratio 0.99, open-sourced, App Store link is secondary). When someone posts a closed-source product without source code and with price hints, it still clears moderation but sits at lower scores with friction-tier ratios.

The community is technical but unusually gentle. There is almost no snark or meme culture. The top comments on question posts are genuinely helpful. The running jokes ("Fixing Swift, one typealias at a time…" at 701, "SwiftUI is getting switch statements!" at 151) are always at Apple's expense, never at another user's. Compare this to r/iOSProgramming's sharp anti-Xcode meme tone or r/swift's rising anti-vibe-coding backlash — r/SwiftUI has almost none of that. The word "vibe-coded" appears in the full dataset only ~4 times, and always self-deprecatingly ("no vibe coding at all" in the Infinity for Reddit post, or mocked in a title like "Ridicule a Vibe Coder Tuesdays").

How it differs from the sister subs:

• vs r/swift (137k subs, peak 1,223): r/swift celebrates language features and Swift Student Challenge wins. r/SwiftUI celebrates visual polish and animation technique.
• vs r/iOSProgramming (192k subs, peak 1,017): r/iOSProgramming has a "Promo Saturday" monetization window. r/SwiftUI has no such window — promo is year-round, but always gated by source-code requirement.
• vs r/macapps (217k subs, peak 2,029): r/macapps is a product launch platform. r/SwiftUI is a technique gallery where the product (if any) is secondary to the code.

The single sharpest framing: r/SwiftUI is a GitHub-backed animation loop gallery that happens to be organized as a subreddit. Think "CodePen for SwiftUI" with Reddit comments.

3. The All-Time Leaderboard

Dataset median: ~88. Top-25 threshold: 200. Top-100 threshold: 121. Note how tightly the top is clustered — #1 is 824 and #25 is 200, a 4.1x spread. Compare r/macapps where #1 is 2,029 and #25 is ~820.

Observations

• 19 of the top 25 are VIDEO (76%). Only 5 are static IMAGE and one of those (trim(from:to:) at 265) is actually a GIF. The top 25 has zero LINK, zero TEXT, zero GALLERY posts.
• The #20 evergreen is the only post in all 4 time periods — "tracking calories shouldn't cost $8/month..." (279, 87 comments, ratio 0.97). It's the biggest C/U-ratio outlier in the top 25 (0.31 vs. a top-25 average of ~0.10). This is an anti-subscription open-source launch with a strong values statement — the same playbook as the #1 r/iOSProgramming post. If you want discussion in r/SwiftUI, the reliable lever is values-posture + open source, not pure code.
• The #7 post ("I'm impressed by what you can replicate in minutes using AI" at 391, ratio 0.95) is the only top-25 post that references AI-generated code positively — and its 0.95 ratio is the lowest in the top 20. The community tolerates AI mention but does not celebrate it. Compare to the #3 post "Fixing Swift, one typealias at a time…" — Apple-at-expense joke, ratio 0.94, 701 score. Both AI-positive and Apple-critical content are rated similarly: allowed, but not universally loved.
• No flair is used ironically in the top 25. The one surprise is the "Promotion" flair at #9 (Qewie QR) — this is a closed-source App Store launch that went to 354. It predates the current "Promotion (must include link to source code)" flair naming, which is why the label is shorter. Newer equivalents are all tagged "Promotion (must include link to source code)".

4. Content Type Dominance at Scale

What this table tells you

• No flair is a handicap. More than half of the dataset (154/274) has no flair, and the top-performing posts are disproportionately flair-less. This is the opposite pattern from r/macapps (strict flair hierarchy) and closer to r/swift (casual). If your content is strong, skipping the flair is not penalized. That said — the "Promotion (must include link to source code)" flair signals honesty and is probably the correct move when the post is a product launch.
• "News" punches above its weight. 22 posts total but an average score around 150 and two in the top 25 — it's the highest avg-score flair when you exclude the tiny-sample "Promo" category. The flair seems to be self-applied by the most effort-heavy, GitHub-linked, "here's a release" posts (ShaderKit, Damage, Qewie, SwipeActions, SwiftUI agent skill). These are author-announced shippings, not journalism.
• "Question" underperforms in raw score (~55 avg) but that's deceiving. Question posts get fewer upvotes but the same or higher comment counts — see Section 9. If your goal is distribution via conversation, Question is the best vehicle.
• The most surprising finding: "Promotion (must include link to source code)" has 24 posts with an avg of ~145 — essentially the same avg as Tutorial. The source-code gating rule works both as a filter and as a trust signal. Posts tagged with this flair consistently land above the dataset median. Contrast this with "Promotion" on r/swift where it buys you a rolled-eye.
• Tutorial outperforms all flairs except News. Avg ~140, highest ratio (0.98). But the distinction is blurry — many "Tutorial" posts are animation demos with "here's the code" in the caption. The flair is really just shorthand for "I'm sharing technique, not asking a question."

5. Content Archetypes That Work

I identified 6 distinct archetypes in r/SwiftUI, ranked by score ceiling. None of these are generic. Each one has specific examples from the dataset and specific reasons why it works in THIS community.

Archetype 1: The Animated Microdemo with a GitHub Gist

Score range: 150 to 824. The canonical r/SwiftUI post. A 15-60 second video clip of one specific visual effect — a jelly switch, a border animation, a holographic card, a shader-driven transition — with a GitHub repo or gist link in the selftext. Often the selftext is literally just the link.

• "Jelly Switch in Metal and SwiftUI" — 824, ratio 0.99 (#1 all-time)
• "Hole-forming displacement with springy in SwiftUI" — 478, ratio 0.99
• "SwiftUI Holographic Card Effect" — 372, ratio 1.00
• "Animated grid, made with SwiftUI" — 344
• "SwiftUI Border Animations" — 323
• "Scratch to Reveal animation using SwiftUI" — 208
• "SwiftUI Infinite Loop Loader with Metal" — 203

The pattern: one effect, one video, one link. No product, no upsell, no "sign up for my newsletter." The video is autoplay-friendly (loops cleanly, visually striking in first 0.5 seconds), the effect is specific enough to be teachable, and the code is free. This is the ONLY archetype that reliably hits 400+.

For distribution: If your product has any animated UI component, strip it into a standalone video clip, open-source just that component, and post it. Do NOT post the product — post the component. Users will click through to your profile and find the product later.

Archetype 2: The Recreation

Score range: 100 to 700+. Rebuild a famous UI in SwiftUI. Has its own small sub-genres: (a) recreating Apple's own components (Weather app, iCloud login, Cash App numpad, iPod click wheel, stock Settings), (b) recreating other well-known apps (Robinhood onboarding, Arc browser intro, Snow Leopard Safari).

• "Recreated the iCloud login animation with SwiftUI" — 284, ratio 0.99
• "I'm recreating the stock weather app for mac/iPad" — 294
• "Cash App numpad entirely recreated in SwiftUI" — 200
• "Snow Leopard's version of Safari rebuilt in SwiftUI" — 150
• "I built an iPod style Apple Music player" — 79 (plus a 71-point sibling post)
• "1-year update: Settings app recreations" — 102

The pattern: The recreation is high-fidelity, usually a short video, and the title names the source explicitly ("stock weather app", "iCloud login", "Snow Leopard Safari"). There's a strong undercurrent of "I bet I can do Apple's work" pride. These rarely hit 500, but they hit 150-300 very reliably.

For distribution: Pick a specific interaction from a famous app that your product touches and rebuild it. Ship the source. This is a very cheap way to land a 200-point post and establish technical reputation.

Archetype 3: The Metal Shader Collection

Score range: 80 to 824. A growing genre — Metal shaders wired into SwiftUI views. This archetype barely existed on r/SwiftUI before iOS 17 added Metal shader support to SwiftUI, but since then it has produced the #1 all-time post and 6-7 posts in the top 50.

• "Jelly Switch in Metal and SwiftUI" (ShaderKit) — 824
• "Added new Metal shaders to ShaderKit" — 153
• "Having a lot of fun... with Metal shaders and SwiftUI, I made a small Shader kit" — 121
• "Custom SwiftUI transitions with Metal" — 121
• "SwiftUI+Metal shaders: free course" (metal.graphics) — 144
• "Waiting Animations with Metal Shaders" — 160
• "SwiftUI Infinite Loop Loader with Metal" — 203
• "Fiddling with SwiftUI and Metal" — 186

The pattern: Author jrochabrun (ShaderKit, 4 posts, avg ~310) and Victorbaro (metal.graphics course, 2 posts) demonstrate the most important fact about this archetype — it's dominated by a small set of recognizable authors building open-source shader kits. If you publish one shader, you get maybe 80 points. If you publish a collection with an ongoing GitHub repo, you can compound posts and get 200+ each time you add shaders.

For distribution: If your product has ANY use for visual effects, open source a shader kit first. The kit becomes a recurring content engine. This is the highest-ROI technique on this sub in 2025-2026.

Archetype 4: The Package Launch with Honest Scope

Score range: 70 to 250. Launching a Swift Package on SwiftPM / GitHub that solves a very specific, visible SwiftUI problem. These are flair-correctly-tagged "Promotion (must include link to source code)" and live at the 100-200 mark reliably.

• "SwiftUI agent skill for people using Codex, Claude Code" by twostraws — 250, ratio 0.97 (Paul Hudson — high author trust)
• "SwipeActions, a swift package..." — 249
• "Portal: Cross-view element transitions" — 210
• "Just released ProgressUI — a SwiftUI-native, customizable progress indicator library" — 168
• "I open-sourced 5 tiny SwiftUI utilities I use in every project" — 128
• "Introducing SwiftUIHTML — Open-source HTML → SwiftUI renderer" — 126
• "Pure-SwiftUI Popovers" — 82

The pattern: The best-performing package launches either (a) come from a known author with pre-existing trust (twostraws = Paul Hudson, Dimillian = Ice Cubes developer), OR (b) are framed around a very specific micro-problem, not a big vague framework. "5 tiny utilities I use in every project" does better than "after years of iOS development, I open-sourced our best practices into an AI-native SwiftUI component library..." (98, ratio 0.92) because the former promises nothing and the latter promises the moon.

For distribution: Ship small, specific packages. Title them the way the community searches — "ShimmerKit", "ToastKit", "SwipeActions" — not with marketing phrases like "production-ready framework." Lead with the code, not the "why."

Archetype 5: The Teaching Explainer

Score range: 80 to 400. Visual / diagrammatic posts that explain a specific SwiftUI concept — property wrappers, environment values, the attribute graph, view update performance.

• "Apple barely documents how SwiftUI actually works under the hood..." (AttributeGraph video by karinprater) — 238, ratio 1.00
• "I was surprised that many don't know that SwiftUI's Text View supports Markdown" — 249
• "SwiftUI decision tree that'll help you decide what property wrappers to use" — 211
• "I've made this graph to help get an overview of all 60+ EnvironmentValues" — 273
• "A Commonly Overlooked Performance Optimization in SwiftUI" — 168
• "PSA: Text concatenation with + is deprecated" — 145
• "The SwiftUI Starter Pack" — 287
• "SwiftUI 2.0 Cheat Sheet" — 157

The pattern: These are effectively reference cards the community saves. The best ones are standalone JPG/PNG images that can be screenshotted and kept. Text posts in this archetype (PSAs, long explainers) perform noticeably worse than the image-native versions.

For distribution: If you're building developer tooling, make a reference card for your domain and post it as a single image. Keep text minimal. Cite the source in a top-level comment, not the title.

Archetype 6: The "How Do I...?" Question

Score range: 30 to 275. Paste a video or image of an app (usually not yours) and ask how to recreate the effect. These generate the most comments per upvote of any archetype.

• "I built this digital canvas entirely using SwiftUI" — 275 (the high-end anomaly)
• "How to create a gradient from an image's main colors, like Apple's recipe view?" — 125, 33 comments
• "How do people create Muscle Maps in Swift?" — 119, 53 comments
• "Any ideas on how to make this???" — 87, 32 comments
• "How the heck do I recreate this wabi intro app?" — 74, 31 comments
• "How is the Apple Notes editing toolbar implemented in SwiftUI?" — 19, 12 comments

The pattern: Low upvote ceiling (~150 for most), BUT very high comment-to-upvote ratio (often 0.25+). They attract helpful senior devs who want to demonstrate expertise. The title formula is almost always "How do I/we/you create/recreate/replicate THIS?" with a short video of a third-party app.

For distribution: You can't directly use this archetype to launch a product, but you CAN use it to build author credibility before launching. Participate in question threads, answer well, leave a non-promotional comment. The community will later recognize your name when you post your product. This is the primary "pre-launch" tactic on this sub.

6. Format Analysis

r/SwiftUI is THE most video-dominated developer sub in the entire data/analyses/ catalog. r/swift video share in the top 25 is ~40%, r/iOSProgramming is ~50%, r/macapps is ~45% (and their videos are app demos, not effect clips). r/SwiftUI's 76% is a direct consequence of its "it's a visual gallery" character — animation simply requires video.

LINK posts are near-dead in the top tier. 35 LINK posts in the dataset, average score ~50, ZERO in the top 25. A YouTube link, a Medium article, or a personal blog post with no embedded video preview just does not compete. If you have an article, record a 15-second clip of the effect it describes and post that as a VIDEO with the article URL in the selftext.

TEXT posts only work for values-posture or reference dumps. The top TEXT posts are "I open-sourced 5 tiny SwiftUI utilities" (128), "All 16 CS193p Stanford 2025 iOS dev lectures released" (82), "Apple Developer Documentation MCP" (126). Plain long-form technical writeups without visuals cap around 100.

What Format to Use For What

What Makes a Good Demo Video

Based on the top 25 video posts, the production rules are specific:

1. Length: 10-40 seconds. The top performers are short loops. The 2-minute "I walked through everything I built" videos rarely clear 200. Do NOT narrate. Let the interaction speak.
2. Loop cleanly. First frame = last frame. Reddit's video player autoplays silently in feed, and a looping clip gets 3-5 viewings per scroll.
3. Start with the payoff. First 0.5 seconds must show the effect. "Jelly Switch" (#1) cuts straight to the toggle animation. No title cards, no intros, no "hey guys."
4. Show the problem once, then the solution. If you're demoing a transition, tap the thing that triggers it within the first second.
5. Record at 60fps in Simulator. The top posts use Xcode Simulator recording, not a camera pointed at a phone. Higher frame rate = the effect looks smooth; a 30fps camera recording of a 120fps device screen looks bad and costs score.
6. No music, no voice. Zero top-25 videos have audio. Reddit mutes by default; music adds nothing.
7. Vertical or square aspect ratio. Matches mobile scroll. Widescreen clips of a landscape Mac app perform noticeably worse than phone-shaped clips of an iOS interaction.

Gallery posts (12 in dataset)

Gallery caps around 173 ("VStack, HStack and ZStack explained"). Galleries are acceptable for Settings-app recreation showcases or multi-platform comparisons but lose to a single video every time. Top gallery posts use 4-6 images.

7. Flair/Category Strategy

Flairs on r/SwiftUI are light-touch. More than half the dataset has no flair at all, and no-flair posts still dominate the top 25. That said, the flair you choose signals intent to the community and the mods.

Raw performance ranking (by avg score, min n=5)

1. Promotion (legacy) — ~290 avg (n=3, high variance; includes the 354-point Qewie)
2. Promo (legacy) — ~190 avg (n=4, includes Cindori Mac perf monitor at 247)
3. News — ~150 avg (n=22)
4. Promotion (must include link to source code) — ~145 avg (n=24)
5. Tutorial — ~140 avg (n=31)
6. (no flair) — ~105 avg (n=154)
7. Question — ~55 avg (n=29)
8. Solved — ~12 avg (n=2)

Distribution utility ranking (different!)

1. Promotion (must include link to source code) — the honest signal. Mods won't touch you, community recognizes you're playing by the rules.
2. Tutorial — maximum trust. Signals "I'm here to teach, not sell."
3. News — only if you're genuinely shipping something. Attaching News to a minor update feels performative.
4. (no flair) — best when your content IS a visual demo and you're not selling anything. Don't add flair just to add flair.
5. Question — low raw score but highest discussion volume. Use when your goal is relationship-building or getting senior-dev answers.

Specific flair guidance

• Never use the legacy "Promo" or "Promotion" flairs — these are being phased out. Use "Promotion (must include link to source code)" for anything with commercial intent.
• Never post a closed-source product and tag it Promotion. Top mod will probably let it stand if the effort is visible, but the ratio collapses. Reference "I built an iPod style Apple Music player" (79, ratio 0.97) — honest about open-sourcing; vs. scattered closed-source attempts that sit below 50.
• Don't use Tutorial for a product demo. It works only for actual teaching content. Mixing them feels slippery.

Pricing model hierarchy

r/SwiftUI has an explicit rule against selling (Rule 3), so the pricing ladder is shorter and sharper than other subs:

1. Free + open source (MIT / Apache 2.0) — the default expectation. No friction.
2. Free closed-source app with source parts open — tolerated if effort is visible (e.g., the image converter at 809 — app is free, source is on GitHub, there's a mention of lifetime license but the source is the primary deliverable).
3. Free TestFlight with source — works for preview/beta of open-source tools.
4. Paid app on App Store — only allowed if the underlying SwiftUI code is shared. "Paid courses or learning material is tolerated for those contributing to the community" — but be prepared to justify it.
5. Subscription app — do not post. If you must, reframe as a code post ("here's the SwiftUI technique I used in my app") and let users discover the product via profile.
6. Closed-source paid templates / app boilerplates — explicitly banned by Rule 3. Do not post.

The single most important pricing signal you can send: "everything stays on your phone, MIT licensed, zero dependencies." That exact phrasing (or close variants) appears verbatim in 4 different top-performing posts, including the evergreen calorie tracker at 279.

8. Title Engineering

The top titles are dry, descriptive, and specific. Zero clickbait. Zero growth metrics. Zero stars-on-GitHub humblebrags.

Deconstructing the top 10

1. "Jelly Switch in Metal and SwiftUI" (824). 5 words. Describes exactly what's in the video. Mentions both Metal (shader) and SwiftUI (UI framework) — two technical keywords. Zero adjectives.
2. "For my first swift app, I built a native macOS image converter" (809). Underdog framing ("first app") + "native" keyword + Mac keyword. The "first" signal invites mentorship comments.
3. "Fixing Swift, one typealias at a time…" (701). Only meme in top 5. Ellipsis implies exhaustion with Apple's naming. Works because it's an Apple-at-expense joke, not a user-at-expense joke.
4. "Pretty proud of this onboarding UI I have created for my iOS App Generator. Built 100% with SwiftUI!" (535). "100% with SwiftUI" is a keyword the sub loves — it appears in 4+ top-25 titles.
5. "hole-forming displacement with springy in SwiftUI" (478). Hyper-specific technique name. No marketing. Lowercase — a signal of humility.
6. "RedditOS, an open source SwiftUI macOS Reddit client" (395). Name-comma-description-in-6-words formula.
7. "i'm impressed by what you can replicate in minutes using AI" (391). Conversational lowercase, positions AI as tool not magic.
8. "SwiftUI Holographic Card Effect" (372). Three-word formula: [framework] [adjective] [noun]. Zero fluff.
9. "First app! Qewie — Make stunning QR codes" (354). "First app!" underdog + product name + one-line pitch.
10. "My skills in graphic design tools are almost non-existent, so I created my app's icon and splash animation in SwiftUI instead, here's the code." (350). Long title that is the hook — the "here's the code" at the end is the promise.

Title formulas that work

• [Effect name] in SwiftUI or [Effect name] with SwiftUI — the Metal Shader and Animation default
  • "SwiftUI Border Animations" (323), "SwiftUI Holographic Card Effect" (372), "SwiftUI Infinite Loop Loader with Metal" (203)
• Recreat(ed|ing) the [famous app] [thing] (in SwiftUI / with SwiftUI) — the Recreation default
  • "Recreated the iCloud login animation with SwiftUI" (284), "I'm recreating the stock weather app" (294), "Cash App numpad entirely recreated in SwiftUI" (200)
• Built / I built [concrete thing] [optional — source code inside] — the Package Launch default
  • "I built this digital canvas entirely using SwiftUI" (275), "Built the fuse wallet onboarding screens (source code inside)" (166), "Built the timed delete button interaction (source code inside)" (105)
• First [app/project/package]: [thing] — the underdog opener
  • "First app! Qewie" (354), "For my first swift app, I built..." (809), "Just released [X] — a SwiftUI-native [thing]" (168)
• PSA / In SwiftUI, you can... — the teaching opener
  • "PSA: Text concatenation with + is deprecated" (145), "In SwiftUI, you can use trim(from:to:) to draw and erase a shape's path" (265), "In SwiftUI, you can use dashPhase to move dashes along/around a shape/path" (198)
• How [do I|to|does] [replicate|recreate] [famous thing]? — the Question opener
  • "How to create a gradient from an image's main colors, like Apple's recipe view?" (125), "How is the Apple Notes editing toolbar implemented?" (19)

Title anti-patterns (community-specific, with evidence)

1. Star counts and download numbers. Searching the full dataset for "stars", "github star", "downloads", "1k", "10k" in titles returns zero top-25 results. The community does not reward vanity metrics. Compare to r/SideProject / r/macapps where "I hit 10k downloads" posts work.
2. Marketing superlatives — "revolutionary", "game-changing", "next-gen". Do not appear at all. The closest is "Neon Vision Editor — A lightweight and modern text editor..." (95, ratio 0.97) which is tolerated.
3. AI brag titles without a useful artifact. "After years of iOS development, I open-sourced our best practices into an AI-native SwiftUI component library with full-stack recipes..." (98, ratio 0.92) is a textbook example — the title promises marketing and the ratio reflects skepticism.
4. Emoji in titles. Almost none in the top 50. Emoji appears in ~6% of all titles and those posts average well below the median.
5. Question titles that sound like complaints. "Am I missing something?" or "Is there a better way...?" posts consistently underperform because they feel low-effort.
6. Cross-post framing. "I just saw this and I HAD to share" (r/iOSProgramming's biggest post) has no r/SwiftUI equivalent because the community is almost entirely about original work.

9. Engagement Patterns

Conditional recommendation

• If your goal is VISIBILITY (highest upvote count, feed placement), use Archetype 1 (animated microdemo) with a tight VIDEO clip and a GitHub link. Target 200-400 upvotes.
• If your goal is RELATIONSHIPS AND DISCUSSION (comments, user feedback, name recognition), use Archetype 6 (Question) or a values-framed TEXT post. Target 30-50 comments regardless of score.
• If your goal is AUTHORITY (long-term author reputation across the sub), use Archetype 5 (Teaching explainer) — reference cards and PSAs build reputation across months.

Highest-discussion topics (subjects that reliably generate 30+ comments regardless of score):

1. Anti-subscription values posts — "tracking calories shouldn't cost $8/month" (87 comments), "open sourced my entire iOS calorie tracker app" (1 comment because the 2nd-pass posting; but the original generated dozens)
2. Navigation quirks (NavigationStack bugs, zoom transitions, sheet behavior) — "Swipe to go back still broken with Zoom transition navigations" (32 comments), "Navigation Zoom transition issues" (15 comments)
3. Liquid Glass / iOS 26 unknowns — "Liquid Glass live activity widget. How?" (11 comments), "I spent 3 days at Apple NYC talking Liquid Glass" (11 comments), "Cash App new Liquid Glass update looking NICEEE" (31 comments, controversial)
4. Apple Foundation Models / on-device AI — "I made a completely free open source AI app..." (36 comments), "Playing with Apple Foundation Models in SwiftUI" (9 comments)
5. Performance / memory issues — "Users said our app 'forgets everything' after a phone call" (20 comments), "PNG vs SVG: 263 flags in LazyVGrid causing memory issues" (42 comments)

10. What Gets Downvoted

r/SwiftUI has unusually few hostile-ratio posts. The community is gentle by default. Most underperformers are low-effort rather than actively downvoted. Still, the dataset contains a few informative examples.

Three ratio tiers

• Above 0.94 — universally well-received: 210+ posts (~77%). This is the default. If your ratio is above 0.94 you're safe.
• 0.85-0.94 — net positive but with friction: ~35 posts. Most common reason: mixed signal about promotion, Liquid Glass controversy, or mild topic-off.
• Below 0.85 — controversial or community-hostile: ~15 posts.

Notable posts below 0.85

Named anti-patterns

1. Vibe-code admission — mentioning Claude Code / Cursor / "AI wrote this" prominently in a title or early in selftext is a net negative. "Can't get sound or haptic to fire in SwiftUI — tried everything, first iOS app" (0, 0.43) opens with "building my first iOS app with Claude Code." Community is polite but downvotes the help request.
2. Closed-source product shill — posting a non-open product without addressing the open-source rule. Automatic friction tier.
3. LINK post with no selftext context — posting a blog URL and nothing else. "The 2FA app that tells you when you get 314159" (3, 0.56) — blog link, empty selftext, dies.
4. Third-party-app fanboy post — "Cash App new Liquid Glass update looking NICEEE, how do we recreate it" (40, 0.71) — the community likes the technique but resents being the audience for another app's marketing.
5. Self-crosspost / duplicate — posting the same effect twice in days. The author of "Dynamic Island Reading Progress Indicator #2" (348, 0.98) posted "Dynamic Island Reading Progress Indicator" (174, 0.81) — the second one works, the first is punished.
6. Pure solicitation — "What should I build next?" / "What's missing from the ecosystem?" — appearing to ask the sub to do your product research.
7. Marketing-maximalist package launches — "AI-native", "full-stack recipes", "production-ready", "10x your AI assistant" — all trigger the ratio hit. The ShipSwift post ("After years of iOS development..." 98, 0.92) is the textbook example.

There is no public "blacklist" or "hall of shame" on r/SwiftUI. Enforcement is quiet: mods remove obvious spam under Rule 2/3, and the community uses the downvote button. The only explicit rule users cite in comments is "no source code = not welcome."

11. The Distribution Playbook

Phase 1: Pre-launch (2-6 weeks before you post)

1. Read Rule 2 again and internalize it. If what you're launching is not open-sourceable in some form — not even the UI components, not even a demo fork — reconsider whether r/SwiftUI is your venue. Switch to r/macapps or r/SideProject.
2. Extract one standalone visual component from your product. Not the whole app. One transition, one button, one list row, one shader. Put it in its own GitHub repo or gist. This is the content you will actually post.
3. Record the clip. 10-40 seconds, Xcode Simulator, 60fps, vertical or square, looping cleanly. No music. No narration. Start with the payoff.
4. Participate in 5-10 question threads over 2 weeks. Answer well. Don't mention your product. Users absolutely remember helpful commenters.
5. Write the post in advance. Title = [Effect name] in SwiftUI OR Built [concrete thing] (source code inside) OR I recreated [famous thing] with SwiftUI. Selftext = 1-2 sentences + GitHub link + optionally a 5-line code snippet.

Phase 2: Launch day

1. Flair correctly. If you have a commercial angle at all, use Promotion (must include link to source code). If it's pure technique, use Tutorial or no flair. Never use legacy "Promotion" / "Promo".
2. Post time. r/SwiftUI is small enough that weekday morning US Pacific works — there's no "Promo Saturday" convention like r/iOSProgramming. The dataset doesn't show clear time patterns because volume is low.
3. Don't cross-post at the same moment. If you're also posting to r/swift or r/iOSProgramming, stagger by at least a day. Cross-posts are tolerated but redundant content shows up in the same user's feed twice and the second one collapses.
4. Do NOT comment on your own post immediately. The first comment should come from the community. Your first comment should arrive ~30 minutes later with either code details or a question back to the community.

Phase 3: First 24-48 hours

1. Expect 150-250 upvotes if things go right. 300+ is exceptional. Above 500 is once-a-year. If you want 1000+ upvotes, you are in the wrong subreddit.
2. First-hour ratio check. If your ratio drops below 0.90 in the first hour, something is wrong with how you framed the post. Common causes: closed-source product, AI-brag title, marketing-maximalist language. You can recover by adding a reply that explains you're open-sourcing [X], but don't edit the title.
3. Answer every comment that asks "how'd you do that". This is the primary source of upvotes in hour 4-12. People return to posts where the OP is engaged.
4. If the post dies in the first 4 hours (< 30 upvotes, ratio below 0.90), do not delete-and-repost. That's bannable and visible. Leave it and iterate on the next post.

Phase 4: Ongoing presence

1. Ship regularly. The top repeat authors — raul0101 (7 posts), jrochabrun (4 posts, ShaderKit), opentonegeorge (4 posts), Cultural_Rock6281 (4 posts) — post every few weeks, not daily.
2. Build a branded open-source repo. ShaderKit, legendary-Animo, SUCODEY's various demos — these compound. Each new commit = potential new post under the same repo umbrella.
3. Become a "known" name in the comments. The community trusts twostraws (Paul Hudson) and Dimillian because they recognize them. There is no shortcut to this; it takes 10-20 helpful comments before your posts get an early-hour boost.
4. Avoid Liquid Glass hot takes for now. The topic is too new and divisive (see the 0.71-ratio Cash App post). Wait until WWDC26 when the pattern settles.

Community-specific comment strategy

Pre-written templates for the 5 most common reply scenarios in r/SwiftUI:

1. "How did you do that effect?" → "Full source is in the repo: [LINK]. The key piece is [.phaseAnimator/Shader/matchedGeometryEffect / whatever]. Let me know if you want a deeper breakdown — I'm happy to write one up."
2. "Why not use UIKit for this?" → "Good question — I tried UIKit first because [X]. SwiftUI got me to [specific outcome] in way less code, but the tradeoff is [honest limitation]. I'll probably end up bridging via UIViewRepresentable if I hit [specific wall]." Never argue that SwiftUI is unconditionally better.
3. "Does this work on iOS 15/16/17/18/26?" → State exact minimum version. Cite the API. If you don't know, say so and commit to updating the README.
4. "Is this open-source?" → If yes: "Yep — MIT licensed, link in the post. Stars appreciated but not required." If no: DO NOT post. Go back to Phase 1.
5. "Will it conflict with [Paul Hudson's / Apple's native] implementation?" → "Different problem — native [X] handles [Y] but not [Z], which is what this solves. Happy to be corrected if I missed a native API."

Stealth distribution tactics (non-obvious)

• Answer "How do I recreate this?" questions with a link to your package. This is by far the most effective way to get repeat exposure without launching a post. Your GitHub username becomes known.
• Add a code-challenge comment chain. When someone posts a cool effect, reply with "I spent 10 minutes on this — here's my simplified version: [gist]". Attaches your name to their top post.
• Post a reference card that uses your library's naming conventions. People save the card. Later they search the names and find your library.
• Update an existing open-source repo and announce the update under a new post title. ShaderKit has 4 posts using this pattern. Each new shader batch = a new post.
• Get tagged in someone else's post. If another author credits your library in their caption, their post's engagement leaks toward you. This happens reliably after 3-5 posts.

Score-tier calibration

• Tool launches on r/SwiftUI cap at ~800 — and ONLY with open source + visible effort. The 2 posts over 800 are both outliers that combined multiple archetypes.
• Realistic target for a well-executed animation microdemo: 200-400.
• Realistic target for a package launch with a known problem solved: 100-200.
• Realistic target for a Question post: 50-150.
• If you need 3,000+ visibility, you need a different archetype or a different subreddit. r/macapps is your next stop (peak 2,029) if the product has a consumer angle.

Post-publication measurement

• Ratio > 0.98 and 50+ comments in 6 hours: you hit it. The post will keep climbing for 24 hours.
• Ratio 0.94-0.98 and 20-30 comments: normal success. Score will land between 150-300.
• Ratio 0.90-0.94 and < 20 comments: friction. Something in your framing is off. Reply in the comments with more context / code — you can often rescue a post into the 100-200 range.
• Ratio < 0.90 in the first hour: the post is dying. Do not delete. Stop replying defensively. Evaluate what signal (marketing language, closed-source, vibe-code admission) triggered the downvotes and avoid it next time.
• No traction in first 4 hours (< 20 upvotes): the post is not going to recover. r/SwiftUI's front page moves slowly but there's no late-day resurrection pattern like r/ClaudeAI.

12. Applying This to Any Project

Quick-reference checklist (12 items)

1. Is the component or library open-sourceable? If no → wrong sub.
2. Do you have a 10-40 second VIDEO clip? If no → record one.
3. Does the clip loop cleanly and start with the payoff? If no → re-edit.
4. Is the title [Effect] in SwiftUI or Built [X] (source code inside) or I recreated [famous thing]? If no → rewrite.
5. Is the GitHub link in the selftext? If no → add it.
6. Did you use the "Promotion (must include link to source code)" flair if commercial?
7. Have you commented helpfully in 5+ unrelated threads in the last 2 weeks?
8. Is the minimum iOS version stated in the README?
9. Is the license MIT / Apache 2.0? (Anything more restrictive causes friction.)
10. Does the title avoid "AI-native", "production-ready", "revolutionary", and emoji?
11. Is your selftext under 300 words for visual posts, or under 600 words for values posts?
12. Are you prepared to answer "How'd you do that?" within 30 minutes of posting?

Scenario-based launch guides

Scenario A: Free / open-source package

Optimal launch formula: VIDEO (Simulator, 20 sec loop) → title "[Name] — a tiny SwiftUI package for [problem]" → selftext = 3-sentence problem statement + GitHub link + 5-line code example → flair: (none) or "Promotion (must include link to source code)". Target: 150-250 upvotes. Key risk: Overselling scope. "A tiny package for X" beats "a production-ready framework for X."

Scenario B: Closed-source paid app

Optimal launch formula: Do NOT launch the app directly. Instead, extract one visual component, open-source just that component, and post that. Mention the full app in a single sentence at the end of the selftext with no marketing language. Target: 100-200 for the component post; downstream clicks to App Store are a bonus, not the goal. Key risk: Making the post about the app instead of the technique. See "Neon Vision Editor" (95, 0.97) vs. "First swift app: image converter" (809, 0.99) — same structural content, different framing outcomes.

Scenario C: One-time / lifetime pricing app

Optimal launch formula: Open source the UI layer of the app entirely. Keep the business logic / data layer closed. Post as a technique showcase — the SwiftUI image converter at 809 follows this playbook exactly (the app mentions a "lifetime license for early adopters" but the source is real). Target: 200-500. Key risk: Being vague about what's open. Be explicit: "UI is open, backend is closed, here's why."

Scenario D: Subscription app

Optimal launch formula: Do not post the subscription product at all. Post an open-source SwiftUI utility you built while making the app, unrelated to the subscription. Example: you run a $9/mo calorie tracker — post your SwiftUI chart library or your custom picker component. Separate the identities. Target: 100-200 for the utility post. Key risk: The community will recognize the indirect promotion if the utility's README links back to the paid app. Keep the utility clean.

Scenario E: Built with AI / vibe-coded

Optimal launch formula: Avoid the word "vibe-coded" in the post. Say "built with AI assistance" only if asked. Focus the post entirely on one visual effect or one useful utility — the AI-assisted provenance is irrelevant as long as the code works and is open. Target: 100-200. Key risk: Leading with the AI angle. "I built [X] with Claude Code" posts sit at 0.73-0.92 ratio. "[X] in SwiftUI (source inside)" posts with identical underlying code hit 0.99.

Cross-posting guidance (referencing existing analyses)

If you're also posting to other Apple-dev subs:

• On r/SwiftUI → frame as "[Effect] in SwiftUI" + video + GitHub. Visual first.
• On r/swift (peak 1,223) → frame as "I built a language/package demo for X" + code sample + anti-vibe-code posture. Language first, visuals secondary. (See the r/swift analysis.)
• On r/iOSProgramming (peak 1,017) → post on a Saturday using the sub's promo-day convention. Frame as "I spent [N] months building X, here's what I learned" + screenshots + App Store link. Career-narrative first.
• On r/macapps (peak 2,029) → frame as "macOS is missing [X], so I built it" + feature screenshots + App Store link. Product first. r/macapps is the ONE Apple sub where closed-source is actively welcomed.
• On r/SideProject / r/buildinpublic → frame as journey post with metrics. These subs reward the growth-metric titles that r/SwiftUI explicitly rejects.

The core rule: r/SwiftUI is the only one of these subs where the post is about the code technique, not the product. If you can't strip out the code and make the post stand on its own, you don't have a r/SwiftUI post — you have a r/macapps post.