I Built My First macOS App. Here's What Nobody Told Me.
I spent the last five years building websites and web applications, so when I decided to build a native macOS application for the first time, I thought the experience would be pretty similar.
It wasn’t.
If you’re not familiar with the Apple ecosystem, Apple uses its own language and framework, Swift and SwiftUI, for building native macOS and iOS applications. Of course, if you come from a JavaScript or React background, you can use something like Tauri or Electron to build macOS apps.
But there’s something different about using Swift and SwiftUI. If you want that rich, native macOS experience, you’re almost always going to get it by using Apple’s own language and framework.
The reason I started building a native macOS app is simple: I’ve been learning guitar for the past year and a half, and I was using a spreadsheet to track my progress.
At some point, the spreadsheet was no longer enough. I wanted something for myself, but also something that could potentially become a paid product.
I thought learning a new programming language would be the hardest part, but it wasn’t. SwiftUI borrows ideas from languages and frameworks I already knew.
If you come from a TypeScript, Python, or Rust background, Swift feels quite friendly. There are syntactic differences, but the fundamentals are familiar.
And if you’ve built with React or Next.js, the component-based thinking translates very well to SwiftUI.
I spent about three to five hours going through 100 Days of SwiftUI by Paul Hudson, which is a great resource. I covered the first five days of the curriculum and got the hang of the language.
Then I got bored and went straight into building a macOS application with SwiftUI.
SwiftUI is to Swift what React is to JavaScript.
Now let’s talk about Xcode.
I expected Xcode to be terrifying because the IDE itself is over 12 GB, and there’s a lot of tension around building in the Apple ecosystem. People always talk about how difficult Apple makes things, how App Store approvals are gated, and all of that.
But Xcode is actually quite appreciable. It may be the most user-friendly IDE I have ever used.
The UX reduces how often you need to go to the terminal. It is very UI- and click-friendly. When I was building with Xcode, I didn’t even think about the terminal.
You click a button, your code builds, and the app opens. In VS Code, you usually open a terminal and type commands. npm install this, npm install that. I built an entire application in Xcode without looking at the terminal.
Building took less than 10 seconds, which was impressive. Coming from the JavaScript ecosystem, building a Next.js app can take somewhere between a minute or two.
One thing I loved seeing was automation. My agent could run its own automation through Xcode. It could run functional tests for features it had just built without me interfering, which is something I had not experienced often.
Xcode is pretty great, and it’s worth the 12 GB size.
The moment it all felt real was after scaffolding and building. A Mac window opened like any other normal Mac application, and it took me less than five minutes to get there. It was amazing.
My first disappointment was the Apple developer account. I had finished working on my MVP and wanted to distribute the app, then realised I needed to pay $99 to do it properly.
That is unlike anything I have seen before. If you want to build a web app, you write your code and import the codebase into Vercel or Fly or whatever cloud provider you want to use. It’s almost always free to start, and the paid ones are usually pay-as-you-go.
But Apple tells you to pay $99 for a developer ID before you can distribute your app properly.
When I went through the website, I understood some of the concern. They are trying to prevent scammers from shipping malicious applications.
But gating direct distribution and macOS App Store distribution behind a $99 subscription does not make sense to me. There are better ways to detect fraud than charging $99. In fact, using money as the barrier feels like one of the easiest ways for people with bad intentions to still ship malicious code.
Since I have not paid the $99 fee, I’m distributing my app as a zip, and that comes with its own issues. When someone tries to install the app, macOS nudges them to move it to the bin because it cannot verify that the app is free of malicious code.
I’m still learning the Apple distribution ecosystem, and I’ll share more on this channel as I figure it out.
A second surprise was that AI becomes dramatically more useful once you understand the problem and have the basics of Swift.
If you’ve been building software for some time and want to get into native Apple development, I wouldn’t recommend spending hundreds of hours learning Swift or SwiftUI before building anything.
I would learn the basics of Swift first. It can take an hour or two to go over the fundamentals, then you can quickly learn things like:
- how to scaffold a new SwiftUI project
- how to organise your project structure
- how to set up your project for agents to use
- how to go straight into building
The barrier is mostly syntax and specific knowledge of the Apple ecosystem, and you get that knowledge by trying to build.
Another surprise was Apple’s design philosophy. The biggest thing I noticed is that the operating system nudges you towards good software. It’s like you have very few excuses to build something bad.
People expect macOS applications to be beautiful, so you naturally feel pressure to make them beautiful. You don’t have to invent every interaction. The platform already has its own opinions, so you are not starting from zero.
Programming languages matter far less than people think.
The hardest part of building software today is not learning syntax. Once you’ve built software professionally for several years, learning a new language is not the main challenge.
Most modern languages share the same core ideas around variables, functions, types, and asynchronous code. You are mostly learning a new way to express concepts you already understand.
With macOS, you start noticing native controls, accessibility, keyboard shortcuts, consistency, and menus. Menus make you appreciate macOS more.
There is a lot of intention behind the macOS ecosystem. It is hard to get the user experience completely wrong, even without a lot of design experience.
It is very design-friendly for anyone with a little taste. macOS is arguably the best operating system for app developers.
My biggest takeaway is this: if you want to start building native macOS applications, don’t try to learn all of Swift first.
Check out 100 Days of SwiftUI. It’s a really good free resource, and you only need a couple of hours to learn the basics:
- what it means to create a project
- how to start a project
- how to build a project
- how to let AI teach you
- how to build something you actually need
You will learn much more from building an app you are genuinely interested in using than from watching thousands of tutorials or courses on SwiftUI.
Thanks for watching. If you enjoy this content, I would appreciate it if you checked out my newsletter and subscribed.
Related: PracticeOS