The Complete MacOS Developer Course - Apps for the Desktop!

Kick off your macOS development journey by building a to-do list app with a text field, a table view, and core data, while noting mac-specific differences from iOS.

Sketch the app design on paper to plan features, then build a Mac to-do list with a two-column table and an add-to-do item form, using Storyboard, Swift, and Core Data.

Learn to build a macOS to-do app visually in a storyboard, adding a two-column table, label, text field, checkbox, and add button, and explore table view structure and basic layout.

New to do item saved in core data by wiring a text field, an important checkbox, and an add button, using the persistent container context to create the item entity.

Create a to do item from the text field and set its important flag. Save the Core Data context for Chordata via the app delegate and reset the text field.

Fetches to-do items from Core Data via a managed object context and fetch request, stores them in a class array, and updates the table view as items change.

Populate a macOS table view from a to-do items array by wiring the view controller as data source and delegate, defining rows and cells, and reloading data.

Populate a macOS table view with NSTableCellView by setting storyboard headers and column identifiers, and display either the to-do item name or an important check mark.

Learn to add a bottom-right delete button that appears when an item is selected, and wire it with outlets and actions to delete via the table view and core data.

Finish strong as you gain confidence in macOS vs iOS programming, master mac-specific concepts in Xcode with view controllers, storyboards, and table views, and preview a Mac-only to-do list project.

design and build a macOS status bar app exclusive to Mac programming that sits in the top menu bar and turns plain URLs into clickable links using HTML.

Demonstrates solving the url linking problem by sketching a macOS app called Link it that makes copied URLs clickable with a status bar icon offering link and quick button options.

Add a status bar item in the app delegate's application did finish launching using NSStatusBar and NSStatusItem, with a menu for link it and quit actions.

Learn to add a macOS status bar icon by selecting and downloading a black 32px PNG from Flat Icon, respecting attribution, then dragging into assets and assigning a template image.

Learn to work with the pasteboard by inspecting clipboard items and types, printing pasteboard contents, and converting copied URLs into clickable links using the Link It button.

Identify the public utf eight plain text on the pasteboard and extract the url. Then print the url and prepare to re-add a clickable link in the next step.

Explore how to clear and repopulate the macOS pasteboard, turning copied text into clickable links by using NS pasteboard, set string, and public HTML or UTF-8 text formats.

Check and fix url prefixes by adding https when missing, normalize to actual url, and publish both html and plain text pasteboard types to create clickable links across apps.

Learn how to export your macOS app using product archives, generate a macOS app file, and share a standalone .app that others can install.

Explore building macOS apps with practical tips on status bar items, menu actions, app quitting, and icon integration, plus exporting and using the pasteboard to streamline workflows.

Build the biggest app of the course—a podcast player—learning Mac principles like split view controllers and a custom table view, while displaying audio clips from an RSS feed.

Sketching guides macOS app development, turning a podcast prototype into a clear plan with a split view controller, custom table view cells, and a web view for HTML episode descriptions.

Implement a vertical split view controller to manage podcasts, with a podcast list, table view, text field, and add button in storyboard.

Connects a text field and button to fetch podcast data, then parses iTunes RSS XML to populate a podcast list and episode details.

Learn to fetch podcast XML via URLSession data task from a text field, handle completion and errors, and parse metadata with a parser class to obtain the title and image.

Integrate swxmlhash to parse xml data from an rss feed, navigate rss, channel, and title, and print the parsed podcast title while handling optionals for robust core data storage.

Parse podcast metadata from XML, design a core data model with a podcast entity including title, image URL, and RSS URL, and enable persistence for favorites in a table view.

Create and save a podcast entity in Core Data using a context, assign the RSS URL, image URL, and title, then fetch and sort podcasts by title for display.

connect the storyboard table view to the view controller, implement the table view data source and delegate to display podcasts from Chordata, and refresh the table on the main thread.

Validate data integrity in core data by checking for existing podcasts with a fetch request and a predicate on the RSS URL, returning a boolean to prevent duplicates.

Design a podcast details view in a split view controller using storyboard, adding a bold title label, image, and delete and play/pause buttons with an episodes table.

Learn to pass data between macOS view controllers using a split view controller, storyboards, and outlets, with live updates to episode details when a podcast is selected.

Load podcast images from URLs, delete podcasts with Core Data, and update episodes with custom table view cells across the split view.

Learn to implement a get episodes function that parses podcast XML into an array of episode objects. Define an episode class with title, publication date, HTML description, and audio URL.

Navigate RSS XML to extract episode data by looping through channel items, creating episode objects with title, description, audio URL, and pub date using a Swift date formatter.

Learn to fetch podcast episodes from XML, display them in a table view, and play audio with AVPlayer when an episode is selected.

Enhance the macOS app by enabling a play/pause button for episodes, managing the audio player state, and resetting when switching episodes, while designing custom table cells with a web view.

Create a macOS custom table cell view called episode cell, connect title and pub date labels and a description web view, and format dates while adjusting the row height.

Practice polishing a macOS podcast app by testing multiple feeds, refining audio URL parsing to enclosure tags, and ensuring playback, UI updates, and delete controls behave correctly.

Recap how we built a fully functioning macOS podcast player using split view controllers, custom table cells and web views, with audio streaming and parser insights.

Build a command line weather tool that runs in the terminal, fetches the current temperature via Yahoo's API, and demonstrates how to install and run a Mac app.

Sketch a macOS command line weather tool that takes input like 'weather tokyo, japan' and outputs 'temp: fifty eight degrees fahrenheit' via Yahoo's weather API, implemented in Swift in Xcode.

Explore building a simple command line tool in Xcode, starting from a single main.swift file, and learn to pass and parse arguments, run in terminal, and test with schemes.

Explore fetching weather data from Yahoo Weather API with Swift, using URLSession data tasks to retrieve location-based temperatures in JSON format.

Use a while loop to wait for the Yahoo weather API response, add finished and api launched flags to prevent repeated calls, and plan to parse the JSON for temperature.

Learn to parse weather json with SwiftyJSON to extract the current temperature by traversing query, results, channel, item, and condition, then print the value.

Extract a user-specified location from command line arguments and construct a URL with proper percent-encoding for spaces and commas. Then fetch and display the temperature, handling encoding or URL errors.

Polish the macOS app by removing unnecessary print statements, test the weather command line tool, and archive and install it to /usr/local/bin for global use with basic error handling.

Explore command line tools with Swift to build and run programs from the terminal, install the toolkit on your computer, and experiment with weather APIs and other command line projects.

Test the Touch Bar simulator and implement Touch Bar support in a macOS app using Xcode 8.1 and macOS 10.12, wiring a color picker via storyboard and a window controller.

Develop an Instagram-like Twitter image viewer called Tweet Graham using collection views, CocoaPods, and user defaults, and connect to the Twitter API with OS authentication.

Create a macOS app with a login that launches the default browser for Twitter authorization, a grid of tweet images, and tweet details opened in a browser.

Log in with Twitter to access the user's home feed, extract images, and display them in a collection view, using OAuth with OS Swift and CocoaPods.

Integrate the oos swift code into your macOS app with CocoaPods, simplifying the OAuth flow. Install via a pod file to create a workspace and manage dependencies.

Learn to integrate OAuthSwift with CocoaPods, implement OS 1.0 Twitter authentication, manage consumer keys and access tokens, and configure URL schemes to return authorization to the app.

Explore the Twitter API, authenticate with OAuth, and make REST API calls to fetch followers and the home timeline, then parse JSON to extract tweets and media.

Identify tweets with images by inspecting the media array in tweet entities, enable tweet_mode extended in API calls, and parse the JSON with SwiftyJSON to extract image URLs for display.

Learn to extract images from tweets by parsing JSON with SwiftyJSON, iterating through tweets and media, building an image URLs array, and preparing media for display in a collection view.

Apply storyboard layout to display the Tweet Gram interface with the app name, a login/logout button, and a collection view; connect outlets and actions, configure constraints, and trigger login authorization.

Save the OAuth token and token secret to user defaults after login, then check at app launch to auto-login and show the log out option.

Implement login and logout logic by toggling the login button to logout, storing and clearing tokens in user defaults, and refreshing tweets on app launch.

Discover how to use collection views to display a grid of items, configure a flow layout with item size, insets, and spacing, and wire up data source and delegate.

Download images from tweets using the kingfisher library with cocoaPods, caching in an image view and loading into a collection view after fetching tweet image URLs.

Enhance the tweet gallery macOS app by adjusting image scaling, increasing tweets to 200, resizing images, enabling selectable collection view items, and opening tweets in a browser via expanded URLs.

Polish the app by refining sign-in and logout to clear data and refresh the collection view, and fix tweet image display by handling retweeted status and extended entities.

Explore APIs by turning a Twitter feed into an Instagram feed and other web integrations, and learn to integrate cocoa pods and collection fuse for efficient macOS apps.

Learn to build a Slack-like chat app by setting up a backend with passes, creating a login, current account, and channels, and managing windows with view controller switching and pop-ups.

Explore building a Slack-like macOS app with login and sign-up, profile upload, channel-based chat, and enter-to-send messaging, plus dynamic channel creation and macOS app navigation.

Explore backend options for macOS apps, why Firebase doesn’t work well for macOS, and how pass open source provides a self-hosted alternative that avoids vendor shutdown risk.

Set up a parse server backend and deploy it with Heroku, choosing between local or hosted hosting, and configure app id, master key, and MongoDB as the data store.

Set up and test a Parse server on Heroku, create a game score object via curl, customize the app id and server URL, and verify it in the Parse dashboard.

Set up and use Parse Dashboard to inspect and manage your app's database locally, install node and npm, launch the dashboard, and perform simple create and delete operations.

Begin building a macOS app by launching Xcode, creating a Swift project, and designing a login screen with email and password fields, a login button, and a create account option.

Master how a macOS window controller moves between view controllers inside one window, wiring a main window controller to a create account view controller via a storyboard identifier.

Create an account screen with name, email, password fields and image upload, lay out using auto layout in storyboard, and toggle to the login view controller.

Install the Parse SDK with CocoaPods, open the Xcode workspace, configure the server URL in AppDelegate, and initialize the SDK to enable login and account creation.

Create a macOS user with the Pass SDK by wiring name, email, and password fields, using a secure text field, sign up in background, and set name property from input.

Implement an open panel to let users choose a single image file from their file system and display it in the profile pic image view.

enable profile picture upload during account creation by converting image to jpeg data, wrapping it as a pdf file, and saving it in the background before attaching to the user.

Connect the login page to authenticate users with email and password, wiring storyboard outlets. Handle success and errors and prepare the transition to the main chat page.

Implement a macOS chat split view by creating a split view controller with a left channel menu and right chat area, and navigate to chat on login or account creation.

Design the left split view to show the user’s profile image, name, and logout button, then load and download the current user profile picture in the channels view controller.

Master managing window controllers in a macOS app by adding a channel add button, presenting a second window, and wiring storyboard connections to support multiple windows and channel creation.

Design and implement an add channel flow: build a UI with title and description fields and a create button, create a Channel PFObject, save in background, then close on success.

Populate a macOS table view with chat channels by wiring the storyboard to code, fetching channels from a parse query, and displaying titles sorted by title with hash-tag prefix.

Design a chat room with channel name, description, and a table view of messages, plus a text field and send button, then connect to the chat view controller.

Pass the selected channel from the channels view controller to the chat view controller in a split view, then update the title, description, and placeholder.

Create a new chat object with the message, current user, and channel, leveraging the created at timestamp, then save in background and clear input for display in the chat table.

Fetch chats for selected channel via a query, order by created at, and display them in a table view; wire up data source and delegate, and reload data after fetching.

Learn to style chat cells in a macOS app by building a custom table cell with a profile image, name, date, and multiline message using autolayout constraints.

Populate chat cells with each user’s name, profile picture, and formatted timestamp by including the user in the query and applying a date formatter.

Implement automatic bottom scrolling for chat updates on load and new messages, and enable sending on enter via text field delegates in a macOS desktop app.

Polish the macOS app by adding a clear chat function that resets channel, chat data, and UI elements, and stabilize the UI with fixed sizing and a delayed initial resize.

Implement a periodic timer in the chat view controller to poll for new chats, start on channel update, invalidate on logout, and update UI only when chat counts change.

set up a macOS app server with PA server, install the pass sdk, and explore open-source deployment with Heroku while mastering macOS window management and cross-window view controller switching.

Learn to implement handoff by building a movie review shell that starts on iOS and resumes on Mac, with an iOS device and Apple developer account.

Explore how to implement handoff between an iOS and macOS movie review app, transferring title, review, and rating across two Xcode projects.

Design the user interface with text fields, a text view, a rating label, and a slider; connect outlets and a slider-changed action to update the rating to one decimal.

Explore macOS handoff with user activity by building a movie review app, syncing with iOS via iCloud and Bluetooth, and passing title, review, and rating.

Set up cross-app handoff by declaring a shared user activity type in both iOS and macOS apps, then run on devices with the same development team and iCloud accounts.

Explore how to pass and sync data between iOS and macOS using user activity in a handoff workflow, including crafting the user info dictionary and toggling needs save for updates.

Restore user activity state by accessing the window and its view controller, then fill title, review, rating from a user info dictionary into macOS text field, slider, and text view.

Conclude by showcasing handoff between iOS and Mac apps, demonstrating cross‑platform integration to enhance user experience and merge iOS and Mac programming skills.

Explore creating macOS app menus, handling keyboard and mouse events, and building a simple game to apply interactive input techniques.

Demonstrates building a simple macOS game in Xcode using the game template, with Jet Woman gameplay, keyboard inputs to stay afloat, and basic menu and high score tracking.

Take a SpriteKit tour in Xcode’s game template, exploring the game scene, NSMenuItem menu, and how the app delegate wires reset high score and close actions.

Set up a game scene in Xcode, size it 400 by 700, add score and high-score labels, and configure a Jet Woman sprite with bounding rectangle and dynamic physics.

Implement a jump mechanic by applying a vertical impulse to the Jet Woman sprite when the spacebar is pressed, using a physics body and gravity to keep her in play.

Create a physics contact delegate to detect collisions, implement didBegin contact, and use category bitmasks to identify Jet Woman and spikes, triggering game over and printing collision events.

Implement a start button to begin and reset the game, detect clicks via nodes at point, unpin Jet Woman to start falling, and restore the start button after use.

Implement a start game function to position Jet Woman in the center, reset the score to zero, and update the on-screen score label when the player jumps.

Develop a macOS game keyboard mechanic by mapping keys to actions via key codes, randomly selecting and displaying the next required key, and triggering a jump when pressed.

Develop and refine a macOS game by implementing a high score system with user defaults, updating a high score label, and resetting game state after collisions to adjust difficulty.

Learn to enhance a macOS game by adding images and assets, integrating Jet Woman and a play button, and using SpriteKit emitters and alpha-driven crash fire for dynamic visuals.

Add a click input option by introducing a click entry with a negative one key code, handle mouse down, convert codes to unsigned 16, and update score and high score.

Finish your macOS game by implementing menu items, a reset high score action, and keyboard and mouse events, then reuse the scene in Xcode to bring the art to life.