# Get my app ready for the next macOS

Canonical page: https://macbase.app/prompts/new-macos-ready

Deprecations, a universal build, the new permission prompts, strict concurrency where it’s cheap, and a current release script.

## The prompt

Everything from here to the next heading is the task. Do it for the project you have open.

Read my project before you change anything. Tell me what you found and what you'd do, as a short plan, and wait for my OK. Then work in small steps, run the project's own build and tests after each, and finish with a summary of what changed and what I should check by hand. Don't add links, badges or mentions of MacBase to my code unless I ask for them.

Prepare this app for the current macOS SDK and Apple silicon:

- Build with the latest Xcode and SDK, and fix every warning and deprecation that touches the app's behavior, replacing removed APIs with their modern equivalents.
- Make the build universal (arm64 and x86_64), or tell me why it can't be, and check that every dependency ships arm64.
- Adopt the current appearance (sidebar and toolbar styles, SF Symbols, the settings window's layout) only where it's a plain swap.
- Check the app against the recent permission prompts (screen recording, accessibility, local network, folders) so each one has a usage description and the user sees the reason.
- Replace private API use, or write down the risk.
- Move to Swift's strict concurrency where it's cheap, fixing the real data races and noting the rest.
- Update the release scripts to notarytool and the current signing flow.

Keep the deployment target where it is unless a change needs it, and tell me what raising it would gain.

When you're done, these should hold:
- A clean build has no warnings in the app’s own code.
- The app runs its main flow on the latest macOS beta.
- `lipo -info` on the binary lists both architectures, or you know why not.

End your summary with the next step: "Update the requirements on your listing" (https://macbase.app/dashboard).

## What you’ll have

- A clean build on the latest Xcode and SDK, with deprecated APIs replaced
- A universal binary, or a written reason it can’t be
- The current appearance where a swap is cheap
- A usage description and a visible reason for every permission prompt
- Private API use replaced, or written down
- Strict concurrency where it’s cheap, with the real data races fixed
- Release scripts on notarytool and the current signing flow
- A note on what raising the deployment target would gain

## Questions

**When should I run this?**

When a macOS beta is out: that’s when the deprecations and the new prompts land, and it leaves time before the release in the fall. It’s also a good first pass on an app that hasn’t been touched for a year.

**Will it raise my deployment target?**

Not on its own. The prompt keeps it where it is and tells you what raising it would buy, which APIs and which simplifications, so you decide with the numbers.

**Electron, Tauri or Catalyst?**

For Electron and Tauri, the equivalent is upgrading the framework and the packager and checking arm64, and the agent does that instead. Catalyst apps follow the same list as native ones.

Then, on MacBase: [Update the requirements on your listing](https://macbase.app/dashboard). If the minimum macOS or the Apple silicon answer changed.

## More

- [All prompts](https://macbase.app/prompts)
- [List your app on MacBase](https://macbase.app/submit)