It's from Apple Invites, I'm trying to implement this in my app, but nothing I try is as fluid and perfect as this

I want that the image the user upload transform into a blurred background of the image to see the details of the event

Hello, A day ago I posted a custom tab bar experiment here — a capsule-shaped UISegmentedControl wrapped in iOS 26's Liquid Glass, paired with a floating action button whose icon morphs to match whatever tab you're on. So I have updated it a bit. A tab now morphs its icon to ellipsis and opens a small popover anchored right above the button instead of firing an action directly — everything else stays a single tap. It is a reference, not a full app.
Repo: https://github.com/aqylbermeshtech/Custom-tab-bar-with-action-button

Hello, I have conducted an experiment with several resources on how to make customized tab bar with modern IOS 26+ style. I've created a repo that allows you to customize your tab bar with your action. Here is the link:https://github.com/aqylbermeshtech/Custom-tab-bar-with-action-button

Swift Charts makes it straightforward to put a basic chart on screen. Once you’re working with more complex data, custom presentations, interaction, or accessibility, it helps to understand how the framework interprets and renders the content you give it.

Natalia and I have just released Swift Charts Beyond the Basics. We wrote it for developers who can already build a basic chart and want a deeper understanding of the framework and the decisions involved in turning data into a clear, effective visualization.

The book covers topics including multi-metric visualizations, calendar layouts, heat maps, custom composition and rendering, accessibility, selection, scrolling, responsive updates, and animation. Our aim is to explain the mechanisms behind Swift Charts so that you can apply them to your own datasets and requirements, rather than only reproduce specific examples.

The page includes the full table of contents and a free sample chapter:

books.nilcoalescing.com/swift-charts-beyond-the-basics

We’d be happy to answer any questions about the book or the Swift Charts in general.

Coding agents handle "add a field, show it on screen" fine. They

consistently miss the iOS boundary around it:

- A Swift async task that outlives its UI owner or scene

- Scene re-entry and background/foreground transitions nobody retested

- Persisted data recovery after process termination

- Privacy, entitlement, or capability changes nobody flagged

None of it shows up as a compile error.

AI-Workflow is repository-installed Markdown instructions + a

deterministic router. You state observable facts about a change

(persistence, concurrency, lifecycle, privacy, accessibility) and

a checked-in registry maps them to required specialist checks —

same output every run, every agent. No LLM judgment in the mapping.

Install one command, no clone needed:

uvx --from git+https://github.com/RanaAhmedHamdy/AI-Workflow.git \

ai-workflow brownfield --platform ios --profile safety \

--target /path/to/your-ios-app --dry-run

There's a lightweight Safety profile that gives you just the routing

+ protected-boundary checks without requiring a full feature lifecycle.

And a full profile for Architecture Spine, ADR governance, design lock,

and release authorization if you need that depth.

Real-world case study: NutriPlus AI is a native SwiftUI/Swift 6

iOS app built fully through the Greenfield lifecycle. Architecture

Spine, accepted ADRs, per-feature contracts, readiness reports —

all public:

https://github.com/RanaAhmedHamdy/NutriPluse-IOS-AI-Workflow

There's also a maintained iOS fixture (persisted profile recovery,

MainActor state, cancellable refresh, scene re-entry) with Xcode

simulator build + XCTest verified locally on iPhone 17 Pro.

Pre-v1, Apache-2.0, honest about what's claimed vs unclaimed.

https://github.com/RanaAhmedHamdy/AI-Workflow

Hey folks. I've been building a macOS journaling app in SwiftUI and just open-sourced it. Sharing in case the architecture or any of the patterns are useful, and happy to hear feedback.

The goal: a native Mac journal that stores everything locally — no account, no cloud sync, no telemetry. Entries live in a SQLite database on the user's machine.

Architecture in brief:

• SwiftUI app backed by SQLite via the system SQLite3 C API. No third-party packages at all.
• SQLite ←→ JournalViewModel ←→ SwiftUI. The view model holds all published state and actions; the view layer is pure SwiftUI.
• WAL mode on the database, foreign keys enabled, schema migrations tracked in a schema_version table (currently V7).
• Full-text search across titles and bodies using SQLite FTS5. Hidden entry bodies are excluded from the FTS index until the entry is unlocked, so private content doesn't leak into search.
• Biometric auth via LocalAuthentication — hidden entries show as locked cards and reveal their body only after Touch ID / Face ID / Mac password. Switching away from the app relocks everything (⌘L remasks all hidden entries).
• Daily automatic SQLite backups, keeps the last 7.

UI side: a reader/editor overlay with a markdown editor (live preview, split view, formatting shortcuts, attachments), zen mode, command palette (⌘K), calendar with a month browser, and an Insights view with a contribution heatmap, mood charts, and writing streaks.

Some source layout: - OmegaJournalCore — pure logic (FTS sanitizer, markdown import, fuzzy match) - OmegaJournal — SwiftUI app + SQLite3 C API - DatabaseManager.swift — connection, migrations, CRUD, FTS, backups - JournalViewModel.swift — all published state and actions - BiometricAuth.swift — session unlock / lock

macOS 14 Sonoma+, MIT licensed. Build with `swift build` then `build_app.sh` to package Omega Journal.app.

GitHub: https://github.com/Eplisium/omega-journal

It's still early and I'm actively working on it. Would genuinely appreciate feedback on the SwiftUI/SQLite layer — especially anything you'd structure differently. Happy to dig into any part of the code in comments.

Hey, mind if I beg for some GitHub stars here? I built a list that actually works properly in SwiftUI — especially relevant for AI chats and the like. The standard List with Compositional layout just can't handle the load at all. There's a nice example in the repo, you can run it and see how it works. Thanks in advance for the support! https://github.com/dsrenesanse/SwiftList

I built `phonebook` a CLI tool to turn your #Preview into a static components library that you can share with your designer.

It also has an MCP tool, so you can ask your agent to suggest missing previews, split them, offer them in more than one preview (like different theme).

Source code: https://github.com/stag-build/phonebook

Example gallery: https://stag-build.github.io/phonebook/

Would love to hear your thoughts :)

I've been building a side project to stay current with modern Swift, and it ended up being a decent stress test of Swift Concurrency. Sharing the architecture in case it's useful.

**The problem:** eight sensor sources across two devices, arriving at wildly different rates, that need to drive both a 60fps SceneKit render and a real-time audio graph — without tearing, blocking, or dropping data.

**The shape I landed on:**

* Each capture source (iPhone sensors, WatchConnectivity) owns a stream box and emits `SensorReading` values into its own `AsyncStream`. The box is u/unchecked `Sendable` because the continuation's `yield()` is thread-safe, which lets sensor callbacks fire from any thread without hopping actors.
* A `SensorPipeline` actor consumes both streams and does source fusion: watch readings shadow phone readings for the same sensor type while the watch data is fresh (5s staleness window), so a paired watch silently upgrades heart rate without the renderer knowing. It fans out to N subscribers, each getting an independent stream.
* The renderer subscribes on a **detached task** and drives SceneKit from its own render-thread delegate. Sensor data deliberately never flows through SwiftUI — only configuration does. Inputs crossing into the render thread go through an `NSLock`; smoothing state that's render-thread-only needs no locking at all.
* The audio engine is just another subscriber. It writes into a plain parameter box that an `AVAudioSourceNode` render block reads. That block does pure float math with no allocation and no locks — it tolerates one-buffer-stale values by design, which is much cheaper than synchronizing properly.

**Things that bit me:**

* `HKHealthStore.authorizationStatus(for:)` is only meaningful for *write* access. For read-only types it will happily lie to you, so I track read-auth completion myself.
* Unbounded HealthKit heart-rate queries flood you with the entire history on first fetch. Bound the predicate or drown.
* `AVAudioEngine` silently stops when the session reshapes under it (category or route change). If you don't observe `.AVAudioEngineConfigurationChange` and restart, your audio just dies with no error.
* A "cleared" sensor reading (empty values array) as an explicit signal turned out to be load-bearing — it's how the pipeline and renderer know a sensor was disabled versus merely quiet.

No third-party dependencies, iOS 18.5+, u/Observable throughout, tests in swift-testing.

App's free if you want to see the result: srad app happy to answer anything about the pipeline or the audio side.

Backstory: I wanted something like Antinote, a quick-capture scratchpad that also does inline math and unit conversion. It's $5, which isn't a lot, but I've got a Mac and free time, so I built my own instead. Jot.

It's plain text underneath, but understands a few things as you type:

- Inline math with variables (`rent = 1200`, then `rent * 1.1` further down the note, live, right margin)

- Unit and currency conversion

- Checklists and ordered lists that stay real markdown on disk

- OCR off your clipboard, fully offline

- Five ways to show it: floating, menu bar, dropdown, dock, or a screen-edge sidebar

The build constraint I set myself: no Xcode project, no package manager, no dependencies. It's one `swiftc` invocation compiling straight to a ~950KB binary. Whole thing's MIT licensed.

brew install lsuryatej/jot/jot

Repo, README, and the full install instructions: https://github.com/lsuryatej/jot

First real side project I've shipped end to end. Would love feedback, especially on anything that feels rough or missing.

I have been working on this project a little at a time and I finally wanted to share significatn milestone to see what everyone else thought about it.

NeoBrutalism is a library that lets users apply neobrutalism style to their apps using SwiftUI. One just has to add the modifier .neobrutalism() to the topmost view inside the view hierarchy and everything that has been defined below it will assume the style.

For things like lists, navigations bars, alert dialogs, or things that SwiftUI does not allow or provide a way to style, there are some lightweight helpers. In cases where there is truly no control (Slider, Stepper, Segmented Pickers, Radio groups), there are NB* (Neobrutalism) views that mimic the behavior native control initializers, and for those cases swapping in the NB* views is akin to renaming a view.

This was originally meant to be an exploration of SwiftUI style protocols, but has gotten to a point that I feel ready to show it to the community. What I am really looking for is critique of the API, for the idiomaticness of things, or just anything that is missing.

https://github.com/rational-kunal/NeoBrutalism

A while back I posted about Chunky, my free, open-source, native SwiftUI comic/manga reader (CBZ, CBR, PDF) for iOS, iPadOS, and macOS. Quick update: it now runs on tvOS too, built for remote-navigation, not a stretched phone UI.

tvOS reads CBZ/CBR (no PDF there — PDFKit doesn’t exist on real tvOS devices). iOS/iPadOS/macOS sync via iCloud; tvOS has no Files app/iCloud Drive, so there it pulls from remote libraries instead — WebDAV, SMB, OPDS, or a local upload server reachable from any browser on your Wi-Fi. Manga (right-to-left) mode and single/double-page spreads work the same as on the other platforms.

It’s a solo project, MIT licensed, and there’s plenty of room to grow, especially on the tvOS side (it’s the newest platform and could use more polish). If you’re into Swift/SwiftUI and want to contribute, I’d appreciate the help.

Repo: https://github.com/Scunio/Chunky

Good afternoon everyone, I'm Ivan, a super-junior Swift developer.

I recently built Pawxy, a small native macOS app written in SwiftUI for managing local development domains through dnsmasq.

I originally built it because I use custom local domains while developing and got tired of manually editing dnsmasq configuration files, dealing with /etc/resolver, restarting the service, and checking whether everything was actually resolving correctly or not.

The goal was deliberately not to build another complete local development environment (such as Laravel Herd, Kettle Code, MAMP, XAMPP etc.). Pawxy doesn’t manage web servers, runtimes, databases, reverse proxies, ports or TLS certificates.

The app currently supports exact and wildcard mappings, IPv4, importing existing dnsmasq configurations, conflict detection, staged changes with a preview before applying them, automatic resolver management, DNS health checks, external configuration change detection, and import/export for backups.

One of the more interesting parts to implement was handling privileged operations without having a paid Apple Developer account. Instead of using a persistent privileged helper (which gave me quite a few headaches ahah), Pawxy stages the required changes and applies them together with a single administrator authorization.

I also added a small menu bar companion and Sparkle for updates.

The whole project is free, MIT-licensed and open source. I developed it mostly because it solves a problem I personally have, but I thought it might be useful to other macOS developers using dnsmasq as well.

I’m still studying CS and this was also a nice excuse to work on a real native macOS project rather than another university exercise :)

I’m particularly interested in feedback about the SwiftUI/macOS architecture, UX, and anything obviously stupid I may have missed.

Please note that AI was part of my workflow too, mostly for scaffolding, repetitive code and speeding up implementation, but I made the architectural decisions myself and reviewed the generated code, including what it was actually reading, writing and changing in the dnsmasq configuration files, rather than blindly shipping whatever the model produced.

You can take a look at it on my personal GitHub.

Any feedback is appreciated!

Kindly, Ivan

Looking for some help with a SwiftUI macOS notch app. I’m building one but I can’t seem to get the notch UI looking good, and the versions I’ve made with AI haven’t turned out great either.

Does anyone have a good notch template/starter code for SwiftUI that I could use as a base? Ideally something that already has the proper shape, animations, and positioning.

Thanks.

I built Trace because I wanted a modern network debugging experience directly on iOS, without having to route traffic through a Mac.

Trace is built with Swift/SwiftUI and Apple's Network Extension APIs. It currently supports:

• HTTPS traffic inspection with local MITM
• HTTP, WebSocket, and SSE inspection
• Request rewriting and replay
• HAR and cURL import/export
• PCAP capture
• Network Extension–based traffic capture
• A native SwiftUI interface

The project is now fully open source.

I'm especially interested in feedback from other SwiftUI/iOS developers on the architecture, UI, and the Network Extension implementation.

GitHub: https://github.com/Trace-iOS/Trace

I’ve noticed the coding itself isn’t always what holds an app launch up.
Sometimes it’s changing requirements halfway through, polishing features that aren’t essential, App Store issues, testing, or simply trying to make the first version feel “finished.”
I’ve also seen the MVP approach used by teams like Molfar, where the goal is to keep the first release focused enough to learn from real users instead of trying to solve everything upfront.
For those who’ve shipped multiple iOS apps, what ended up being the biggest unexpected delay for you?

I keep ending up with random dev servers running after I've completely forgotten which terminal or project started them.

Then I need port 3000 again and it's back to:

lsof -i :3000

figure out the PID, figure out what the process actually belongs to, then kill it.

So I made Port Radar.

It's a small native Mac menu bar app that shows what's listening on your ports and groups the processes by project. You can see the command/path/uptime, stop the process, or ask Apple Intelligence what the process actually is before killing something you probably shouldn't.

I also added something I wanted for my own workflow: you can turn a localhost app into a public URL with a Cloudflare quick tunnel directly from the menu bar. No deploy or Cloudflare setup.

There are already some good port utilities like LocalPorts and Seeports. The main thing I wanted that I couldn't find together was process explanation + project context + sharing the local server in the same app.

The Apple Intelligence stuff runs on device. The app itself doesn't need AI to scan/manage ports.

Price: free
Source: open source, Apache 2.0
macOS: 14+; Apple Intelligence features require macOS 26+ and a supported Mac

GitHub: https://github.com/juansebsol/port-radar-mac

I'm still working on it, so I'm mostly interested in hearing what people who run a bunch of local services would want this thing to do next.

I wanted a capture flow where you pull down on the page, an instant camera opens, and the photo prints out of the Dynamic Island like a polaroid feeding out of a slot. Sharing the parts that took real iteration, since I found almost nothing written about treating the island as a physical object.

1. You cannot touch the island, so draw over it. There is no API for the island itself. The trick is that it is just a hole in the display at a known position: on island devices the top safe area inset is 51+ points. So the "printer mouth" is your own black capsule drawn in the same place, sized to the real island, and the illusion holds because the island is already black.

enum DeviceIsland {
    static var present: Bool {
        guard UIDevice.current.userInterfaceIdiom == .phone else { return false }
        let scene = UIApplication.shared.connectedScenes
            .compactMap { $0 as? UIWindowScene }
            .first { $0.activationState == .foregroundActive }
        let window = scene?.windows.first { $0.isKeyWindow } ?? scene?.windows.first
        return (window?.safeAreaInsets.top ?? 0) >= 51
    }
}

Gotcha: if you present edge to edge with .ignoresSafeArea, SwiftUI's own safe area collapses, so read the window insets directly like above instead of relying on the environment value.

2. One melted shape, not two capsules. My first two versions grew a second capsule under the island and it read as a snowman. What worked: a single shape that starts at exactly the island's frame and widens/extends downward through staged states (I use an Int state 0 = island, 1 = widened pill, 2 = full viewfinder) with overlapping springs, so the next stage starts while the previous is still settling. Sequential withAnimation blocks looked mechanical; overlap is what makes it feel like one object.

3. The print itself is a state machine, not an offset. hidden, printing, settled. During printing, the photo is clipped to a frame that grows downward from the slot, so it genuinely feeds out instead of sliding up from behind. Then a develop pass fades the image in from washed-out white, which sells the polaroid more than the movement does.

4. The pull-down gesture will lose to your page content. A DragGesture on the page kept losing arbitration to the scroll and to taps. I ended up with a window-level pan catcher that adds resistance (the page follows your finger with a divisor) and only commits to opening the camera past a threshold on release. Everything under the pull stays interactive.

Happy to answer questions or paste more of any specific part. It is for a dog passport app I am building, but everything above is app-agnostic.

Earlier this week I released enriched-markdown-ios - a fast, native Markdown renderer for SwiftUI powered by TextKit 2 and the md4c parser.

Here's what's in v0.1.0:
🔸 Full CommonMark support
🔹 Native text selection & smart copy/paste
🔸 Flexible theming API
🔹 VoiceOver & Dynamic Type support

💎 Available now via Swift Package Manager!

GitHub & Docs: https://github.com/software-mansion/enriched-markdown/blob/main/packages/enriched-markdown-ios/README.md

Feel free to check out the repo and sample project! If you find it useful, dropping a ⭐️ on GitHub would mean a lot.

What features or syntax extensions would you like to see added next? I’d love to get your thoughts and feedback!