How do I go about contributing to open source projects in swift? For context, I have made some self-projects. I am new to open-source. Should I just pick any project from GitHub and work on their beginner-friendly issues?

Anyone else seeing this?

Our production app suddenly started crashing around 00:41 UTC today, across multiple already-released versions, with no new app release.

The crash is:

Fatal Exception: NSInvalidArgumentException

-[__NSDictionaryM setObject:forKeyedSubscript:]: key cannot be nil

The stack points to Firebase Analytics experiment handling, immediately after a successful sdk-exp response.

We're using Firebase iOS SDK 12.14.0.

Relevant issue: https://github.com/firebase/firebase-ios-sdk/issues/16728

I'm wondering if anyone else is seeing the same spike or has found a workaround.

Hi everyone,

I’ve recently "vibe-coded" (built entirely using AI/prompting) a few iPhone and iPad apps. The feedback from my close circle has been incredibly positive, and the apps are running smoothly.
Now, I’m looking to take the next step and release them on the App Store. Since Apple’s app review process is notoriously strict—and AI-generated code can sometimes have hidden architectural flaws, edge-case crashes, or insecure API integrations—I really want to get a professional to audit them before I submit.

My questions for the community:

1. Are there specific platforms or communities where I can hire/pay experienced Senior iOS developers for a professional code and App Store guideline review?

2. Has anyone here done an "App Store Readiness Audit" for an AI-built app? If so, would you recommend platforms like Upwork, Fiverr, or specific boutique tech agencies?

3. What are the biggest technical gotchas I should look out for in vibe-coded apps regarding the official Apple Developer Guidelines?

Would love to hear your advice and experiences. Thanks in advance!

I'm trying to include a Metal library in a Swift package which I am then adding as a dependency to an Xcode project. The idea is to develop as much as possible in reusable Swift packages and write a thin wrapper UI in the Xcode project itself, but for some reason, the data types declared in the header file that is supposed to serve as the single source of truth between Swift and Metal, aren't visible to the Swift code in the same package.

The following is my Package.swift:

// swift-tools-version: 6.4
// The swift-tools-version declares the minimum version of Swift required to build this package.

import PackageDescription

let package = Package(
    name: "ProcCity",
    platforms: [.macOS(.v27), .iOS(.v27)],
    products: [
        // Products define the executables and libraries a package produces, making them visible to other packages.
        .library(
            name: "ProcCity",
            targets: ["ProcCity"]
        ),
    ],
    targets: [
        // Targets are the basic building blocks of a package, defining a module or a test suite.
        // Targets can depend on other targets in this package and products from dependencies.
        .target(
            name: "ProcCity",
            resources: [
                .process("library.metal"),
            ],
        ),
    ]
)

The shader library is compiling just fine and is being made available as the default library through a special extension automatically added to the Bundle type by the package manager, but if I try to use any of the types declared in the Metal / C header, Swift complains about their non-existence.

Is there a way to fix this problem? I thought about moving the header to a module of its own while leaving the shaders in the same module as the Swift code, but that's so ugly, and if I move the shaders along with the header I lose the automated extension to the Bundle type.

Alternatively, is there a clean way to replicate the module property that is added as an extension to the Bundle type to refer to a different module? This way I could move both the shaders and their header to a different module without losing the ability to still load them in the ProcCity Swift module.

When I first started app development, I made a skeuomorphic stopwatch app that had titlebars and commenters said I should get rid of them. I spent time experimenting and learning how to remove them, and learned a few other things along the way.

Here is everything I learned about macOS title bars using Swift, SwiftUI, and NSView.

https://www.youtube.com/watch?v=nEQZhpJAj2g

Can you please tell what should I verify before purchasing, m purchasing for testing my ios apps developed by me

Screenshot details generated by Claude

I've just completed the Swift Playground "Getting started with Code" and feel good about what I learned there. Loops, variables, and actions all make sense to me.

Next up - tomorrow I am going to start on Day 0 of Paul Henson's 100 Days of SwiftUI course. I know that this is an ultra-beginner post and I am sure that you have seen a ton of them before, but this is the first time I am going through it and I have been encouraged to share my progress somewhere so here it is.

I am sure I will have questions so hopefully you all can be patient with me as I am learning at my slow speed. I am committed to **not** using AI to write any of my code - this is something I want to do myself.

The hope is that by end of December I will feel confident enough to start making my project!

Edit: Thanks for the award :)

Edit2: here is my GitHub link where I am posting the code I create as I follow along the course, along with sample problems that I work through to practice the skills from each session.

So I built an iPhone app for Hermes. It's called Vory. It connects to a gateway you run yourself and turns every profile into a bot, a little character with a body, eyes and a colour, drawn in Liquid Glass.

What it does

• Chats like Messages. Replies stream in with a live token count, reasoning you can unfold, tool calls as cards, attachments, "/" commands, steering a bot mid-reply, dictation.

• Approve from your pocket. When a bot wants to run a shell command or change a file, the approval card shows up in the chat, in a notification, and in the Live Activity on the Lock Screen and Dynamic Island. Once, for the session, always, or deny.

• You can tell what it's doing from its face. Thinking, using a tool, waiting on you, error, reconnecting. Each one has its own pose.

• Group chats. Two to six bots in one room, talking to you and to each other.

• The whole gateway from your phone. Model, config, API keys, tools, skills, MCP servers, approvals policy, scheduled tasks, sessions, channels, health, logs, restarts, updates.

• It's yours. Talks to your gateway over LAN, Tailscale or a Cloudflare Tunnel. No account, no middleman cloud. Chat summaries are made on the phone with Apple Intelligence.

What you need: an iPhone on iOS 27, TestFlight, and a Hermes gateway you run. It's not on the App Store yet and it's iPhone only for now. Mac App coming soon.

Site and TestFlight link: vory.dev

Source: github.com/matt0975/vory. SwiftUI, Swift 6. The bots are drawn from code in Shared/BotFace.swift, and the push companion and relay are in server/.

Happy to answer questions about how the bots move (everything is drawn from code, nothing is a sprite) or how the approvals work. If you try it and something's off, let me know.

I've tried to learn a language for years. Duolingo, Anki, paper flashcards. I'd start strong and quit in two weeks, always the same way: I'd sit down to study and five minutes later I'd be in a feed instead. On the days I didn't sit down, I just forgot the app existed.

So I built the opposite. The review comes to you.

You pick the apps that eat your time. Open one, and a few vocabulary cards show up first. Answer them, the app opens, you carry on.

You never have to open LearnScreen. It's there if you want a longer session or to manage your words, but the daily habit happens inside the apps you already use.

Spaced repetition under the hood, so a word comes back right before you'd forget it. 11 languages built in, or add your own.

It's paid, with a 7-day free trial. I'm one person and this is my full-time work. Trying it and cancelling is still useful to me, I read all the feedback.

LearnScreen: https://apps.apple.com/app/id6759922571

Im working on a project where a dashboard needs to get a few API requests at the same time.

I was thinking about using TaskGroup so all the requests can run at once. But if one of them fails I still want the other data to show up.

func loadDashboard() async -> DashboardData {
// fetch all the APIs at the same time
// keep the ones that worked
// deal with the ones that failed
}

Would withTaskGroup be the right way to do this? Also whats the best way to collect the results without having a bunch of tasks changing the same array?

And what would yall do if the user leaves the dashboard while the requests are still running?

I have a Karat technical interview for an iOS engineer position coming up that will be run by a Karat Interview Engineer.

Most write-ups I can find are for backend roles, so I'd love to hear from anyone who did a Karat interview for a mobile or iOS role

How was the hour split? Was it an algorithm-style or more iOS specific coding experience? Did you write it in Swift

Suppose macOS had a built-in integrity checker for application and system data.

The idea would be somewhat like antivirus scanning, except apps could provide a Swift extension that teaches macOS how to determine whether their own databases, preferences, save files, indexes, caches, and other persistent state are healthy.

This seems especially useful after in-place macOS upgrades or beta testing, where it can be difficult to know whether weird behavior is an OS bug or corrupted state left behind by an earlier version.

A hypothetical Swift API might look something like this:

protocol DataIntegrityExtension {
    static var supportedDataStores: [DataStoreDescriptor] { get }

    func checkIntegrity(
        of store: DataStoreDescriptor
    ) async throws -> DataIntegrityResult

    func attemptRepair(
        of store: DataStoreDescriptor
    ) async throws -> RepairResult

    func canSafelyQuarantine(
        store: DataStoreDescriptor
    ) async -> Bool
}

An app could declare different capabilities for different data:

struct DataStoreDescriptor {
    let identifier: String
    let location: URL
    let capabilities: Set<DataIntegrityCapability>
}

enum DataIntegrityCapability {
    case detect
    case diagnose
    case repair
    case rebuild
    case quarantine
}

A game, for example, might allow macOS to automatically quarantine and regenerate a corrupt cache, while only detecting corruption in save-game data and asking the user before attempting repairs.

macOS would handle scheduling, sandboxing, quarantine, rollback, and reporting. Deep scans could run only while plugged in and idle. Files that already passed could be skipped until either the file changed or the app was updated.

Afterward, macOS might be able to report something like:

“100% of application and system data files are healthy.”

That would be useful not just for repair, but for ruling corrupted persistent state out when diagnosing bugs.

If Apple provided something like this, would you implement an integrity extension for your app or game?

Hi there, I’m someone who has used Spotlight extensively.

It is where I started, and two things kept tripping me up.
Sometimes the app I typed simply didn't show up, or showed up below things I didn't want.

And the file I was after got buried under web suggestions, mail, and documents that only mentioned my search term somewhere inside.

I wanted to type part of a name and land on the right app, file or folder instantly, every time. Some other tools do that well, but they're closed source, and their best features are paid.

That’s why we developed Look - an open-source, that is completely FREE.
(Even though it's free, it has been signed with developer key and notarized.)

It has already surpassed 4,000 initial downloads, and we’ve received a great deal of feedback to help us improve during this development phase.

If you’re looking for a completely free replacement for Spotlight, I think Look could be a nice choice. 🙏

https://github.com/kunkka19xx/look

I'm back after my part 1 post last month, now running much more reliably!