If you search for "install Java on Mac," you'll find a confusing number of vendors, version numbers, and installation methods. To make it easy, I'll cut through the confusion and show you a recommended Java installation path that takes about five minutes.

Here's my recommendation: Install Java 25 using Homebrew with the Eclipse Temurin distribution. Java 25 is the current LTS (Long-Term Support) release and your best choice unless your work team or university course uses an older version. With Homebrew, one terminal command accommodates the entire installation. The Temurin distribution is free, certified, and unencumbered by Oracle's licensing restrictions.

Now I’ll walk you through the process.

Table of Contents

1. What You Need Before You Begin

2. How to Check if Java Is Already Installed

3. Why Eclipse Temurin and Why Not Oracle

4. How to Install Java with Homebrew

5. How to Verify the Installation

6. How to Set JAVA_HOME for Build Tools

7. How to Troubleshoot Common Problems

8. Alternative Installation Methods

9. What's Next

What You Need Before You Begin

With this recommended path, you only need two things before you install Java: a terminal application and the Homebrew package manager.

Terminal

Terminal is the built-in Mac terminal application. If you don’t know, you can learn how to open Terminal here. You'll use it to run the installation commands.

Homebrew

Homebrew is a package manager you can use to install software programs for the command line. Check if you already have it like this:

$ brew --version
Homebrew 5.0.11

If you see a version number, you're ready. If you see zsh: command not found: brew you need to install Homebrew first. Follow the instructions at Install Homebrew.

How to Check if Java Is Already Installed

Run this command to check for an existing Java installation:

$ java -version

You'll see one of two results.

If Java is installed, you'll see output like this:

openjdk version "25.0.1" 2025-10-21 LTS
OpenJDK Runtime Environment Temurin-25.0.1+8 (build 25.0.1+8-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.1+8 (build 25.0.1+8-LTS, mixed mode)

If the version number shows 25, you already have the latest Java and you can stop here.

If Java is not installed, you'll see a message, "The operation couldn't be completed. Unable to locate a Java Runtime." You'll need to install Java as described below.

If you previously installed Java but see this dialog, something is wrong with your installation. See Unable to Locate a Java Runtime for troubleshooting. For detailed guidance on Java version output, see Check Java Version on Mac.

Why Eclipse Temurin and Why Not Oracle

If you search for Java downloads, you'll encounter several potentially confusing terms. Here's what they mean.

JDK stands for Java Development Kit. It contains the compiler, runtime, and developer tools you need to build and run Java applications. Vendors used to offer a JRE (Java Runtime Environment) for non-developers, but now the JDK does everything.

OpenJDK is the official open-source implementation of Java. All major Java vendors build from this same source code, so the core functionality is identical across vendors.

Eclipse Temurin is the distribution many developers recommend. It comes from the Adoptium project and is backed by IBM, Microsoft, Red Hat, and Google, among others. It's completely free for any use, including commercial production. Temurin is TCK-certified, meaning it passes Oracle's official compatibility tests (over 139,000 of them). You can trust that your Java code will run correctly.

Why not Oracle JDK? Oracle changed its licensing in January 2023. The new model charges per employee across the entire organization, not per Java user. A 500-person company would pay $90,000 per year. Oracle actively audits for compliance.

Temurin is functionally identical to Oracle JDK and is free to use under its open‑source license, avoiding Oracle’s Java subscription fees.

If you deploy to AWS, Amazon Corretto is another good free option. If you need Java 8 for legacy code, Azul Zulu provides well-supported builds. For a comparison of Java distributions, see Install JDK on Mac.

How to Install Java with Homebrew

Homebrew offers two ways to install Java: the cask method and the formula method. The cask method is easier because it installs the vendor's macOS package to the standard system location. Apple's macOS discovers it automatically with no extra configuration.

Run these two commands:

$ brew update
$ brew install --cask temurin@25

The first command refreshes Homebrew's package list. The second downloads and installs Eclipse Temurin JDK 25.

Homebrew places the JDK at /Library/Java/JavaVirtualMachines/temurin-25.jdk/. This is the standard macOS location for Java installations. Apple's macOS includes a Java launcher at /usr/bin/java that automatically searches this directory. You don't need to configure your PATH.

Homebrew also detects your Mac's chip architecture automatically. You'll get the correct native build whether you have an Apple Silicon or Intel Mac.

For more details about the Homebrew installation process, including the alternative formula method and troubleshooting, see Brew Install Java, Cask Method.

How to Verify the Installation

After installation, open a new Terminal window. Existing windows may not detect the new installation.

Check the Java version:

$ java -version
openjdk version "25.0.1" 2025-10-21 LTS
OpenJDK Runtime Environment Temurin-25.0.1+8 (build 25.0.1+8-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.1+8 (build 25.0.1+8-LTS, mixed mode)

This confirms three things: the version number (25.0.1), the distribution (Temurin), and that the 64-Bit Server VM is active.

Check the compiler:

$ javac -version
javac 25.0.1

List all installed JDKs:

$ /usr/libexec/java_home -V
Matching Java Virtual Machines (1):
    25.0.1 (arm64) "Eclipse Adoptium" - "OpenJDK 25.0.1" /Library/Java/JavaVirtualMachines/temurin-25.jdk/Contents/Home

If all three commands produce the expected output, Java is installed and working.

How to Set JAVA_HOME for Build Tools

For most users, Java works immediately after installation. The java and javac commands are available with no additional setup.

However, some build tools require the JAVA_HOME environment variable. Apache Maven, Gradle, and Android SDK all look for it. If you see errors mentioning "JAVA_HOME is not set," you need this step.

If you only run Java applications or use IntelliJ IDEA (which manages Java paths internally), you can skip this section.

Add this line to your ~/.zprofile file:

export JAVA_HOME=$(/usr/libexec/java_home)

This uses Apple's java_home utility to find the installed JDK automatically. After saving the file, you'll need to run source ~/.zprofile or close and reopen your terminal. Verify it works:

\( echo \)JAVA_HOME
/Library/Java/JavaVirtualMachines/temurin-25.jdk/Contents/Home

For complete configuration instructions, see Set JAVA_HOME on Mac.

How to Troubleshoot Common Problems

"Unable to locate a Java Runtime" message keeps appearing. Run java -version to verify Java is installed. If you just installed Java, see Unable to Locate a Java Runtime.

Wrong Java version appears. You have multiple JDKs installed and macOS selected a different one. Run /usr/libexec/java_home -V to list all installed versions. See Set JAVA_HOME on Mac to point to the version you want.

Alternative Installation Methods

Homebrew is the fastest path, but other options exist.

1. Manual download: You can download the .pkg installer directly from adoptium.net and double-click to install. This is a good choice if you don't use Homebrew. See Install Java on Mac for detailed instructions.

2. Homebrew formula. The command brew install openjdk@25 installs a Homebrew-managed build. This approach requires manual symlink configuration before macOS can discover it. See Brew Install Java, Formula Method for details.

3. Version managers. Tools like SDKMAN and mise can install and switch between multiple Java versions per project. If you work on codebases that require different Java versions, see Java Version Managers.

What's Next

You now have Java 25 installed on your Mac. You've verified it works and configured JAVA_HOME for build tools. You're ready to compile and run Java applications.

If your team or university course requires Java 21 instead, see Install Java 21 on Mac. If you need to remove Java, see Uninstall Java on Mac.

This article is based on my guides that offer additional details about how to install Java on Mac and choose the latest Java version.

By the end, you'll have a fully functional MCP server integrated with Claude Desktop in about 10 minutes. This solution applies to any MCP setup facing this standard error after Python upgrades.

Table of Contents

1. What Causes the ENOENT Error?

2. Prerequisites

3. How to Diagnose Your Broken Virtual Environment

4. How to Completely Rebuild Your Virtual Environment

5. How to Install MCP Server Dependencies

6. How to Locate Your Server Files

7. How to Test Your Server Setup

8. How to Configure Claude Desktop

9. How to Restart Claude Desktop and Test Integration

10. Understanding MCP Server Capabilities

11. Alternative Installation Methods

    • Method 1: Direct Package Installation

    • Method 2: Using UV Package Manager

12. How to Prevent Future ENOENT Errors

13. Troubleshooting Common Issues

14. Conclusion

What Causes the ENOENT Error?

The ENOENT (Error NO ENTry) error means your system can’t locate the Python executable at the specified path. This occurs when the file is missing or inaccessible.

On macOS, this typically happens when:

• You've upgraded Python through Homebrew

• The brew cleanup command removed old Python versions

• Your virtual environment's symlinks now point to non-existent files

What makes this particularly challenging is that your virtual environment folder still exists – it looks fine from the outside, but the Python executable inside is completely broken.

When MCP servers try to spawn Python processes using these broken paths, you get the dreaded ENOENT error. This affects any Python-based MCP server, whether you're building custom tools, connecting to APIs, or working with file systems.

Prerequisites

To follow this tutorial, you'll need:

• macOS with Homebrew installed

• Python 3.10 or higher

• An MCP server repository cloned locally

• Claude Desktop installed

• Basic familiarity with terminal commands and Python virtual environments

If you haven't cloned an MCP server repository yet, you can start with any open-source MCP server. For this tutorial, I'll use generic examples that work with any MCP setup:

git clone https://github.com/your-username/your-mcp-server.git
cd your-mcp-server

How to Diagnose Your Broken Virtual Environment

First, you need to confirm that your virtual environment is actually the problem. Open your terminal and navigate to your MCP directory:

cd /path/to/your/mcp-server

Now check if your Python executable exists:

ls -la venv/bin/python*

If you see broken symlinks or get "No such file or directory" errors, you've found your problem. You might see output like:

lrwxr-xr-x  1 username  staff  16 Jan  1 12:00 python -> /usr/local/bin/python3.11
lrwxr-xr-x  1 username  staff  16 Jan  1 12:00 python3 -> /usr/local/bin/python3.11

But when you try to run these Python executables:

./venv/bin/python --version

You'll get an error because the target files no longer exist. This confirms your virtual environment is broken and needs rebuilding.

How to Completely Rebuild Your Virtual Environment

The most reliable solution is to rebuild your virtual environment from scratch. This ensures all paths and dependencies are correctly configured for your current Python installation.

Here's your step-by-step rebuild process:

# Make sure you're in the MCP server directory
cd /path/to/your/mcp-server

# Remove the corrupted virtual environment
rm -rf venv

# Create a fresh virtual environment
python3 -m venv venv

# Activate the new environment
source venv/bin/activate

You should now see (venv) in your terminal prompt, indicating the virtual environment is active. This prefix confirms you're working within the isolated Python environment.

How to Install MCP Server Dependencies

With your fresh virtual environment active, install the MCP server and its dependencies. The exact installation command depends on your specific MCP server, but typically follows one of these patterns:

# For package-based installation
pip install -e .

# Or for requirements file
pip install -r requirements.txt

# Or for specific MCP frameworks
pip install fastmcp

Common MCP server dependencies include:

• FastMCP for the server framework

• JSON-RPC libraries for communication protocols

• HTTP clients for API integrations

• File system utilities for local operations

The installation process displays all packages as they install. Don't worry if you see deprecation warnings – they're normal and won't affect functionality.

How to Locate Your Server Files

After installation, identify where your main server file lives. Run this command to find all server.py files:

find . -name "server.py" -type f

You may see results like:

• ./server.py (in the root directory)

• ./src/server.py (in a source directory)

• ./mcp_server/server.py (in a package directory)

Check your current directory structure:

ls -la

Look for the main server entry point. Most MCP servers follow standard Python project structures with either a root-level server file or one nested in a package directory.

How to Test Your Server Setup

Now you’ll want to test your server to ensure it's working correctly. Start with the main server file you identified:

python server.py

If this is the correct server and everything is configured correctly, you'll see output similar to:

╭─ MCP Server ───────────────────────────────────────────────────────────────╮
│ 🖥️  Server name: Example-MCP                                              │
│ 📦 Transport: STDIO                                                        │
│ 🤝 Protocol: JSON-RPC                                                      │
╰────────────────────────────────────────────────────────────────────────────╯
[INFO] Starting MCP server with transport 'stdio'
[INFO] Server ready for connections

This output confirms your MCP server is working correctly. The server uses standard input/output (STDIO) for communication, which is perfect for Claude Desktop integration. You can stop the server with Ctrl+C.

How to Configure Claude Desktop

Now that your server runs properly, configure Claude Desktop to connect to it. The configuration file location depends on your operating system:

For macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

For Windows:

%APPDATA%\Claude\claude_desktop_config.json

For Linux:

~/.config/Claude/claude_desktop_config.json

Create or edit this file with your exact paths. Your configuration should look like this:

{
  "mcpServers": {
    "example-mcp": {
      "command": "/Users/yourusername/path/to/mcp-server/venv/bin/python",
      "args": ["/Users/yourusername/path/to/mcp-server/server.py"],
      "cwd": "/Users/yourusername/path/to/mcp-server"
    }
  }
}

Replace /Users/yourusername/path/to/mcp-server/ with your actual path. You can get your precise path by running pwd in your MCP server directory.

The configuration tells Claude Desktop:

• Which Python interpreter to use (from your virtual environment)

• Where to find the server script

• Which directory to run the server from

How to Restart Claude Desktop and Test Integration

After saving your configuration file, altogether quit Claude Desktop (not just close the window). On macOS, use Cmd+Q or right-click the dock icon and select Quit. Then restart Claude Desktop.

Once Claude Desktop is running again, test your MCP integration. You can verify the connection by:

1. Looking for your MCP server name in Claude's interface

2. Testing basic MCP functionality with prompts like:

   • "What MCP tools are available?"

   • "Can you check the MCP server status?"

   • "Show me the available MCP commands"

If everything is working correctly, Claude will respond using the MCP server tools, confirming successful integration.

Understanding MCP Server Capabilities

MCP servers extend Claude's capabilities by providing structured access to external tools and data sources. Common MCP server implementations include:

1. File system operations: MCP servers can provide controlled access to local files, allowing Claude to read, analyze, and process documents while maintaining security boundaries.

2. API integrations: Connect Claude to external services through MCP servers that handle authentication, rate limiting, and data formatting for various APIs.

3. Database connections: Query databases safely through MCP servers that manage connections, handle credentials securely, and format results for Claude's consumption.

4. Custom tools: Build specialized tools for your workflow, from code analysis to data processing, all accessible through the standardized MCP interface.

The beauty of MCP is its flexibility – you can create servers for virtually any tool or service you need Claude to interact with.

Alternative Installation Methods

If you want more streamlined approaches for future setups, here are two excellent alternatives:

Method 1: Direct Package Installation

For MCP servers available as packages, you can install directly:

pip install mcp-server-package

Then use this simpler configuration:

{
  "mcpServers": {
    "example-mcp": {
      "command": "mcp-server-command"
    }
  }
}

This method works when the MCP server provides a command-line entry point through its setup configuration.

Method 2: Using UV Package Manager

UV provides more robust dependency management – perfect if you're tired of Python version conflicts:

# Install UV
curl -LsSf https://astral.sh/uv/install.sh | sh

# Use UV in your configuration
{
  "mcpServers": {
    "example-mcp": {
      "command": "uv",
      "args": [
        "run",
        "--with", "fastmcp",
        "python",
        "/path/to/mcp-server/server.py"
      ],
      "cwd": "/path/to/mcp-server"
    }
  }
}

UV automatically manages Python versions and dependencies, reducing the likelihood of environment-related errors.

How to Prevent Future ENOENT Errors

To avoid this issue in the future, follow these best practices:

1. Use Virtual Environment Copies Instead of Symlinks

When creating virtual environments, use the --copies flag:

python3 -m venv venv --copies

This creates actual copies of files instead of symlinks, making your environment more resilient to Python upgrades.

2. Pin Your Homebrew Python Version

Prevent automatic Python upgrades that break environments:

brew pin python@3.11

Remember to unpin when you're ready to upgrade intentionally.

3. Create a Health Check Script

Save this script as health_check.sh in your MCP server directory:

#!/bin/bash
# health_check.sh
echo "Checking Python virtual environment..."
source venv/bin/activate

python -c "import sys; print(f'Python: {sys.executable}')"
python -c "print('✓ Python is working')"

# Check for common MCP dependencies
python -c "import json; print('✓ JSON module available')"
python -c "import asyncio; print('✓ Asyncio available')"

echo "Health check complete!"

Make it executable and run it periodically:

chmod +x health_check.sh
./health_check.sh

4. Document Your Python Version

Create a .python-version file in your project:

python --version > .python-version

This helps you remember which Python version the project was built with.

Troubleshooting Common Issues

Even with the fix applied, you might encounter these challenges:

Import Errors

If you see import-related errors, ensure all dependencies are installed:

source venv/bin/activate
pip list  # Check installed packages
pip install -r requirements.txt  # Reinstall if needed

Permission Denied Errors

Make sure your server file is executable:

chmod +x server.py

Claude Desktop Not Finding the Server

Double-check your configuration paths are absolute, not relative:

# Good - absolute path
"/Users/username/projects/mcp-server/server.py"

# Bad - relative path
"./server.py"

Server Starts, But Claude Can't Connect

Verify that the transport method matches between your server and the configuration. Most MCP servers use STDIO, but some might use HTTP or WebSocket transports.

Multiple Python Installations

If you have multiple Python versions, be explicit about which one to use:

# Check available Python versions
ls -la /usr/local/bin/python*

# Use a specific version
/usr/local/bin/python3.11 -m venv venv

Conclusion

You've successfully fixed the "spawn python ENOENT" error by rebuilding your Python virtual environment and properly configuring your MCP server for Claude Desktop. You've also learned how to prevent future mistakes and troubleshoot common issues.

With your MCP server running smoothly, you can now:

• Build custom tools that extend Claude's capabilities

• Create integrations with your favorite services

• Develop specialized workflows for your specific needs

• Share your MCP servers with the community

The MCP ecosystem is growing rapidly, with new servers and tools being developed constantly. Whether you're building file system tools, API integrations, or custom utilities, you now have the foundation to create and maintain robust MCP servers.

Happy building, and enjoy your error-free development journey! For more tutorials, follow my work on GitHub.

Throughout this handbook, you will learn how to:

• Correctly establish and manage an app's unique identity.

• Understand the roles of different Apple developer certificates and how to create and manage them.

• Differentiate between various types of provisioning profiles and know when to use each one.

This guide is geared towards new developers who want to learn how the code signing process works, but it should also be useful experienced developers who want or need to refresh their memory.

Prerequisites

While there are no hard prerequisites to understanding the certificates, bundles, and provisioning profiles for distributing on Apple platforms, it helps to have an Apple developer account to follow along.

Table of Contents

• App IDs, Bundle IDs – Your App’s Identity

• Understanding Distribution: A Deep Dive into Certificates

• Bridge between everything: Provisioning Profiles

• Device management – Development and Ad Hoc Builds

• Possibilities: Enabling Capabilities and Services

• Conclusion

App IDs, Bundle IDs — Your App’s Identity

The Bundle ID and the corresponding App ID registered with Apple form the basis of an application’s identity. Establishing these correctly from the beginning is very important, as errors or misconfigurations here can lead to significant complications down the line, particularly once you’ve submitted your app to App Store Connect.

Understanding CFBundleIdentifier (Bundle ID)

What is the “Bundle ID”?

Think of the Bundle ID as a unique name or a fingerprint for your app. The CFBundleIdentifier, more commonly known as the Bundle ID, is a string that uniquely identifies your application.

This identifier is not just a name – it serves multiple crucial purposes.

• The operating system relies on it to apply specific preferences and settings to an app.

• This is used to launch the application from other apps etc.

• It plays an essential role in the validation of an app's code signature, ensuring the app's integrity and authenticity.

• The Bundle ID defined in an app's Info.plist file must exactly match the Bundle ID registered for the app in App Store Connect for successful submission and distribution.

The Bundle ID string must adhere to specific character limitations: it can only contain alphanumeric characters A-Z, a-z, 0-9, hyphens -, and periods .. It's important to note that Bundle IDs are treated as case-insensitive by the system.

How to Choose and Format Your Bundle ID (Reverse-DNS and Best Practices)

Apple highly recommends, and it is standard practice, to use a reverse-DNS (Domain Name System) format for Bundle IDs.

A common example would be com.yourcompanyname.appname. This convention leverages the global uniqueness of domain names to help ensure the global uniqueness of Bundle IDs.

If an organization uses its unique domain name (for example, sravan.gg becomes gg.sravan ) as the prefix, and the app name is unique within that organization, the resulting Bundle ID (for example, gg.sravan.mycoolapp ) is highly likely to be unique worldwide.

Sidenote: While Xcode won’t stop you from creating something like com.google.mapping or something like that even if you don’t work at Google, this will most likely get rejected when it goes through the AppStore review process. This is because this implies ownership of that domain. So, while it’s technically possible when starting out, you shouldn’t use domains that don’t belong to you.

The fundamental nature of the Bundle ID as a unique, system-wide identifier – coupled with its immutability after an app is first uploaded to App Store Connect – means that you should treat its selection with the same seriousness as choosing a permanent, unchangeable identifier for a critical entity. A mistake in the Bundle ID after this point can necessitate creating an entirely new app listing on the App Store.

App IDs in the Apple Developer Portal: Explicit vs. Wildcard

Which One Do You Need?

In the Apple Developer Portal, developers register an "App ID." This App ID is a record that links one or more applications from a single development team to specific app services (capabilities) and is used in provisioning profiles. We’ll learn more about this in the following sections.

There are two main types of App IDs:

• Explicit App ID: This type is used for a single application. The Bundle ID specified within an explicit App ID must be an exact match for the CFBundleIdentifier in the app's Info.plist file (for example, com.mycompany.myapp). Explicit App IDs are required for apps that use many of Apple's specific services and capabilities, such as In-App Purchases (which are enabled by default for explicit App IDs), Push Notifications, iCloud, HealthKit, and Sign in with Apple.

• Wildcard App ID: This type can be used for a set of applications that share a common Bundle ID prefix. It contains an asterisk (*) as the last part of its Bundle ID string (for example, com.mycompany.*). This wildcard App ID would match any app whose Bundle ID starts with com.mycompany., such as com.mycompany.app or com.mycompany.utility. But you can’t use wildcard App IDs if the app requires services or capabilities that mandate an explicit App ID.

The choice between an explicit and a wildcard App ID has significant implications. The App ID acts as a central registration point, and the capabilities are "enabled" for this registration – more on capabilities later in this handbook.

You can think of an explicit App ID as a specific key designed to unlock extra "keyholes" (capabilities). A wildcard App ID, being more generic, might not fit these extra keyholes. If you choose a wildcard App ID initially for convenience, but you need a feature requiring an explicit App ID (like Push Notifications) later, you’ll be forced to create a new explicit App ID and reconfigure associated settings and provisioning profiles.

So, make sure you carefully consider your current and future app features when selecting an App ID type. The following table provides a quick comparison**.**

My personal recommendation is always go with explicit App Ids unless you need the flexibility of wildcard app ids.

Step-by-Step: How to Register Your App ID in the Apple Developer Portal

To register an App ID, an you’ll need an Apple Developer Program membership. Also, the actions must be performed by someone with an Account Holder or Admin role.

The process is as follows:

1. Sign in to the Apple Developer Portal and navigate to "Certificates, Identifiers & Profiles," then select "Identifiers" from the sidebar.

2. Click the “Add button (+)” to create a new identifier.

   

3. Select "App IDs" from the list of options and click "Continue."

   

4. Make sure that the "App" type is selected (it usually is by default) and click "Continue."

   

5. Enter a "Description" for the App ID. This is for your reference within the portal (for example, "My very cool App ID").

   

6. Choose the "App ID Type": "Explicit" or "Wildcard."

7. For an "Explicit App ID," enter the exact Bundle ID that will be used in your Xcode project (for example, com.yourcompany.yourapp). For a "Wildcard App ID," enter a Bundle ID suffix ending with an asterisk (for example, com.yourcompany.*).

8. Scroll down to the "Capabilities" section and select the checkboxes for any app services your app will use. Some capabilities might require further configuration at this stage or later. (Again, we’ll cover app capabilities in more detail later on).

9. Click "Continue," review all the details carefully, and then click "Register" to finalize the App ID creation.

   

How to Manage Your Bundle ID: Xcode, App Store Connect, and the Point of No Return

The Bundle ID specified in an Xcode project is critical. To set it:

1. In the Xcode project navigator, select the target for your app.

2. Open the "Signing & Capabilities" tab.

3. Expand the "Signing" section.

4. In the "Bundle Identifier" text field, enter the Bundle ID. This identifier must precisely match the Bundle ID associated with an explicit App ID registered in the Developer Portal, or conform to the pattern of a wildcard App ID if applicable.

It's important to understand the difference between the "Bundle ID" (or CFBundleIdentifier) in the Xcode project and the "App ID" registered in the Developer Portal. The "App ID" in the developer portal is an entity that contains a “Bundle ID” string (either explicit or wildcard). The string in your Xcode project's "Bundle Identifier" field must match this contained string.

When preparing for distribution via TestFlight or the App Store, you’ll need to create an app record in App Store Connect. The Bundle ID you enter during this app record creation must exactly match the Bundle ID in the Xcode project.

A Critical Warning: Immutability After First Upload

This is a point of no return: Once you upload a build of an app to App Store Connect, the Bundle ID for that app record cannot be changed.

In addition, after an upload, you can’t delete the associated explicit App ID registered in the Developer Portal. This immutability highlights the need for careful planning and verification of the Bundle ID before any uploads occur.

If you prefer programmatic management or automation, the App Store Connect API provides resources for managing Bundle IDs. You can read more on that here.

Understanding Distribution: A Deep Dive into Certificates

What are Certificates?

Certificates are digital credentials that verify a developer's identity – that is, you – to Apple and, by extension, to the app users.

They are fundamental to Apple's code signing process, which is mandatory for all apps to ensure they originate from a known source and have not been tampered with since being signed.

What is Code Signing: Ensuring Trust and Integrity

Code signing is you as a developer signing the app with your signature. It is the process of attaching a digital signature to an app's code. This signature assures users of two key things:

1. Authenticity: The app was created by an identified Apple developer (an individual or a team).

2. Integrity: The app's code has not been altered or corrupted since it was signed by the developer.

The process involves using a private key, securely held by the developer (you), to create the signature. The corresponding public key, embedded within the developer's certificate (issued by Apple), is used by the system to verify this signature.

This system of identity verification and integrity checking is crucial. The developer's certificate, issued by Apple as a Certificate Authority (CA), vouches for their identity. The code signing process, using hashing and encryption, ensures that any modification to the code after signing would invalidate the signature.

For app developers, benefits of code signing include removing warnings on macOS for apps distributed outside the Mac App Store, providing a smoother user experience. It is a mandatory requirement for listing applications on any of Apple's App Stores. It also enhances security of the app as it acts as a deterrent against malicious tampering.

Types of Certificates: Development, Distribution, and Developer ID

Apple provides different types of certificates for various stages of development and methods of distribution. Each of them has a distinct role to play throughout the app development process.

1. Development Certificates (for example, "Apple Development"):

• Purpose: Used to sign apps during the development phase, allowing them to be installed and run on a limited number of registered test devices and simulators for debugging and testing.

• Identifies: Typically identifies an individual developer through their developer ID.

• Used with: Development provisioning profiles – more on this later.

2. Distribution Certificates (for example, "Apple Distribution"):

• Purpose: Used to sign apps intended for distribution, either through Ad Hoc methods (to a limited set of registered testers) or for submission to the App Store.

• Identifies: The development team via the team identifier.

• Use Cases:

  1. App Store: For signing the final version of an app that will be uploaded to App Store Connect for TestFlight beta testing or release on the App Store (iOS, macOS, tvOS, watchOS). These are used with App Store provisioning profiles – more on this later.

  2. Ad Hoc: For signing apps that will be distributed to a limited number of registered test devices outside of the App Store or TestFlight. These are used with Ad Hoc provisioning profile. More on this later.

3. Developer ID Certificates (for Mac apps distributed outside the Mac App Store):

• Purpose: Specifically for macOS developers who wish to distribute their applications directly to users (for example, from their own website) rather than through the Mac App Store. Gatekeeper on macOS recognizes apps signed with a Developer ID certificate, assuring users that the app is from a known developer and has not been tampered with.

• Types:

  1. Developer ID Application: Used to sign the Mac application bundle (.app) itself.

  2. Developer ID Installer: Used to sign a Mac Installer Package (.pkg) that contains the signed application.

  3. Limit: Developers can create up to five Developer ID Application certificates and up to five Developer ID Installer certificates.

The following table summarizes these certificate types:

How to Create an Apple Certificate – An Overview

Here’s a general outline of how you create an Apple Certificate:

• Generate a Certificate Signing Request (CSR) on your Mac. (Yes you need a mac.)

• You upload this CSR in AppStoreConnect as a part of creating the certificate.

• Download the certificate from AppStoreConnect once it’s issued.

• Install the certificate into your Keychain.

Now we’ll go through each step in more detail. This part is very important, since we have to save some of the files generated locally or we lose the ability to transfer these certificates. This would mean revoking and re-issuing certificates (I have done this more times than I’d like to admit).

How to Create a Certificate Signing Request (CSR)

A Certificate Signing Request (CSR) is a fancy name for an encrypted block of text containing information about who’s requesting the certificate (like your name and the public key). These are widely used in the cryptography world.

For our purposes, you’ll generate a CSR on your Mac and then submit it to Apple to request a digital certificate. The CSR generation process also creates a new public/private key pair on the Mac – the private key is stored in Keychain Access and is used for the eventual code signing.

To create a CSR using Keychain Access on macOS:

1. Launch Keychain Access (you can find it at /Applications/Utilities/ or use spotlight).

2. From the menu bar, choose Keychain Access > Certificate Assistant > Request a Certificate From a Certificate Authority.... (Here the Certificate Authority would be Apple).

3. In the dialog, enter your email address and a common name for the key (for example, "My Mac Key" or "[Your Name] Dev Key"). This name is primarily for your identification in the Keychain.

4. Leave the "CA Email Address" field empty – we won’t email it to the Certificate Authority (Apple).

5. Select the "Saved to disk" option and click "Continue".

6. Save the file, which will have a .certSigningRequest extension. The corresponding private key is now stored in the login keychain. This private key is irreplaceable by Apple and you must store it yourself.

How to Generate and Download Your Apple Certificates

Once you’ve created a CSR, you can request a certificate from the Apple Developer Portal:

1. Navigate to "Certificates, Identifiers & Profiles" and select "Certificates".

2. Click the add button (+).

3. Choose the desired certificate type

4. Follow the prompts, and when asked, upload the .certSigningRequest file generated earlier.

5. After Apple processes the request, the certificate will be available for download as a .cer file.

   

To install the certificate, double-click the downloaded .cer file. It will be added to the Keychain Access application – usually appearing in the "login" keychain under the "My Certificates" category, where it should be paired with the private key generated during the CSR generation process earlier.

You can see my certificate and private key in the image below for reference.

To recap, the CSR certifies that you generated the request from your mac. The certificate certifies that Apple (in this case, an intermediary like the "Apple Worldwide Developer Relations Certification Authority") confirms that they verified the CSR and that it is indeed you who will sign with the certificate (.cer) file.

This is enforced by only you having access to the private key – if you lose it, you cannot use this certificate anymore.

So, if you use this certificate (and the private key) to sign an app, the app store / operating system knows that it is you for sure since Apple confirmed it.

How to Store Your Keys: What are .p12 Files?

As I mentioned in the previous section, to code sign an app you need your certificate (containing the public key) and the corresponding private key. This is created along with the CSR, and you can find it in the Keychain Access app.

We call the combination of the certificate and the private key a digital identity. This proves your identity when you sign an app with them.

.p12 Files (Personal Information Exchange):

A .p12 file is a password-protected archive format used to bundle a certificate along with its private key. Its primary purposes are:

• Backing up the digital identity in case you lose access to your Mac.

• Transferring the digital identity to another Mac (for example, for another team member or a new development machine).

• Providing the identity to automated build systems or third-party build services.

Historically, I have stored the .p12 file on a shared drive with my team and shared the password to it verbally – you can also store it in a local backup disk.

Great. So how do you create one?

To export a .p12 file from Keychain Access:

1. Open Keychain Access, select the "login" keychain, and go to the "My Certificates" category.

2. Locate the desired certificate. It should have an expandable disclosure triangle indicating an associated private key (look at the image of my certificate above).

3. Select both the certificate and its private key (or right-click the certificate and choose "Export").

4. Right-click and choose "Export [X] items...".

5. In the save dialog, choose the "Personal Information Exchange (.p12)" file format.

6. Assign a strong password to protect the .p12 file. This password will be required when importing the file elsewhere. It is crucial for security.

7. Save the file to a secure location.

   

Bridge Between Everything: Provisioning Profiles

Provisioning profiles are the final link between an App ID, developer certificates, and, in some cases, a list of specific test devices. They act as a permission slip, authorizing an app signed with a particular certificate to be installed and run either on designated devices or to be submitted to the App Store.

What Exactly is a Provisioning Profile?

A provisioning profile is a .mobileprovision (for iOS / VisionOS) or .provisionprofile (for macOS) file that holds several key pieces of information:

• The App ID: Specifies which application (or set of applications, if using a wildcard App ID) the profile applies to.

• Certificates: Contains one or more developer or distribution certificates that can be used to sign the app.

• Device UDIDs (for Development and Ad Hoc): For profiles intended for testing on specific devices, it includes a list of the Unique Device Identifiers (UDIDs) of those authorized devices – more on devices in the next section.

• Entitlements: A list of app services or capabilities (like Push Notifications, iCloud, App Groups) that the app is permitted to use. These are derived from the capabilities enabled for the associated App ID.

You can open the file using vim or any editor to see parts of the content which include the App Id, Operating Systems, Certificates, and so on.

The operating system checks the provisioning profile at app launch to ensure the app is authorized to run on the current device and use the requested services. If the profile is missing, invalid, or doesn't match the app's signature or the device, the app will not launch.

They are difference from certificates, because certificates are tied to you as a developer. But provisioning profiles are to a specific app – with specific capabilities to a specific developer and maybe on specific devices.

If any of these change (let’s say you added a capability or your certificate expired, for example), you’ll need to generate the provisioning profile again. These are the files you will work with the most out of all the above, and any change can cause your profile to become invalid.

Types of Provisioning Profiles: Development, Ad Hoc, App Store, (and Enterprise)

Types of Provisioning Profiles: Development, Ad Hoc, App Store, (and Enterprise)

Just like certificates, we have multiple types of provisioning profiles. Similar to certificates, there can be development and distribution provisioning profiles.

Since we also keep track of the devices a profile is supposed to run, we have several kinds of distribution profiles based on which devices it should run on.

We also have special profiles like “Enterprise” which will add additional capabilities (like main camera access on the Vision Pro) but will restrict your app distribution methods to enterprise only.

We will go over each of these types now. Feel free to skip to the one that you’re looking for.

Development Provisioning Profile:

• Allows an app to be installed and debugged on specific devices registered in the developer's account during the active development phase. More on device registration later.

• Contains an App ID, one or more development certificates, and a list of registered device UDIDs.

• Created manually in the Apple Developer Portal or generated automatically by Xcode if Automatically manage signing is enabled.

Ad Hoc Provisioning Profile:

• Allows distribution of an app to a limited number of registered test devices without requiring Xcode for installation. This is ideal for distributing builds to QA teams, beta testers, or clients for feedback.

• Contains an App ID (often an explicit App ID, or an Xcode-managed one like XC Wildcard or XC), a single distribution certificate, and a list of registered device UDIDs.

• Created manually in the Developer Portal or managed by Xcode's automatic signing.

App Store Connect Provisioning Profile:

• Required to sign an app for submission to App Store Connect. This is the pathway for distributing apps via TestFlight for broader beta testing and for official release on the App Store.

• Contains an explicit App ID (or an App ID that matches the app's bundle ID, including Xcode-managed App IDs), and a single distribution certificate. Device UDIDs are not included in this profile type since this is meant for broader distribution.

• Created manually in the Developer Portal or managed by Xcode's automatic signing.

Enterprise Provisioning Profile:

• Exclusively for members of the Apple Developer Enterprise Program. It allows developers of these orgs to distribute proprietary, in-house applications directly to their employees, bypassing the public App Store.

• Note: This program has stringent enrollment criteria and is strictly for internal distribution within the enrolled organization – these apps cannot be pushed to AppStore.

Developer ID Provisioning Profile:

• Required to utilize certain Apple services or advanced capabilities like Push Notifications, CloudKit, Sign in with Apple, or specific iCloud services.

• Contains an App ID, a Developer ID distribution certificate, the entitlements authorized for the app.

• Created manually in the Developer Portal – will not be added automatically by Xcode’s automatic signing.

How to Create and Manage Provisioning Profiles

Creating and managing provisioning profiles usually requires an Account Holder or Admin role in the Apple Developer Program. You also need a configured App ID, the appropriate certificate(s), and for Development or Ad Hoc profiles, a list of registered device UDIDs.

If you are new developer, my recommendation is to read this article completely, then get back to this section once you have your devices setup.

General steps for manual creation in the Developer Portal:

1. Navigate to "Certificates, Identifiers & Profiles" and select "Profiles".

2. Click the add button (+).

3. Select the type of provisioning profile to create (for example, "iOS App Development," "Ad Hoc," "App Store").

4. Choose the App ID you’re targeting from the dropdown list.

5. Select the certificate(s) to include in the profile. Development profiles can include multiple development certificates – so you can include all the team member certificates here. Ad Hoc and App Store profiles include a single distribution certificate.

6. If creating a Development or Ad Hoc profile, select the registered devices to include.

7. Provide a name for the provisioning profile (this is for identification in the portal and Xcode).

8. Click "Generate" and then "Download" the .mobileprovision or .provisionprofile file.

You need to make downloaded profiles available to Xcode. You can often do this by double-clicking the downloaded file or by refreshing profiles within Xcode's account settings (Preferences > Accounts).

I really like Xcode's "Automatically manage signing" feature and it can simplify profile management by a lot. It creates and updates profiles as needed. But, understanding the manual process is crucial for troubleshooting because when things go wrong, it is straightforward to debug the issue with this knowledge.

Provisioning profiles will become invalid and require regeneration if:

• The capabilities of the associated App ID are changed – let’s say you added a new capability.

• An included certificate expires or is revoked.

• For Development/Ad Hoc profiles, if devices are added or removed from the registered list in a way that affects the profile's device set, or if the profile's own expiration date is reached. When such changes occur, you have to edit the profile (if possible) or delete it and recreate it in the Developer Portal, then re-download it and install it again. While this may seem like a complicated step, it’s straightforward if you do it a couple of times.

Device Management — Development and Ad Hoc Builds

For testing applications on physical Apple hardware outside of Testflight or AppStore, you’ll need to register the Unique Device Identifiers (UDIDs) of your test devices with your Apple Developer account. This registration is a necessary step for creating Development and Ad Hoc provisioning profiles.

Why You Need to Register Test Devices

Development and Ad Hoc provisioning profiles are specifically tied to a list of registered devices. An app signed with this profile can be installed directly without going through App Store process. This means that you need to register devices you intend to develop on. This restricts bad faith actors from releasing apps widely without developer and App Store supervision.

The UUID of a device is like a physical address (think Mac Address). If you don’t include this in the provisioning profile you used to sign an app package, it cannot be installed on that device.

Let’s go over the steps to do that.

How to Find Your Device's UDID (Unique Device Identifier)

A UDID is a unique 40-character hexadecimal string (for older devices) or a 25-character string (format XXXXXXXX-XXXXXXXXXXXXXXXX) that uniquely identifies a specific iPhone, iPad, Apple Watch, Apple TV, Vision Pro or Mac.

There are several ways to find a device's UDID:

• Xcode: Connect the device to a Mac running Xcode. Open Xcode and navigate to Window > Devices and Simulators. Select the connected device from the list on the left. The UDID will be displayed as the "Identifier" in the device information panel.

• Finder (macOS Catalina and later): Connect the iOS or iPadOS device to a Mac. Open Finder and select the device from the sidebar under "Locations." The UDID may be displayed directly, or it might be necessary to click on the line of text beneath the device's name (which shows model, storage, and OS version) to cycle through to display the UDID.

• iTunes (older macOS versions): For Macs running macOS Mojave or earlier, connect the device and open iTunes. Select the device icon when it appears. In the "Summary" tab, click on the "Serial Number" field; this will change to display the UDID.

• Apple Silicon Macs: When registering an Apple Silicon Mac, it's important to look for the "Provisioning UDID," which can be found in System Information under Hardware > Provisioning UDID.

• Other Ways: There are some websites that will install a profile on to your device to get the UUID – so as an absolute last resort, you can do this. But I highly recommend doing it in the one of the official ways to avoid any potential issues.

How to Register Devices in the Apple Developer Portal

Device registration is managed through the "Certificates, Identifiers & Profiles" section of the Apple Developer Portal (developer.apple.com) and typically requires an Account Holder or Admin role.

To manually register a single device:

1. Sign in to the Apple Developer Portal and navigate to "Certificates, Identifiers & Profiles," then select "Devices" from the sidebar.

2. Click the add button (+) to register a new device.

3. Select the correct platform for the device (for example, iOS, macOS, tvOS, watchOS).

4. Enter a descriptive "Device Name" (this is for your reference, for example, "Sravan’s iPhone 11 Pro") and the device's UDID obtained in the previous step.

5. Click "Continue," review the information to make sure everything is correct, and then click "Register".

For registering multiple devices, the portal supports uploading a specially formatted text file (a .txt or a .deviceids file) containing device names and UDIDs.

If "Automatically manage signing" is enabled in Xcode, Xcode can automatically register a connected device when it's selected as a build target. This is the way I managed all of my personal projects and devices. On the other hand, the file upload was really useful at my workplace to keep track of all the devices and add them at once.

Understanding Device Limits and Annual Resets

The Apple Developer Program imposes limits on the number of devices that can be registered for testing:

• Annual Limit: Each membership year, a development team can register up to 100 devices for each product family (iPhone, iPad, Apple Watch, Apple TV, Apple Vision Pro, Mac). If you are a large team, this can potentially bottleneck you. When we ran into this issue, we created a new development team that could be split so that it didn’t have too much interdependence. There is no other way as far as I know, other than asking Apple and appealing them.

• Disabling Devices: While a device can be disabled in the portal during the membership year, doing so does not free up its slot or increase the number of available devices for that year. This part is frustrating but I think this is the only way they can enforce the 100 device limit to avoid people swapping devices. They should just provide a pathway to increase the limit, really. Disabling a device will, however, invalidate any provisioning profiles that include it, requiring those profiles to be regenerated.

• Resetting Device List (Start of New Membership Year): At the beginning of a new membership year, Account Holders, Admins, and App Managers are given a one-time option when they first sign in to "Certificates, Identifiers & Profiles" to remove devices from their list. This allows them to "reset" their available device count back to 100 for each product family. You can choose to remove specific devices or all registered devices. This is your one chance per year to remove unused devices completely and free up slots for new devices.

• Membership Expiration: If a developer program membership is nearing expiration and is not planned for renewal, the Account Holder will have an option, starting 30 days before expiration, to download a copy of their registered device list. They can also opt to have all devices removed from the account immediately upon membership expiration. If no action is taken, devices are typically removed automatically 180 days after membership expiration.

Possibilities: Enabling Capabilities and Services

App Capabilities (or App Services) are features provided by Apple that we (as developers) can integrate into our applications to extend functionality and provide richer user experiences. Examples include iCloud storage, Push Notifications, Sign in with Apple, Apple Pay and HealthKit integration. Enabling these often requires explicit configuration for an app's App ID in the Apple Developer Portal and within the Xcode project.

Why You Should Use Capabilities

Making full use of these App capabilities can set your app apart from other apps in a very noticeable way. You can use Apple Wallet integration if you want users to scan a membership card. You can use journaling suggestions if you want to prompt them to journal something. You can use iCloud Storage to lean further into inter-device synchronization.

When you enable a capability for an App ID, it results in specific entitlements being added to the app's provisioning profile. These entitlements are permissions that the operating system checks at runtime to ensure the app is authorized to use the requested service.

How to Configure Capabilities for Your App ID (Apple Developer Portal)

Enabling and configuring capabilities is typically done by an Account Holder or Admin in the Apple Developer Portal (developer.apple.com).

1. Navigate to "Certificates, Identifiers & Profiles" and select "Identifiers."

2. Choose the App ID for which capabilities need to be configured.

3. In the App ID's settings, there will be a "Capabilities" tab. Select the checkboxes for the capabilities the app requires.

4. Many capabilities require additional configuration steps. For these, a "Configure" or "Edit" button will usually appear next to the capability once selected. Examples include:

• App Groups: Requires creating or selecting an app group identifier to allow data sharing between a main app and its extensions, or between different apps from the same developer.

• Apple Pay: Requires associating one or more Merchant IDs with the App ID.

• iCloud: May require choosing Xcode version compatibility and creating or assigning iCloud containers for Key-Value or Document storage

• Sign in with Apple: May require configuring the App ID as a primary app or grouping it with an existing primary App ID, and optionally providing a server-to-server notification endpoint URL.

5. After configuring all selected capabilities, click "Save." A warning dialog may appear, which needs confirmation to finalize the changes.

Enabling a capability in the Developer Portal is only one part of the process. You’ll also need to add and configure it within the app's target in the Xcode project, under the "Signing & Capabilities" tab.

1. Navigate to the project settings and select “Signing & Capabilities”.

2. Press the “+ Capability” button to select the capability.

3. Once selected, the capability should appear in the pane. Depending on the capability, you might want to configure it further.

This Xcode step integrates the necessary frameworks, adds entitlements files to the project, and adjusts build settings.

How Enabling Capabilities Affects Your Provisioning Profiles

Changes to an App ID's enabled capabilities have a direct and significant impact on its associated provisioning profiles.

• Invalidation: When a capability is enabled, disabled, or its configuration is modified for an App ID, all existing provisioning profiles that use that App ID immediately become invalid.

• Regeneration Required: These invalidated provisioning profiles must be regenerated (either by editing and re-saving them in the Developer Portal or by having Xcode's automatic signing handle it). The regenerated profiles will then include the updated set of entitlements corresponding to the newly configured capabilities.

• Platform Impact: Enabling a capability for an App ID that is used across multiple platforms (for example, an iOS app and its watchOS companion) will affect the provisioning profiles for all eligible platforms that use that App ID.

This is something to keep in mind. Especially when it comes to distribution profiles since those are usually manually managed.

Conclusion

While all of these might seem daunting, Apple’s automatic process should handle most of it. But I highly recommend learning how everything works so that you can debug it in case something goes wrong. I also highly recommend using manually created profiles for distribution.

While signing and handling certificates is not the most exciting part of the App development process, it is a necessary skill to have. In my next article, I will go over distributing an app from start to finish (which includes these processes and more restrictions).

You can follow me at Sravan Karuturi for my other posts.

Though the final release of macOS Sequoia (macOS 15) won't be available until late September or early October 2024, I'll show you how to install the public beta for an advance look. It's actually stable enough for daily use.

The macOS Sequoia public beta is available to anyone who wants to try it, though you have to register with the Apple Beta Software Program to obtain it.

Table of Contents

1. Is macOS Sequoia stable?
2. Time needed to install
3. What's new in macOS Sequoia
4. Features in macOS Sequoia
5. Small changes in macOS Sequoia
6. Requirements for macOS Sequoia
7. Back up your Mac first
8. Sign up to get the public beta
9. Where to install the macOS beta
   – Install on a spare Mac
   – Install on an external drive
   – Install on a separate volume
10. Use the Startup Manager
11. Halt macOS beta updates
12. Return to macOS Sonoma
13. What's next

Is macOS Sequoia Stable?

So far, users are reporting the beta version has only a few minor issues. They say the beta is "surprisingly stable."

There are reports of issues with external monitors, and users say to expect issues with external third-party devices. There may also be issues with screen sharing, video conferencing (Zoom particularly), or streaming in web browsers.

Time Needed to Install

The update from macOS Sonoma to macOS Sequoia can take more than an hour. The time needed varies widely based on factors such as the size of the update, your Internet speed, and the age and performance of your Mac.

What's New in macOS Sequoia

Users are reporting that macOS Sequoia is faster, with better battery life on laptops, but we can't be sure until we see the final release.

Looking closely at macOS Sequoia, it's plain that it isn't a major overhaul of the operating system. The most useful features are Window Tiling and a new Passwords application, as well as iPhone mirroring and seamless drag and drop between devices.

I've compared Sonoma vs Sequoia in a separate article, and also provided some advice to answer the question, Should You Update to macOS Sequoia?

Features in macOS Sequoia

macOS Sequoia Passwords application

Password Manager

MacOS Sequoia adds a new app called Passwords, improving the way users manage their login credentials.

Built on the existing framework of Apple's Keychain, this app consolidates passwords, passkeys, Wi-Fi passwords, and other essential credentials into one secure, centralized location.

Credentials previously could be edited in System Settings but they were buried and hard to find. The new Passwords app will largely eliminate the need to use third-party password managers such as 1Password, LastPass, or Bitwarden.

macOS Sequoia Window Tiling

Window Tiling

For years, Windows users have complained that MacOS lacks a tiling window manager. MacOS Sequoia adds a new feature called Window Tiling, which allows users to drag windows to the edge of the screen for placement side by side, top and bottom, or in a grid. Third-party utilities have more features but the built-in Window Tiling is a welcome addition.

These two features make an upgrade worthwhile. In addition, Apple has announced other capabilities.

iPhone Mirroring

This feature allows the use of iPhone apps within a macOS window. Users can now check iPhone notifications directly on their Mac, making the Mac an extension of the iPhone.

One user noted, “No longer do I have to find my phone when I am at home sitting in front of my Mac just to check on a notification.”

Seamless Drag and Drop Between Devices

This feature aims to improve the reliability of transferring files between iPhone and Mac, addressing issues with AirDrop. "Transferring files from Mac to an iPhone Apps no longer requires 5+ tedious steps," a user mentioned.

Apple Intelligence

MacOS Sequoia will introduce the first use of Apple Intelligence, Apple's AI initiative. Apple Intelligence comprises new system-level capabilities, leveraging Apple custom silicon for both local and cloud-based processing.

This is more of a future prospect as AI gets baked in to more applications, but we may see improvements to Siri in macOS Sequoia. Note that these capabilities won't be present when you install macOS Sequoia on an Intel-based Mac.

Small Changes in macOS Sequoia

• System Settings: Individual menus have been rearranged for quicker access to frequently used menus.
• Safari: The web browser has faster page load times, a new start page, and a brand new unified menu similar to "compact mode" on iOS. It can summarize websites and highlight relevant information.
• Notes: Minor improvements including collapsible sections and a choice of highlight styles. Also, Notes adds support for live audio transcription and math equations.
• Videoconferencing: Preview what you share in video calls for presentations and screen sharing. Also, background replacements are built into the macOS video feed so you won't need to use background replacements in Zoom or other conferencing apps.

Requirements for macOS Sequoia

Check your macOS version and update macOS to Sonoma (macOS 14) before installing the macOS Sequoia beta.

You should keep the current macOS Sonoma available on your Mac, just in case you run into problems with the beta. That means you should install the macOS Sequoia beta on a separate volume, external drive, or a secondary Mac.

Also, macOS Sequoia does run on older Intel-based Macs, but it may be slow. So I recommend installing it only on Macs with M1, M2, or M3, the Apple Silicon chips.

You can install the macOS Sequoia beta on any computer that runs runs macOS Sonoma with the exception of the 2018–2019 MacBook Air models with Intel Amber Lake chips. Apple provides a list of supported models for macOS Sequoia.

Back Up Your Mac

If you've got a new Mac that hasn't been used, you don't need to back up files. Or, if you're like many developers, you won't need to back up your Mac if you have all your important files stored in the cloud.

Otherwise, if there are important files on your computer, make sure you have a backup of your Mac before you install the macOS beta version.

Sign Up to Get the Public Beta

Apple offers a public beta version as well as developer beta versions. The developer beta is released first and intended for software developers to test compatibility of applications, while the public beta is released a few weeks later. The public beta is more stable and has fewer bugs than the developer beta.

The public beta is available now, for free. Sign up for the public beta on the Apple Beta Software Program website. After you sign up with your Apple ID, your System Settings will show that beta updates are available.

Where to Install the macOS Beta

Your best option is to install the macOS beta on a spare Mac, if you have an extra computer. Ideally, you have a relatively new Mac with an Apple Silicon M1, M2, or M3 chip. If you have an older Mac, you may want to avoid the beta version because it could slow down your computer.

Installing on a spare Mac allows you to try the new macOS version without affecting your daily productivity.

Alternatively, you can install the macOS beta on a separate volume on your Mac. This allows you to boot into the beta version when you want to try it out.

You can also install the beta version on an external drive. In either case, you need to hold the power button until you see the Startup Manager menu which lets you select an alternate to the default startup disk.

Here are instructions for installing the macOS Sequoia beta version on a spare Mac, an external drive, or a separate volume.

Install on a spare Mac

Here's how to install the macOS Sequoia beta on a Mac running macOS Sonoma.

1. Open System Settings and navigate to General and Software Update.
2. Click the "circle I" info button in Beta Updates.
3. Set the Beta Updates to macOS Sequoia Public Beta.
4. Click "Done" and your Mac will check for software updates.
5. After a check, the upgrade name appears with an "Upgrade Now" button.
6. Software updates require at least 20% battery power so you may need to connect to power if your battery is low.
7. Enter your password to start the software update. With a fast Internet connection, the download should take about 30 minutes. After the download, the "preparing" process will take about 15 minutes.
8. Your Mac will restart after the installation. You'll see the Apple logo and a progress bar. The installation process will take about 15 minutes with several automatic restarts.
9. After installation completes, you'll see the login screen. Enter your Mac password, then your Apple ID password, and "Continue" or "Set Up Later" through various agreements and settings.
10. The macOS Sequoia desktop will appear with a the Feedback Assistant application open. Use the Feedback Assistant to report any bugs or issues you encounter.
11. Check About This Mac to confirm you're running macOS 15.

If you don't see macOS Sequoia Public Beta option in Beta Updates, sign up for the Apple Beta Software Program. After you sign up with your Apple ID, your System Settings will show that beta updates are available.

Install on an external drive

Not many users own an external drive now that cloud storage is popular. But if you have an external drive, you can install the macOS beta on it.

You'll need to format the drive so you must erase any files already on the drive. It's best if you own a fast SSD drive with a USB-C or Thunderbolt connection for use of the operating system. You can use a USB thumb drive, but you'll need at least 32 GB of space.

How to format the external drive

1. Connect the external drive to your Mac.
2. Search in Spotlight and open Disk Utility.
3. Select the external drive in the left sidebar.
4. Click Erase to reformat the drive.
5. Name the drive macOS Sequoia or whatever you like.
6. Choose Mac OS Extended (Journaled) as the format.
7. Choose GUID Partition Map as the scheme.
8. Click Erase to format the drive.
9. Close Disk Utility after the drive formatting is done.

How to get the macOS Sequoia beta

You'll need to download *.pkg files to install on an external drive. Several sites provide links to installer *.pkg files for macOS betas. Check:

• betaprofiles.dev
• mrmacintosh.com

Download the latest InstallAssistant.pkg. These files are huge (14GB or more) so a download may take more than 30 minutes with a fast Internet connection.

How to install the macOS Sequoia beta

Double click the InstallAssistant.pkg file to start the installation. Click "Change Install Location" to select the external drive. In the step "Destination Select" you can select the external drive as the installation destination.

Install on a separate volume

If you want to install the macOS beta on a separate volume, follow these steps. You might hear this process called a "dual boot" or "separate partition" installation. Apple's APFS file system introduced "volumes" which are like partitions but more flexible.

You'll have two volumes on your Mac, one for macOS Sonoma and one for macOS Sequoia. You can use the Startup Manager to choose which volume to boot from.

How to create a new volume

1. Search in Spotlight and open Disk Utility.
2. Select the internal drive in the left sidebar.
3. Click the + button in the top bar to add a new volume (or "Edit" > "Add APFS Volume" in the menu).
4. Name the volume macOS Sequoia or whatever you like.
5. Choose a format (commonly "APFS").
6. Click Add to create the volume.
7. Click "Done" and close Disk Utility after the volume creation is done.

Get the macOS Sequoia beta

You'll need to download *.pkg files to install on a separate volume. Several sites provide links to installer *.pkg files for macOS betas. Check:

• betaprofiles.dev
• mrmacintosh.com

Download the latest InstallAssistant.pkg. These files are huge (14GB or more) so a download may take more than 30 minutes with a fast Internet connection.

Install the macOS Sequoia beta

Double click the InstallAssistant.pkg file to start the installation. Click "Change Install Location" to select the volume you created. In the step "Destination Select" you can select the new volume as the installation destination.

Use the Startup Manager

Hold down the power button when starting your Mac to enter the Startup Manager. "Loading startup options" will appear. You have a choice of booting from the internal drive, an external drive (if connected), a disk volume, or "Options."

Select the external drive or volume to boot from. You can set a default for the external drive or volume in System Settings > Startup Disk.

Halt macOS Beta Updates

If you don't want to continue using macOS Sequoia beta, you can turn off beta updates.

Go to System Settings > General > Software Update. Click the "circle I" info button in Beta Updates and set the Beta Updates to Off. This will stop the macOS beta updates.

This is a necessary step if you don't want to use the macOS beta. If you don't do this, your Mac will continue to update to the latest beta version.

Return to macOS Sonoma

If you're using an external drive or separate volume to run the macOS beta, you still have macOS Sonoma on your Mac as the primary volume on the internal drive. Reformat the external drive or delete the volume if you no longer want to use the macOS beta.

Restore macOS Sonoma on a Spare Mac

If you are using macOS Sequoia on a spare Mac, you can restore macOS Sonoma by reinstalling it.

You can download and install macOS Sonoma from the Mac App Store. Search in the Mac App Store for "macOS Sonoma" or use this link to view the listing for macOS Sonoma. Click "Get" and the App Store will open System Settings > General > Software Update and begin downloading macOS Sonoma.

Downloads from the App Store are slow, so expect a wait of an hour or more. The App Store installs an application Install macOS Sonoma in the Applications folder.

After the download is complete, the Install macOS Sonoma application will launch automatically. Follow the instructions to install macOS Sonoma.

Alternatively, you can directly download an installer *.pkg file to restore macOS Sonoma. The download is faster than the App Store. Check:

• mrmacintosh.com

Double click the InstallAssistant.pkg file to start the installation.

What's Next

After you've installed macOS Sequoia, I've got recommendations for a Mac setup, including Mac name settings, Dock settings, and Finder settings.

For developing software on the Mac, you'll need to:

• Install Xcode Command Line Tools for missing command line tools
• Install Homebrew as a software package manager
• Install Git for version control

When you update macOS, you may also want to install newer software as well. Here are new and recommended applications for macOS Sequoia:

• Terminal alternatives
• Text Editor options
• ChatGPT desktop application for better ChatGPT usability

Conclusion

After October 2024, you'll need to update macOS from Sonoma to Sequoia to stay up to date with bug fixes, security, and software compatibility, especially if you are a software developer.

Before then, you can try out the macOS Sequoia beta to see what's new and provide feedback to Apple. See an article MacOS Beta for more details.

Though macOS Sequoia doesn't bring spectacular changes, new features like Window Tiling and the Passwords app are useful.

Installing the macOS beta takes an hour or more, but you may find it is stable enough for daily use, giving you access to new features now.

I recently wrote an article for freeCodeCamp titled "How to Install Python on a Mac", which provides a clear guide to installing Python on macOS.

As a follow-up, I will discuss errors you may encounter when installing Python on macOS and how to fix them in this article.

Contents

Here's what we'll cover here:

• How to Fix the "command not found: python" Error
• Using an Out-of-date Python
• Using the System Python
• Using the Homebrew Python
• Missing Pip
• Pip Package Installation Errors
• More on Mac Python
• Conclusion

How to Fix the "command not found: python" Error

You may encounter this error:

$ python ...
zsh: command not found: python

You'll see this when trying to run Python commands in the terminal. This mostly happens because Python is yet to be installed. However, it is also possible, and more frustrating, that the Python installation is not in the Mac PATH.

If you only need to install and run a Python application, you can use Homebrew to install Pipx. This will install Python as a dependency. Pipx is a tool that allows you to install and run Python applications as standalone executables, avoiding dependency conflicts that can occur when using the standard Python package manager Pip.

If you're going to work on a programming project in Python, install Python with Pyenv, the standard Python version manager. Better yet, install Python with Rye, an all-in-one tool for Python installation, virtual environment management, and package installation.

If you're seeing the zsh: command not found: python error, and are certain you have already installed Python, you may need to update the Mac Python PATH. You'll need to find where Python is installed on your system, which takes some sleuthing because there are multiple ways to install Python on macOS.

Here are the most common locations for Python on a Mac:

1. /usr/bin/python3 is the system Python installed with Xcode Command Line Tools. This is an alias; the actual location is /Library/Developer/CommandLineTools/Library/Frameworks/Python3.framework/Versions/3.9/bin.
2. /opt/homebrew/opt/python@3.12/libexec/bin/python is the Homebrew Python.
3. /Library/Frameworks/Python.framework/Versions/3.12/bin/python3 is the Python installed with the official Python website installer.
4. /Users/username/.pyenv/shims/python is the Python installed with Pyenv.
5. /Users/username/.rye/shims/python is the Python installed with Rye.

Enter the full pathname followed by python --version and see if you get a version number. If you do, you'll need to update your PATH by adding the Python installation path to your .zprofile file. For more information, see Mac PATH.

The article Command not found: python goes into more detail if you need more help.

Using an Out-of-date Python Version

The current Python version is 3.12, as of October 2023. New releases of Python come yearly, typically released in October. The next version, Python 3.13, is expected in October 2024. The newest Python version is listed on the Python website.

Check your Mac Python version:

$ python --version
Python 3.12.4

You should see Python 3.12.4 or a later version. You may not notice issues with an older Python version but it's a good idea to start any project with the newest version. The article about updating Python on Mac explains how to update Python on macOS.

Using the System Python

Macs no longer come with Python pre-installed. But you may have installed Xcode Command Line Tools which includes Python 3.9.6, an older Python version that supports Apple development utilities.

Try python3 --version and which -a python3 to check if Python was installed with Xcode Command Line Tools.

$ python3 --version
Python 3.9.6
$ which -a python3
/usr/bin/python3

If you have Python 3.9.6 installed at /usr/bin/python3, you'll likely have the system Python installed by Xcode Command Line Tools. You can confirm this with xcode-select -p which will show if Xcode Command Line Tools is installed.

$  xcode-select -p
/Library/Developer/CommandLineTools

It's possible to alias python3 to python but I would not recommend using the system Python for development. The system Python is intended for Apple utilities, not for you, so you should install Python on macOS separately if you want to run Python programs or develop in Python.

See my freeCodeCamp article How to Install Python on a Mac to install Python for development.

Using the Homebrew Python

If you use Homebrew as a software package manager, you can easily install Python with brew install python. Homebrew-installed Python is suitable for running scripts but it has drawbacks for installing Python applications or Python software development, when packages are installed.

• Homebrew's automatic updates. Homebrew automatically updates its Python as a dependency for other packages, potentially breaking your projects.
• Multiple projects may need different Python versions. Homebrew-installed Python is a single version and you may need to switch among different versions for different projects.
• Problems with environment isolation. Homebrew provides a single Python environment, which can cause conflicts between projects. Pip, the Python package manager, will block installation of packages unless you first create a virtual environment.

You can check if Python is installed with Homebrew:

$ brew list | grep python
python@3.12

For running applications, it's best to install Pipx and use pipx install instead of pip install to install programs. For Python development, it's best to install Pyenv or install Rye for Python version management and virtual environments.

Missing Pip

READMEs and tutorials often assume users are familiar with Python development tools and instruct them to install Python packages using Pip, the Python package manager. If you've followed instructions that start with pip install <package>, you may have run into the zsh: command not found: pip error.

This is the error you'll see:

$ pip install <package>
zsh: command not found: pip

Pip is installed automatically with Python, so it's unusual to run the python command successfully and then pip and see the error. If you have Python installed, you should be able to use the pip command. You can try a special command that installs Pip:

$ python -m ensurepip --upgrade

If Pip is not already installed, this command will install it. Otherwise, nothing will happen. With this error, it's more likely that you have a Python installation that is not in your Mac Python PATH. See the article Command not found: pip for more details.

Pip Package Installation Errors

You will need to use Pip to install Python packages, unless you are using Rye as an all-in-one tool. However, Pip has some drawbacks.

By default, the pip install <package> command installs the package "globally." This means that the package is added to the global Python site-packages directory, which may result in conflicts if different projects require different versions of the same package.

For example, if project A requires package==1.0 and project B requires package==2.0, installing both packages globally may result in conflicts and dependency hell. Without proper isolation, installing one project's dependencies can cause problems for another. To avoid these conflicts, create a Python virtual environment for each project.

There are two Python tools for creating virtual environments and using different versions of packages. Venv is a built-in Python package. Virtualenv is a more powerful tool with additional features. These tools allow pip to install Python packages into a virtual environment that has its own installation directories and does not share libraries with other virtual environments. Pip must be used in conjunction with either Venv or Virtualenv to successfully install packages.

When you try to install a package with Pip, you may see:

$ pip install <package>
error: externally-managed-environment

Recent versions of pip implement PEP 668 to prevent attempts to install packages globally, which results in the message error: externally-managed-environment. This error occurs when attempting to install a package globally without using a virtual environment. To resolve this error, create a virtual environment using Venv or Virtualenv and install the package within it.

More on Mac Python

You'll need to do more than install Python to begin a programming project, so I've also written a longer article about Mac Python that explains the fundamentals of version management, virtual environments, and package management, as well as comparing various installation options.

Conclusion

A variety of competing development tools means that it can be difficult to get started with Python compared to other programming languages such as JavaScript, Rust, or Ruby. Python is moving towards standardization of tools, and there's rapid innovation as the community seeks to improve the developer experience.

For now, developing Python skills requires some knowledge of the Python ecosystem, the various tools, and how to use them. Still, Python is popular and powerful, and the tutorials on freeCodeCamp will help you learn the language and become a better developer.

These shortcuts seem to originate from Unix (MacOS is built on top of Unix), and they work in Linux as well.

You may be asking: why should I bother learning these? Well I will tell you: I use these thousands of times each day. They dramatically speed up my typing and text editing. And I rarely ever have to use my mouse, the arrow keys, or take my fingers off the letter keys of my keyboard.

What is Swap Caps on Mac and Why Do it?

Caps Lock is a useless key. So I remap my Caps Lock key to instead be Control. Then I can easily move my left pinky over to hold it when I do these shortcuts.

You can do this in MacOS like this:

1. Go to Mac preferences

2. In the search box, type "modifier keys" and click it

3. Set Caps Lock to Control

Here's the full list of Control Shortcuts I use on Mac:

Movement

• Control+f – move the cursor to the right

• Control+b – move the cursor to the left (backward)

• Control+n – Go to the next line

• Control+p – Go to the previous line

• Control+a – Go to the beginning of the current line

• Control+e – Go to the end of the current line

Deleting / Substituting

• Control+h – backspace

• Control+d – delete the character to the left (this is like the traditional delete key on Windows, and as far as I know, this shortcut is the only way to delete this way on Mac)

• Control+t – switch the position of two characters

• Control+k – "yank" the current line of text.

• Control+y – "paste" the yanked line. Note that this uses a different clipboard than the traditional clipboard, so you can use to it have two things stored at the same time – one for your Command+v paste clipboard and one for your Control+y clipboard.

Again, once you get used to these, they'll save you a TON of time. Just a few milliseconds each time, but those add up very quickly over the course of a day at the keyboard.

Happy coding.

But it doesn't look messy if you create a specific directory for saving all the screenshots and your MacBook saves all the screenshots there automatically.

Configuring the settings might seem tricky for new MacBook users. So I will show you how you can do this within a few minutes with this step-by-step guide.

Keep in mind that although I am choosing the Pictures/Screenshots directory as my specific directory for saving all my screenshots, you can choose any directory you want.

For this article, I am using my newly purchased MacBook M1 Air (8/256) which is currently running on macOS Sonoma 14.4.1. But the same procedure is applicable for all the latest macOS versions as well.

A messy desktop full of screenshots :( (Source: Internet)

How to Choose a Different Location

Firstly, you need to select a specific location where you want to save all the screenshots directly.

In my case, I created a separate folder for saving screenshots inside my "Pictures" directory.

Directory where I want to save the screenshots automatically

How to Configure the Screenshot Tool

Now we need to configure the default screenshot tool on macOS so that it automatically saves the screenshot images to our desired location. Here's how you can do that:

1. Use Shift + Command + 5 to open the screenshot tool.
2. Click on "Options". Then click "Other Location...".
3. Select that specific location that you created earlier.
4. Now click "Ok", or "Open", or whatever it says to confirm that new location.

Screenshot tool's options. I captured it using my phone. :)

That's it! From now on, whenever you use the default screenshot tool, it will automatically save all the screenshots in that newly specified location. This will help your desktop remain clutter free!

Screenshot Shortcut

There are many people who still open the Screenshot tool using Spotlight or the launchpad. But there is a dedicated shortcut key for that!

You can use Shift + Command + 3 to take screenshot directly and save yourself a little time.

Conclusion

I hope you have learned something new from this article.

If you have enjoyed the procedures step-by-step, then don't forget to let me know on Twitter/X or LinkedIn. I would appreciate it if you could endorse me for some relevant skillsets on LinkedIn.

You can follow me on GitHub as well if you are interested in open source. Make sure to check my website (https://fahimbinamin.com/) as well.

Thank you so much! 😀

Cover image: Photo by Iewek Gnos on Unsplash

Zsh shell offers four configuration files with no discernible differences. Particularly, ~/.zshrc and ~/.zprofile appear to be identical, leaving us wondering which one to use.

In this article, you'll learn the difference and a simple guideline for your shell configuration.

Why Do you Need Configuration?

For programming on a Mac, the Terminal application is an essential tool in your development environment. The Terminal is a command-line interface (CLI) that allows you to interact with the operating system and run commands.

The Terminal or console gives you access to the Unix command line, or shell.

Zsh, also known as Z shell, is a program that runs in the Terminal, interprets Unix commands, and interacts with the operating system. Zsh is the default shell program on MacOS.

Before you get started with programming on the Mac, you'll need to configure the shell. There are optional and convenient settings, such as aliases for hard-to-remember commands and a custom prompt that can display the directory you're in, among other things.

There are also some critical environment variables that make programs available or alter shell behavior. The EDITOR environment variable, for example, can set your preferred text editor. Oftentimes, when installing a programming language or software utilities, you need to set the PATH environment variable..

Where to Start

Zsh configuration files are kept in the user's home directory and are named with a dot as the first character to keep them hidden by default.

Zsh recognizes four different configuration files in the user's home directory: ~/.zshenv, ~/.zprofile, ~/.zshrc, and ~/.zlogin.

This is where Zsh configuration becomes puzzling, even for experienced developers. Tutorials rarely explain the differences, especially between the zprofile and zshrc files, leaving curious developers scratching their heads and blindly following instructions.

How is the Shell Used?

To understand the differences among Zsh configuration files, consider various shell uses, which can be classified as interactive or non-interactive, login or non-login sessions.

1. On macOS, each new terminal session is treated as a login shell, so opening any terminal window starts an interactive login session. Also, a system administrator who connects to a remote server via SSH initiates an interactive login session.
2. If a terminal window is already open and you run the command zsh to start a subshell, it will be interactive and non-login. Beginners rarely use subshells.
3. Automated shell scripts run without login or any user prompting. These are non-interactive and non-login.
4. Few people ever encounter a non-interactive login shell session. It requires starting a script with a special flag or piping output of a command into an SSH connection.

How do the Configuration Files Work?

These use cases necessitate different shell configurations, which explains why Zsh supports four different configuration files. Here's how the configuration files are used:

• ~/.zshenv: This is loaded universally for all types of shell sessions (interactive or non-interactive, login or non-login). It is the only configuration file that gets loaded for non-interactive and non-login scripts like cron jobs. However, macOS overrides this for PATH settings for interactive shells.
• ~/.zprofile: Loaded for login shells (both interactive and the rare non-interactive sessions). MacOS uses this to set up the shell for any new terminal window. Subshells that start within the terminal window inherit settings but don't load ~/.zprofile again.
• ~/.zshrc: Loaded only for interactive shell sessions. It is loaded whenever you open a new terminal window or launch a subshell from a terminal window.
• ~/.zlogin: Only used for login shell configurations, loaded after .zprofile. This is loaded whenever you open a new terminal window.

How to Use Each File

With that in mind, let's consider which configuration files you should use.

• ~/.zshenv: It is universally loaded, so you could use it to configure the shell for automated processes like cron jobs. However, it is best to explicitly set up environmental variables for automated processes in scripts and leave nothing to chance. As a beginner, you will not use this configuration file. In fact, few experienced macOS developers use it.
• ~/.zprofile: Homebrew recommends setting the PATH variable here. There's a reason PATH should be set in ~/.zprofile and not the universal ~/.zshenvfile: the macOS runs a utility path_helper (from /etc/zprofile) that sets the PATH order before ~/.zprofile is loaded.
• ~/.zshrc: This is the configuration file that most developers use. Use it to set aliases and a custom prompt for the terminal window. You can also use it to set the PATH (which many people do) but ~/.zprofile is preferred.
• ~/.zlogin: This is rarely used. Only important in managing the order of initialization tasks for login shells in complex environments. It can be used to display messages or system data.

How to Avoid Complications

These configurations may appear complicated. It made sense in the early days of computing to start time-consuming processes at login and not have them repeat when a new terminal was launched.

MacOS now launches any new terminal window as a login shell, loading both ~/.zprofile and ~/.zshrc files without concern for the shell startup time. So why not use one Zsh configuration file? A bow to history, plus configuration customization for the experts.

The key advantage of the ~/.zprofile file (versus ~/.zshenv) is that it sets environment variables such as PATH without override from macOS. The ~/.zshrc file could be used for the same but, by convention and design, is intended for customizing the look and feel of the interactive terminal.

Keep It Simple

If you're looking for simple guidelines, here's the current best practice.

• Use ~/.zprofile to set the PATH and EDITOR environment variables.
• Use ~/.zshrc for aliases and a custom prompt, tweaking the appearance and behavior of the terminal.
• If you write automated shell scripts, check and set environment variables in the script.

More Information

I've written other guides that go into detail about the following:

• Mac Terminal
• Shell Configuration
• Mac PATH.

If you're just getting started, you'll need to know How to Open Mac Terminal and Install Xcode Command Line Tools.

Configuring the Zsh shell is a critical step in preparing your Mac development environment. With your development environment set up, you'll be prepared for any tutorial you'll find on freeCodeCamp.

In this tutorial, we'll use Tauri and Next.js to build a desktop-based cross-platform application and publish it to the Snap store and AppImage.

So why is building a cross-platform app, that works on Windows, Mac, and Linux, important these days? Well, it helps companies target a larger audience and increase their revenue, without having to build three separate apps.

Many companies and developers use Next.js as a front-end when building a website. In this tutorial, we'll use Next and Tauri to build a desktop-based cross-platform application that'll be available on Windows, macOS, and Linux.

Demo of the project

To build this cross-platform application, you need Tauri, markdown, Contentlayer, pnpm, and Next.js. If you check how my application looks, you can install the application with snap-cli, AppImage, or download the application via the link and install it.

Let's see what these tools do:

• we'll use Next.js for building the frontend part of the website
• the markdown npm package helps convert markdown files into HTML
• the Contentlayer npm package helps us manage markdown files in the project.
• we'll use Tauri to build the cross-platform application binary
• and finally, we'll use pnpm as our Node package manager.

// Install with snap
snap install static-blog-app

or

// install with AppImage
https://github.com/officialrajdeepsingh/static-blog-app/releases/download/v0.0.2/static-blog-app_0.0.2_amd64.AppImage

or

// Install on macOS
https://github.com/officialrajdeepsingh/static-blog-app/releases/download/v0.0.2/static-blog-app_0.0.2_x64.dmg

or

// Install on Windows
https://github.com/officialrajdeepsingh/static-blog-app/releases/download/v0.0.2/static-blog-app_0.0.2_x64_en-US.msi

Table of contents:

• What is Next.js?
• What is Tauri?
• Computer Architecture
• How to Create a New Project with Next.js and Tauri
• How to Build an Application with Tauri
• How to Build an Application for the Snap Store or Snapcraft
• How to Build a Cross-Platform Application with GitHub Actions
• How to Publish the App
• FAQ
• Conclusion

What is Next.js?

Next is a framework base on React. It has many features that let you build a website and enhance the user experience.

To learn more about Next, you can read this helpful tutorial I found on freeCodeCamp written by Reed Barger.

What is Tauri?

Tauri is a new framework that helps you build cross-platform desktop applications. Tauri is built based on the Rust language. Rust is faster, more secure, and has fewer memory issues than other languages.

Tauri has many features, but I'll mention some of the important ones for a front-end developer.

1. Tauri supports HTML, CSS, and JavaScript.
2. Tauri supports a lot of front-end frameworks and libraries, for example, React.js, Next.js, Vite, and Svelte kit.
3. With Tauri, you don't need to learn GTK, GJS, and app build commands or AppImage builder.
4. Tauri provides JavaScript API support. You can use it inside JS easily. For example, the window API helps all tasks related to the window.
5. You can quickly build a cross-application bundler size with one command.
6. Tauri provides an update handler to update older Tauri versions to the newest. You do not need to use other services and libraries to achieve the self-update functionality.
7. In Tauri, you call Rust functions within JavaScript.

Tauri improves the development experience by providing an inbuilt JavaScript, npm, and Rust CLI tool, plugins, and the tauri-action GitHub workflow.

All these tools help you write code faster and create a production-ready app in less time. But the big thing Tauri provides is beginner-ready, easily understandable documentation.

GTK is a free and open-source cross-platform widget toolkit for creating graphical user interfaces for applications.

GJS is a JavaScript library for Gnome to build application interfaces. GJS is built on the SpiderMonkey JavaScript engine.

Computer Architecture

Every operating system comes with different architecture. Building cross-platform applications or performing cross-compilation is not easy. Based on the architecture, you can understand where the application is run. In other words, which architecture requires running our applications like i386, ARM, or x86_64?

The most common architectures in the computer science world are ARM, i386, and AMD (x86_64). Less technical users might know it as 64 or 32-bit architecture.

Rust uses different types of architecture to install itself. In my case, my laptop hardware support x86_64 and I have Ubuntu installed. On Ubuntu x86_64, the default stable-x86_64-unknown-linux-gnu Rust toolchain is used to build Tauri applications.

The Rust toolchain builds AMD (x86_64) applications. That is why Tauri builds cross-platform application (for Windows, macOs, and Linux distros) but does not build cross-architecture ones (builds applications for all ARM, i386, and x86_67 architecture).

How to check your architecture in Linux by command:

cat /etc/debian_version

    or 

dpkg --print-architecture

    or

uname -m

    or

arch

How to check which toolchain Tauri is using:

The toolchain is a utility provided by Rust itself. You can install different toolchains with the rustup command.

You can use different types of Rust toolchains according to your computer's architecture. You can easily check which toolchain is installed in your operating system with the tauri npm, yarn, or pnpm command.

In my project, I'm using pnpm to create a new project, so I use the pnpm command. Again, based on the toolchain, we build apps for different architectures.

The default Ubuntu (x86_64) is based on the stable-x86_64-unknown-linux-gnu toolchain. The Rust stable-x86_64-unknown-linux-gnu toolchain builds only AMD-based applications.

The Rust toolchain is different according to the operating system and distro you're using. The default Rust toolchain is installed when you install Rust on your computer.

Here are the commands to check your architecture:

pnpm tauri info

or

yarn tauri info

or

npm run tauri info

pnpm tauri info command output

Tauri officially supports macOS, Windows, and Linux distros and you can't build mobile applications with Tauri (you'll face lots of issues, and after resolving them all you'll end up building your mobile app directly).

I found a great tutorial on the Rust toolchain as well as cross-compilation. The tutorial guides you and provides you with a deeper understanding of the Rust toolchain.

You can use the rustup command to install a different type of toolchain if you'd like. To learn more about the Rust toolchain and the rustup command, I'd suggest starting with the Rust toolchain docs.

How to Create a New Project with Next.js and Tauri

You can create a Tauri app with bash, cargo, PowerShell npm, yarn, or pnpm. We'll use pnpm to create a new Tauri set-up in this tutorial. pnpm is the new package manager for Node.js.

Create the UI template in Tauri

You can use different types of front-end frameworks for the Tauri app, for example, Vue, React, Svelte, Solid, Next.js, Preact, Angular, and Svelte. I've chosen to use Nextjs as the front-end template for our Tauri app in this tutorial.

pnpm - choose your UI template

Create a new application with pnpm

You can use any other node package manager to create a new app like yarn or npm. I choose the pnpm node package manager, because pnpm is fast compared to yarn and npm.

pnpm create tauri-app

Create tauri-app with nextjs

Now Tauri has created the my-demo app successfully. You can directly change the directory (folder) cd my-demo with the change directory (cd) command. Then you can run the pnpm install command to install all the dependencies required for the project. Finally, run the tauri dev command to lunch a new Tauri application window.

Run local development server in tauri

After downloading and compiling the code, you can see a new window open in your system using the pnpm tauri dev command.

Open a new window by tauri

The default Tauri folder structure comes with pnpm create tauri-app:

Tauri default folder structure

1. You use the next.config.js file for Next.js configuration.
2. The next-env.d.ts file automatically generates for TypeScript
3. The package.json file contains all information for npm, yarn, and pnpm.
4. The pnpm-lock.yaml file is created by pnpm to store all package information with the version.
5. The README.MD file contains all the information about the project.
6. The src folder contains all the Next.js code with pages, components, and CSS files.
7. You use the src-tauri folder for Rust and Rust configuration.
8. src-tauri/icons contains all icons for the app.
9. src-tauri/Cargo.lock generated by cargo to store all package information.
10. src-tauri/Cargo.toml generated by cargo and store all packages and confirmation for the project.
11. src-tauri/src used to write the Rust code.
12. src-tauri/target generated by the pnpm tauri dev command. It contains all the binary for the project.
13. tauri.config.json file used for Tauri configuration.

Create the UI for the app with Next.js

I'm using my old Next.js static site and I'll convert it into a desktop application. The Next static website code is available on GitHub so you can easily download it.

First, I need to copy my old posts along with the public, components, and pages folders and paste them into the new Tauri project. Then I'll remove the bootstrap CSS, and use Tailwind CSS to design the application's layout.

I already explained the process step-by-step on how to install TailwindCSS with Next in this article. You can read and follow the same setup to install Tailwind if you don't have it installed already.

Generate an icon for the application

The icon is important for the application. The user will click on the icon to open your application in Windows, macOS, and Linux.

Ubuntu static-blog-app icon

Generating icons for applications with various types and sizes can be complicated. You need icons for Windows, macOS, and Linux. Every operating system has its own guidelines for icons.

Tauri comes with a CLI tool that generates cross-operating system icons for applications based on icon configuration in Tauri. Here's the command to generate the icons:

pnpm tauri icon path-of-image

Generating icons

You can use an online website to generate icons for Tauri, and then add all icons into the tauri-app/src-tauri/icons folder.

You can change the icon configuration in the tauri-app/src-tauri/tauri.conf.json file:

"icon": [
        "icons/32x32.png",
        "icons/128x128.png",
        "icons/128x128@2x.png",
        "icons/icon.icns",
        "icons/icon.ico"
],

How to Build an Application with Tauri

To build the application in Tauri, you need to run only one command in the terminal. Tauri automatically generates the build applications.

The first application is for the .deb Debian-based distro and the second application is appImage. The application build file changes from operating system to operating system.

AppImage is a universal application distribution for the cross-Linux distro. So you create one AppImage and run your application on any distro.

pnpm tauri build

The first time you run the tauri build command, you may face a bundle identifier error in the terminal.

Bundle identifier error

To solve the bundle identifier error, first open the my-demo/src-tauri/tauri.conf.json file and find identifier. Then change the "identifier": "com.tauri.dev" value according to your app. Make sure the identifier value is unique across the application.

"identifier": "com.officialrajdeepsingh.blog",

After changing the identifier in the tauri.conf.json file, rerun the pnpm tauri build command.

Run tauri build command

After successfully running the tauri build command, Tauri generates two files:

1. my-demo_0.0.0_amd64.deb
2. my-demo_0.0.0_amd64.AppImage

The bot file binary works only for the amd64 architecture and doesn't work on the arm and i386 architecture.

The file extension tells us where we use it.

1. .deb file extension is used for Debian.
2. .AppImage file extension is used for all Linux distros to install the app.
3. .dmg file extension is used for macOS.
4. .msi file extension is used for Windows.
5. .snap file extension is used for the Linux distro.

Install .deb and .AppImage locally

To test for both binary my-demo_0.0.0_amd64.deb and my-demo_0.0.0_amd64.AppImage, first install them locally and check that everything is working fine.

.deb file

❯ dpkg -i static-blog-app_0.0.2_amd64

.AppImage file

Firstly add the file permission for executing and then run the file.

Step 1: run chmod +x my-demo_0.0.0_amd64.AppImage

Step 2: run ./my-demo_0.0.0_amd64.AppImage hit enter to run AppImage base binary.

Tauri automatically generates both .deb and .AppImage files with their own file names.

Both files use the same naming conversion syntax all around the world. This file name conversion is not for Tauri. The Flatpak builder and Snapcraft also use the same kind of file naming syntax.

Syntax

<name-of-appliciation> <version> <architecture> <File extension>

Example
1. my-demo_0.0.0_amd64.deb
2. my-demo_0.0.0_amd64.AppImage

How to Build an Application for the Snap Store or Snapcraft

Snapcraft or the Snap store is a Linux application distribution. It helps distribute your applications across Linux distros. Users can install your application with one click and the use of a command line (Terminal).

Snapcraft is maintained and built by Canonical (Ubuntu). Canonical provides all Linux application distributions and does not work for macOS and Windows.

Before building a snap, first you need to install Snapcraft.

sudo apt-get update
sudo snap install snapcraft --classic

How to build an application for the Snap store

I will guide you with a simple way to generate the snap file for Snapcraft. The snap file is a binary file, similar to the .deb file. The Snap store uses a special .snap extension for the file. That indicates that it's a snap application installed on a linux distro.

You can also develop your first snap app quickly if you are a beginner – simply follow these steps (we'll go through each one by one):

1. Install the tauri-snap-packager npm package
2. Add configuration in the package.json file
3. Build the snap
4. Handle any errors
5. How to fix the tauri-snap-packager takes too much time error

Install tauri-snap-packager npm package

Firstly install the tauri-snap-packager npm package in your project. The tauri-snap-packager npm package helps you create a snapcraft configuration file.

npm install --save-dev tauri-snap-packager

# Or with yarn

yarn add --dev tauri-snap-packager

# Or with pnpm

pnpm add tauri-snap-packager

Add configuration in the package.json file

After installation, complete the tauri-snap-package npm package. Now configure the "tauri-snap": "tauri-snap-packager" tauri-snap-package script in the package.json file.

"scripts": {
    "dev": "next dev -p 1420",
    "build": "next build && next export -o dist",
    "tauri": "tauri",
    "lint": "next lint",

    "tauri-snap": "tauri-snap-packager"

  },

Build the snap

Now you run the pnpm tauri-snap command in your project folder. tauri-snap automatically creates a snap folder in src-tauri/target. Inside the snap folder pnpm tauri-snap creates a new snapcraft.yaml file with all the configurations. All the configuration is based on your Tauri configuration.

name: static-blog-app
base: core18
version: 0.0.2
summary: Tauri app.
description: Awesome Tauri app.
grade: devel
confinement: strict
source-code: https://github.com/officialrajdeepsingh/static-blog-app
apps:
  static-blog-app:
    command: static-blog-app
    extensions:
      - gnome-3-34
    desktop: static-blog-app.desktop
parts:
  dump-binary:
    plugin: dump
    source: ./target/release
    source-type: local
    stage:
      - lib
      - icons
      - static-blog-app
      - static-blog-app.desktop
    prime:
      - lib
      - icons
      - static-blog-app
      - static-blog-app.desktop
    stage-packages:
      - libc6

How to fix the errors

You'll get an error while validating snapcraft.yaml with the pnpm tauri-snap command.

Issues while validating snapcraft.yaml

Your application name may contain some words that are not allowed, like spaces, numbers, uppercase letters, and so on. For example, Static-blog-website does not allow you to use your name with a capital letter. Simply use a small case word for a name like static-blog-website.

You might also see an error you need 'multipass' set-up to build snaps when running the pnpm tauri-snap --trace-warnings command.

The --trace-warnings Node.js flag helps debug or trace the error.

You need a multipass set-up to build snaps error.

To solve the error, you must install the multipass package in Ubuntu. The tauri-snap-package uses the Snapcraft command as a background to build a snap file. So Snapcraft requires multipass to build a snap package.

sudo snap install multipass

Install multipass in ubuntu

Tauri-snap-packager takes too much time.

If the tauri-snap-packager takes too much time to build the snap binary or you feel your application is stuck and does not show any output in the terminal, then just stop the command. The tauri-snap-packager isn't working for you, so you can use the snapcraft command.

Create a snap configuration with Tauri-snap-packager

This error means that the pnpm tauri-snap the command is not working and it takes too much time. It's likely because the tauri-snap-package npm package isn't working correctly.

To solve this issue, run the snapcraft command in the same folder where your snap folder was created. Before running the snapcraft command, first, install the snapd command tool. Snapd is a REST API daemon for managing snap packages. To learn more about snapd, I found a great article written by Oyetoke Tobi Emmanuel.

snap install --channel stable snapd

After installation is complete, run the snapcraft command in the tauri-app/src-tauri/target folder. The target folder is generated by the pnpm tauri dev command.

Face common error with snapcraft command

You may get a snap "core18" has no updates available error with Snapcraft. But the core18 is not a big issue. Simply update your distro package with the sudo apt-get update && sudo apt-get upgrade command, then restart your terminal or laptop. Here's a youtube tutorial that can help you solve your core18 error problem.

"Snapd has not logged" means that first, you need to login into your snapcraft account. For login run snapcraft login.

After you solve the core 18 issue, now run the snapcraft command again and build your snap binary file.

Create a binary with snapcraft

The Snapcraft creates a new binary static-blog-app_0.0.0_amd64.snap file. Now the static-blog-app_0.0.0_amd64.snap file is ready to publish on the Snapcraft website or snap store.

How to install static-blog-app_0.0.0_amd64.snap locally in the system

If you install the static-blog-app_0.0.0_amd64.snap file locally with the following command, you might find the signatures metadata error.

sudo snap install ./static-blog-app_0.0.0_amd64.snap

Here's the error:

cannot find signatures metadata error for snap

To solve this error, you need to run the snap command with the --dangerous flag.

Install snap locally package

How to Build a Cross-Platform Application with GitHub Actions

GitHub Actions is a continuous integration and continuous delivery (CI/CD) platform or pipeline that allows you to automate tasks like building, testing, and deployment.

You can triage GitHub actions on certain events like somebody pushing new code to the GitHub repository and running tests on the code. If the test passes then the code gets added to the main or master branch.

If you want to build cross-platform applications for Windows, macOS, and Linux, the easiest way is using the GitHub actions workflow. This workflow runs on a specific event like push, pull, and so on.

To try this out, you'll need to create a new action in your project. First, create a new .github/workflows folder. After in the workflows, create a file with any name with a .yml extension.

The Tauri app provides a GitHub action configuration. With Tauri actions, you can quickly build cross-platform applications for Windows, macOS, and Linux distros with the GitHub workflow.

name: Build application
on:
  push:
    branches:
      - 'main'
  workflow_dispatch:

jobs:
  release:
    strategy:
      fail-fast: false
      matrix:
        platform: [macos-latest, ubuntu-latest, windows-latest]
    runs-on: ${{ matrix.platform }}
    steps:
      - name: Checkout repository
        uses: actions/checkout@v2

      - name: Install Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 16

      - uses: pnpm/action-setup@v2.0.1
        name: Install pnpm
        id: pnpm-install
        with:
          version: 7.13.1
          run_install: false

      - name: Get pnpm store directory
        id: pnpm-cache
        run: |
          echo "::set-output name=pnpm_cache_dir::$(pnpm store path)"

      - uses: actions/cache@v3
        name: Setup pnpm cache
        with:
          path: ${{ steps.pnpm-cache.outputs.pnpm_cache_dir }}
          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
          restore-keys: |
            ${{ runner.os }}-pnpm-store-

      - name: Rust setup
        uses: actions-rs/toolchain@v1
        with:
          toolchain: stable

      - name: Install dependencies (ubuntu only)
        if: matrix.platform == 'ubuntu-latest'
        run: |
          sudo apt-get update
          sudo apt-get install -y libgtk-3-dev webkit2gtk-4.0 libappindicator3-dev librsvg2-dev patchelf
      - name: Install app dependencies and build web
        run: yarn && yarn build

      - name: Build the app
        uses: tauri-apps/tauri-action@v0
        env:
          GITHUB_TOKEN: ${{ secrets.STATIC_BLOG_APP }}
        with:
          tagName: v__VERSION__ # tauri-action replaces \_\_VERSION\_\_ with the app version
          releaseName: 'v__VERSION__'
          releaseBody: 'See the assets to download this version and install.'
          releaseDraft: true
          prerelease: false

Following the GitHub action, you can build your application on every push after successfully building the application and show all files in the GitHub release assets section.

Show all applications in the assets section.

How to Publish the App

Publishing the package is the core of this article. A lot of people build their own Linux applications. But then they can't figure out how to submit the app on various distributions like Snapcraft, AppImage, and Homebrew.

So now I'll show how to submit a static-blog-app to Snapcraft and AppImage.

How to publish the app into the snap store or snapcraft

To publish a new package on the snap store, make sure you have a .snap binary available. Otherwise, first, build the .snap binary for the application (which we already went over above).

Go to the target or whatever folder where you created the .snp binary. Then run the snapcraft command. Make sure you first log in with your Snapcraft account. For login, run snapcraft login. Then run the following command with the argument I mentioned:

Syntax:

snapcraft upload <Opation> name-of-file

Publish a new package to snap in devel release

After successfully getting into your account, then you can add or change the information regarding your package icon, name, and so on.

snapcraft upload --release=stable ./static-blog-app_0.0.0_amd64.snap

In the devel mode, you'll see a message on the application installation page. devel means development mode.

Application in development mode

By default, your package publishes all the information collected by src-tauri/target/snap/snapcraft.yaml in the edge release. To understand more about the Snapcraft release system, you can read the release documentation.

Go to the dashboard and add or update all the information regarding the app.

Make sure to use a banner image with a size of 720 x 240 for the snap.

How to publish your application on Snapcraft

When you upload your application to your Snapcraft account, your application is private. To change how it's published, drag your available release into one of the release channels.

Go to the dashboard> my snap> select your snap> releases, and according to your requirements, add your application to one of the provided releases. The default is edge release.

How to add an application to a stable release

To change the application to a stable release, go to the snap configuration src-tauri/target/snap/snapcraft.yaml file and update your grade: devel to grade: stable:

....

grade: stable

....

Now your application goes to stable release or channel and re-uploads your application.

The application automatically goes to a stable release if you do not mention- release tags.

Now you've successfully released your application in a stable release.

How to update your snap application

For updating the snap application, you need to make changes in the tauri/target/snap/snapcraft.yaml file in the version section.

...

version: 0.0.1

or 
version: 1.0.0

or

version: 0.1.0

...

Now rebuild your application with the snapcraft command.

Rebuild your application

After successfully building your application, re-upload your latest build, and your application will be updated on the snap store website.

Update your application in snapcraft

How to publish applications in AppImage

AppImage helps you distribute your application across Linux distros. You don't need to install AppImage for it to work in your system.

Publishing the application on AppImage is a straightforward process. First, you need an AppImage URL and a GitHub account.

First, go to the appImage GitHub repository and click on this link.

Click this link

After that, a new page is opened in the browser:

Submit pull request in AppImage

1. Add your application name.
2. Paste your image URL
3. Add comment
4. Click the new propose file button.
5. Download the appimage.github.io repo in your GitHub account
6. Create a new pull request into the appimage.github.io repository.

Create a pull request into appimage.github.io

7. Add the comment and click the create pull request button.

Add comment and Create a pull request into appimage.github.io

Now your application is successfully submitted to the appimage.github.io repository. The appimage.github.io runs GitHub actions based on your application. Your application should pass all tests run AppImage. After that, your image should be successfully listed on AppImage so everybody can download your application.

If you submit an application on AppImage with a pull request, your GitHub action test will fail. You'll see the GLIBC_2.29' not found error.

I tried many ways to solve this issue, but I couldn't find a solution. If I do, I'll update my repository as well as this article.

_GLIBC2.29 is not found

FAQ

If you're building the application with Tauri, do you have to code in Rust?

No, you can build an application without writing a single line of code in Rust. Instead, Tauri provides JavaScript and TypeScript API support for front-end development to handle a lot of stuff like clipboard, dialog, event, HTTP, notification, and so on.

How do you build cross-platform architecture (cross-compilation) with Tauri?

You can build an application cross-architecture (cross-compilation) with Rust. Rust Toolchain helps you build cross-compilation applications.

What is the toolchain in Tauri?

The Rust toolchain helps you build an application on a different architecture. In rust, there are 86 toolchains available for a different architectures.

❯ rustup target list

Can you use Tauri to build an Android or IOS application?

No, you can't use Tauri to build applications for Android and iOS. But there is a library that helps you build applications for mobile phones – I just haven't tested it yet. You can build applications with a toolchain. I'll soon write an article about this on my website.

What are Tauri JavaScript and TypeScript API?

Tauri provides a different type of API that helps enhance the user and developer experience. You can use the API to handle notifications, dialog, events, HTTP, and so on.

Conclusion

It's relatively easy to build cross-platform applications with Tauri. You can use any front-end framework for the application.

But other frameworks don't let you build various cross-architecture and cross-operating system applications, for example, Windows, macOS, and Linux distros.

Tauri comes with strong backend language support. With Rust, you can do anything you can with a low-level language. In addition, Rust provides memory safety, no garbage collector, and so on.

When building the Tauri application with Flatpak, I couldn't find a development and distribution solution. However, in the future, I will add it to the GitHub readme file.

I haven't covered how to distribute applications on Windows and macOS. I'm a Linux user and do not test applications on Windows and macOS. But there are lots of articles and videos on the internet you can check out to learn how to do that.

MacOS has a popular distribution platform called homebrew. The homebrew distribution system is similar to appimage.org. If you submit a new pull request for your application and pass all tests, your app shows on homebrew.

If you have any questions or suggestions related to developing and distributing a Tauri application, you can ask for help on the Tauri GitHub discussions.

Maybe you just got a new laptop, or you're getting into tech for the first time with a MacBook. Either way, I've got you covered.

This short article will help you understand how to set up Git on macOS so you can get back to work immediately.

I assume you already know what Git is and what it does before reading this article. But if you don't and need an introduction to Git and version control, you can check out this article on What is Git? A Beginner's Guide to Git Version Control.

Let's now get started.

How to Install Git on a Mac

There are so many methods available to install Git on a Mac computer, but the easiest is by using Homebrew. You can find other methods and how to make them work in this documentation or here.

How to Install Git with Homebrew

Homebrew is a free and open-source software package management system that simplifies software installation on Apple's operating system (macOS). You can use it to install all types of packages you will need in the future, not just Git. This makes it really useful.

You don't need to install an application or anything to install Homebrew. You only need to open the terminal and install Homebrew by running the following command:

$ /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Note: Once you enter the command, it will request your password.

Once that is successful, you can proceed to install Git via the command below in your terminal:

$ brew install git

At this point, if it's successful, you've installed Git on your Mac. You can now verify by running the command below in your terminal:

$ Git --version

How to Configure Git in macOS

So far, you have learned how to install Git – but installing Git alone doesn't just let you push, pull, and commit code and perform other Git operations from your Git Version Control.

To work with Git, you must set up your Git environment using the git config command. This will give you access to configuration variables that control how Git works on your system.

Two significant git config variables you need are the identity variables. These let you set your username and email. This is the username and email you used when setting up your version control system with GitHub, GitLab, and so on.

$ git config --global user.name "olawanlejoel"
$ git config --global user.email "mymail@gmail.com"

Note: Replace the name and email with yours. You should also know that the --global option ensures that these values are used throughout your system.

Once you've done this, there are a couple of other configurations you can do, which are to setup the default text editor and colors for your Git console:

$ git config --global core.editor emacs
$ git config --global color.ui true

You can choose whatever editor you regularly use. I've chosen EMACS.

Now Git is ready for you to use. You can check your Git configurations to be sure they are correct using this command:

$ git config --list

This will show the following (with your own information):

user.name=olawanlejoel
user.email=mymail@gmail.com
color.ui=true

Suppose there is an error, and you wish to change any of the configurations. Feel free to rerun the config command particular to the error.

For example, if there is an error with my email, I can rerun the email configuration to correct it:

$ git config --global user.email "mynewmail@gmail.com"

Now, when you rerun the --list command, you will get the updated value:

user.name=olawanlejoel
user.email=mynewmail@gmail.com
color.ui=true

Wrapping Up

In this article, you have learned how to set up Git on a Mac computer for the first time.

If you also want to check out how to do it on other systems like Windows and Linux, check out this comprehensive guide.

Also, if you are also interested in learning some basic Git commands, here is a detailed cheat sheet.

Have fun coding!

Here is what we'll discuss in this guide:

1. What is DNS cache?
   1. Why flushing DNS cache is important
2. How to flush DNS cache on MacOS
   1. How to access the terminal application on MacOS
   2. How to clear DNS Cache for your MacOS version

What is DNS Cache?

DNS acts much like an internet phonebook. Think of what a phonebook does – it maps a person's name to their respected phone number.

DNS (short for Domain Name System) maps domain names to their associated IP addresses.

A domain name, such as freecodecamp.org, is easily read, understood, and recalled by humans.

IP addresses (IP is short for Internet Protocol) is an address that is machine-readable and consists of a unique series of numbers. These numbers identify a device connected to the Internet.

Their format is not that human-friendly since it is hard to remember an exact sequence of numbers each time you want to visit a website.

DNS then maps freecodecamp.org to its associated IP address - 104.26.3.33.

Think of the DNS cache as a local storage area on your Mac.

It temporarily stores and keeps track of your computer's activity records like recent website visits.

Each time you visit a website by typing its URL (short for Uniform Resource Locator), the DNS cache will save the IP address associated with that website.

When you visit that same website for the second time, the lookup process is more efficient, and the lookup time is much shorter.

It helps save significant time.

Why Flushing DNS Cache Is Important

You should flush the DNS cache for a few reasons.

The two most important ones are:

1) Flushing DNS is a helpful step for troubleshooting Internet connectivity issues.

You may be getting DNS errors in your browser, such as the 'DNS Server Not Responding' message when trying to access a site and establish a connection.

Keep in mind that your local cache information can become outdated over time.

When DNS updates happen on a website, your Mac is still using the old, inaccurate information to load the requested page.

Flushing the DNS cache makes sure cache information is up to date.

2) Flushing the DNS cache prevents network security threats, malicious attacks, and DNS cache poisoning from happening.

Hackers can access and corrupt your saved DNS cache records.

For example, they could manipulate and change the IP address associated with a Domain Name of a website you have already visited and map it to a malicious one.

The next time you request to access that same website, there will be a redirection to a fake and corrupted URL.

Hackers can request personal and sensitive information, such as credit card numbers, and steal it.

Frequent flushing of the DNS cache will help prevent this from occurring.

How to Flush DNS Cache on MacOS

Clearing the DNS cache on your Mac is a relatively straightforward process, even if you don't have a lot of technical knowledge.

Here is what you will need:

• Access to the command line,
• Your computer password,
• To enter a text command (the command will depend on the version of macOS you are running).

How to Access The Terminal Application on MacOS

macOS has a built-in CLI (Command Line Interface) named Terminal.app, which allows you to enter text-based commands that the Operating System will carry out.

There are a few ways to open the terminal.

The easiest way is through Spotlight search.

For this, you can:

• Either navigate to the very top right corner of the screen and click on the icon that looks like a magnifying glass.
• Or, you can also use the Command Space shortcut.

Both will open up the following window:

From there, start typing terminal and click on the Terminal.app option that appears.

You should see a window open that looks similar to the following:

How to Clear DNS Cache For Your MacOS Version

In the terminal window, you will then need to enter a command.

The command is different depending on the version of macOS you are running.

Each version of macOS has a version number and a version name.

To find out the macOS version on your computer, click on the Apple icon at the very top left corner of your screen. From the dropdown menu that appears, select About This Mac.

In the Overview tab, you will first see the version name. Then, underneath that, you will see the version number.

In the table below, you will see the versions of macOS in reverse chronological order – from the most recent one to the oldest one.

Navigate to your version of Mac and copy the respective command.

After typing the command and hitting enter, there will be a prompt for entering your computer's password.

Keep in mind that when you are typing your password, you will not be able to view what you are typing – not even any asterisks.

It appears as though nothing is happening, but rest assured that something is.

Once you have entered your password and hit enter, you will not see a message indicating that the process is complete.

Instead, you will view a new terminal prompt.

Conclusion

And there you have it – your local DNS cache is now clear.

Hopefully, this has helped resolve any connectivity issues you may be experiencing.

Clearing DNS frequently is always a good idea to help fix troublesome internet connections and ensure your system is secure from potential threats.

Thanks for reading!

When using Python, you may install different version variations for different projects. But sometimes this can affect how your code executes, as it may not use the correct version.

In this article, we'll learn how to install new Python versions (Python 3 in our case) and how to set this version as the active version for code execution.

Install Pyenv

If you're familiar with NodeJS, you'll know that nvm is used for managing versions of Node in different environments. pyenv does the same thing for Python – it's a version management tool.

This tool helps you to work on different environments which require different versions of Python.

Install pyenv using Homebrew with the following command:

Here's the command to install Python 3 on Mac:

brew install pyenv

Make sure you follow the rest of the steps for installing pyenv in the documentation.

Install Python 3

With pyenv installed, you don't need to install Python with Homebrew anymore (as you may already be doing). You can install Python using pyenv with the following syntax:

pyenv install [version]

The version argument follows semantic versioning which is "major.minor.patch".

For Python 3, let's say we want to install 3.10.2. Then we'll use this command:

pyenv install 3.10.2

To see the list of the Python versions we have, we use the following command:

pyenv versions

In my case, I have:

Currently installed python versions on my system

From the screenshot above, the asterisk shows the currently active Python version, which is the default system version:

python --version
# Python 2.7.18

To set the newly installed version as the default, here's how to do it (among many other ways):

pyenv global 3.10.2

python --version
# Python 3.10.2

If your python version remains the same, you have to make sure that you add the required init command as you can see in the documentation: Basic GitHub Checkout – 2. Configure your shell's environment for Pyenv

With all that in place, you can now use Python 3.

Update Python Version

With more versions being released, you may want to update your version. You can update your version by installing a new version, making it your global default, and optionally uninstalling the old version.

Here are the commands for that:

pyenv install new.python.version

pyenv global new.python.version

pyenv uninstall old.python.version

Thank you for reading! I hope you now have the version of Python installed that's most useful to you.

When you're coding, you're writing various text that can be executed by different language compilers. And what makes this text fun and easy to write are the editors that we use.

Different editors have different features. But they have a common goal: making writing code easier – easier to compose, debug, and read.

In this article, we'll look at five code editors that can improve development on your Mac device.

1. Sublime Text

Sublime Text is a lightweight editor with many features for improving your code-writing experience. Here are some of its features:

Multiple view panes

Multiple view panes

Sublime Text offers multiple view panes for writing code. This way, you can view multiple files at once.

What's more fun is you can open the same file in two panes. This feature can be helpful when you're writing code in a file with long lines of code, as you'll be able to scroll to the top in one pane and then write in the bottom of the other.

Side-by-side view for Type Definitions

Instead of just viewing type definitions in a small popup or opening the definition file that overrides the current view, Sublime Text provides a side-by-side view of a definition file for the types in the current file.

Multiple Selections

Multi-Line Selection Text Entry with Sublime Text

There are two forms of multi-selections: multi-selecting the same characters or different characters.

Same character selection

Say you want to rename a literal (variable, function, and so on) in multiple places. Sublime Text allows you to highlight the literal, and using Ctrl/Cmd D you can select other occurrences of that literal and edit, replace, or do what you want.

Different characters selection

Maybe some literals are spelled differently, but you want to highlight them together. Sublime allows you to use your mouse to highlight many things at once and operate on them as you choose.

2. VSCode

The VSCode editor offers syntax light, IntelliSense features (autocompletes, code hinting, and more), custom configurations, and room for different plugins. VSCode also allows multiple selections and multiple view panes.

Here are more features of VSCode:

Code Debugging

With VSCode, you do not need to debug on your browser or other tools.

Debugging in Visual Studio Code

VSCode allows you to debug right from your editor using breakpoints, the call stack, and even an interactive console.

Many extensions for different things

VSCode has a large marketplace for different languages, frameworks, and even your editor. You have extensions that beautify your editor's appearance and experience and tools that help with autocompletion when writing code.

Managing Extensions in Visual Studio Code

Built-in Terminal

With VSCode, you have a a built-in shell terminal where you can execute commands without leaving your editor to go to a different terminal app.

The terminal view of VSCode

A small screen may make your editing view small and a bit inconvenient, but with a large monitor, for example, the view is just okay.

VSCode also has multiple view panes, character selection, and multiple character replacements.

3. Atom

Atom is a highly customizable code editor. This is why the team calls it a "hackable text editor". From the appearance and colors on the editor to the key combinations for commands and many other things, you can customize Atom as much as you wish and make it very personalized.

Here are some features:

Real-time Code Collaboration

Teletype for Atom

Atom has a Teletyping feature that allows multiple people to work on a codebase in real-time. This feature improves collaboration in a team workspace on projects. For VSCode, you'll usually need an extension for this.

Git Integration

With Atom, you never have to go to your terminal for your Git operations.

GitHub for Atom

Git actions are integrated into Atom using the GitHub package, and this creates a smooth version control experience while you write code.

Smart Autocompletion

With many languages and syntaxes integrated into Atom, you also get a nice auto-completion feature while writing code.

Autocomplete (atom.io)

You don't have to type out those long method and variable names anymore. Atom's smart enough to help you avoid that 😉.

In Atom, you also have search and replace features, view panes, and more.

4. WebStorm

WebStorm calls itself "The Smartest JavaScript IDE". It takes a lot of confidence to call itself that, and WebStorm actually delivers. WebStorm makes writing JavaScript and its related technologies not just convenient but more enjoyable.

Some features include:

Built-in developer tools

WebStorm takes the name "development editor" quite literally. From running scripts to breakpoints and general debugging, WebStorm provides developer tools that allow you to write, execute and debug your code.

WebStorm: Integrated Developer Tools

Smart features

This editor allows you to move files between folders seamlessly. It also helps you refactor your code and suggest fixes for errors.

And the most brilliant feature I love about it is that you can easily rename a specific variable across your application. Say you have a variable you've imported in many files – you can easily rename that variable from one of the files.

Fast search and navigation

Another fantastic feature of WebStorm, which people generally praise it for, is the fast file or folder search and navigation.

WebStorm: Navigation and Search

From searching file names, class names, function names within files, and special selectors, you can easily find a file you're looking for.

There's also collaboration, view panes, search and replace in WebStorm.

5. Vim

And there's Vim. It's worth noting that Vim is not for everyone, as it arguably has a steep learning curve – but Vim has many features that make it worth trying out. I have a friend who's never letting go of Vim and keeps advocating that people are missing out.

Here are some features:

High Customizability

I mentioned earlier that Atom is highly customizable, but I don't think it's as flexible as Vim.

Vim customized to be like SublimeText

Down to the low-level commands and feel of the editor, you can configure many things that makes using another editor very strange for you. You can also create scripts that automate things for you.

Support for Many Languages and File Formats

Vim has support for many languages and files of different kinds. It also integrates with many tools.

Powerful search feature

With powerful selectors and regex, you can do multi-level file searches and replacements. With Vim's scripts, you can also get plugins that take the search features to another level.

Agreed, it's not very easy to learn. But it's pretty powerful and consumes less memory, surprisingly. It also has an extensive script system that gives you much power while writing code.

Wrapping Up

There you have it - five code editors you can use to write cleaner, more readable code. I hope you find the one that best fits your needs!

Thanks for reading :)

And what's often worse than the problems themselves is that they seem to occur when we're in the middle of an important task that needs to get done.

The computer starts to significanlty slow down and an app we are using might freeze for a while. The computer's fan then starts to get louder and louder and that dreaded – but colorful – spinning wheel may even make an appearance.

Fortunately, there are certain steps you can take to fix different problems, get to the root of them, and see what caused them in the first place.

In this article you'll learn about the essential Task Manager tool on MacOS. You'll see how using it gives you insight to help diagnose and troubleshoot problems.

The First Step of Troubleshooting

The first action to take when an application or program you're using freezes and is no longer responsive is to use the following keyboard shortcut: Command Option Esc.

Hold down those three keys at the same time.

This will launch the Force Quit Applications Manager window:

This window shows a list of all the applications that are currently open on your computer.

As the helpful instructions indicate, select the application that has frozen and is no longer responsive. Then next click the Force Quit button.

💡 Another way to access this window is by selecting the Apple icon at the top left corner of your screen by clicking on it. A dropdown menu will appear and from there select "Force Quit".

The application you selected will be closed and terminated immediately.

It's a handy and quick solution for closing a program that is not working and is unable to stop properly.

But this method doesn't give much information about what could be causing the problem. It's useful for just force-quitting an application.

MacOS Activity Monitor

If you were a Windows user in the past, you may be familiar with the Task Manager for troubleshooting problems.

The Activity Monitor is the equivalent system for measuring your computer's activity on a Mac Operating System - it is just under a different name.

It shares a lot of similarities with the Window's counterpart. It locates and shows all the processes currently running and how different applications affect the computer's performance.

So, to dig a bit deeper and gather more information on how the program that has frozen affects your computer, it's helpful to launch the Activity Monitor.

From there you can close or force quit programs, background processes which are not open and visible by default, or apps that have frozen up and are unresponsive and hanging.

How to Open the Activity Monitor

The easiest and most straightforward way to open the Activity Monitor is with the Spotlight button.

The Spotlight button is located in the menu bar at the top right corner of your Mac's screen and looks like a magnifying glass.

To access the Spotlight button you can just click on it:

💡 Another way to access Spotlight is by using the Command Spacebar keyboard shortcut.

Then, the Spotlight Search will appear. Start enetering the input for what you're looking for – in this case type the words Activity Monitor and it should come up.

Hit Return and double click on the first option that appears.

Once you've completed those steps and opened the Activity Monitor, you can optionally keep it in the Dock for easy and fast access in the future.

Click and hold down on the application's icon. From there, once the dropdown menu appears, select Option and then Keep in Dock.

Now the application is pinned in your Dock.

How to Use the Activity Monitor

An Overview Of The Five Tabs in Activity Monitor

Once the Activity Monitor Window is open, you can take a deeper look into the current processes that are running on your computer.

There are five tabs available at the top of the window:

In the "CPU" tab which is the first one opened by default, you can see information on CPU usage.

For example, here you can see how the activities are affecting the processor's performance and how many processor resources are being used. It shows which applications are doing the heaviest work.

This is one of the two most useful tabs to check when problems occur. When the fan starts getting loud, the computer heats up and your battery starts going down fast. Check this tab to see which application is consuming most of the CPU's resources.

Quitting that app may then stop the problem.

In the "Memory" tab you can check memory usage and load. You see statistics and information on how much RAM (Random Access Memory) the different applications are consuming at the time.

This is the second most important tab to check when an application freezes. When an application freezes and your computer really slows down, it could be a sign that RAM is being overused and maxed out. It could also indicate that your computer is running out of sufficient RAM and that's why it is not functioning to the best of its abilities.

The "Energy" tab shows how much energy and power is being used by each application for each process that is running. This tab shows which applications are consuming the most energy and are draining battery life.

The "Disk Tab" shows the disk usage. It indicates how much data is being read from and written to your disk storage device. Here is also a good place to detect potential malware.

Lastly, the "Network" tab shows which applications on your Mac send and receive the most data from the network.

You can select either of these tabs to further investigate the issue you're having.

How to Search for Applications in Activity Monitor

There might be a long list of running processes.

To narrow them down and search for a specific application, use the search bar that is located at the top right hand corner of the window.

Type the name of the app you're looking for and if it is currently up and running it will appear as a result.

How to View More Information About Applications in Activity Monitor

First, select a particular application from the list of current running processeses that you're interested in learning more about by clicking on it.

Once you've selected it, that line will be highlighted.

Then, click on the i button (for Inspecting) at the top left hand corner.

A pop-up window will appear, with additional information on the application.

This window will have three different tabs: "Memory", "Statistics" and "Open Files and Ports".

In Memory you'll see how much RAM is running.

In the Statistis tab you can see the number of threads, the CPU time, and more technical insight.

The "Open Files and Ports" tab will show all the names of files that are currently running.

How to Force Quit an Application in Activity Monitor

To quit or force quit any of the processes listed in the Activity Monitor, select the application you want to stop from running.

Then select the x button at the top left hand corner, which acts as the Stop button.

You'll see a pop up window appear asking you to confirm that you want to terminate the process. It will mention the name of the application you want to stop running in double quotation marks.

Select "Quit", and if that fails to close the app, choose "Force Quit" and the application will close immediately.

Keep in mind that you may end up losing data if the app froze and you didn't manage to save any progress or files you were using.

An Alternative to Activity Monitor

If you're a developer you may prefer working with the terminal.

Using just one command, you can see a list of the current running processes.

Navigate to spotlight again and this time type in "Terminal". The built-in terminal application for MacOS will launch.

You'll see the command prompt which is right after your computer's username.

By default, if you haven't applied any custom styles for the Zsh shell, the command prompt is a % sign.

A shell is a computer program that interacts with the underlying operating system through text-based commands it receives as input.

Zsh is one of the many different Unix shell types available. The Zsh shell is the default shell for MacOS Catalina and later.

After the command prompt, enter the command top and hit return.

You'll see a list of all the current running processes:

To stop this, enter Control C which sends a signal to the command to terminate. You'll be back to the command prompt immediately.

When the top command is executing, you may see a process that is using too many resources. It may be a good idea to kill it, which is another word for terminating a process.

To do so, first locate the PID (Process ID). This number is located in the first column at the left hand corner when the top command is executed.

To continue, make sure you are at the command prompt.

Then, type the kill -9 PID, where PID the number of the process you want to terminate.

For example, if I wanted to force quit the terminal application I am currently using which has a PID of 7728, I would write the following: kill -9 7728.

The application will then close immediately.

Conclusion

Thanks for making it to the end. Hopefully you found this helpful and were able to troubleshoot any problems you were facing with your Mac computer.

You learned about the Activity Monitor which is the equivalent of the Task Manager available on Windows PCs. You also leared how to use the command line to terminate processes that use too many of the computer's resources.

Thanks for reading!

Here is what the Quick Notes feature looks like when you move your cursor to the lower right hand corner of the screen:

The New Quick Note feature in the lower right hand screen of MacOS Monterey

I like a lot of MacOS Monterey's features, but I didn't like this popping up so frequently when I was moving my mouse around. So I disabled it. You can do this, too, and it only takes a few seconds.

How to Disable the New Quick Note Feature in MacOS Monterey

First of all, navigate to your MacOS preferences.

Step #1: Open System Preferences

The fastest way to do this is to press Command + Space to open up Spotlight.

Then type "pref" and you should see a System Preferences option.

MacOS Spotlight is a helpful way to open up applications quickly. You can open it by pressing Command + Space

Step #2: Open Mission Control Preferences

Click the Mission Control icon pointed to above

Step #3: Click the "Hot Corners..." button

The Hot Corners button is in the lower left-hand corner

Step #4: Disable the Quick Note Hot Corner Gesture

You can now disable the Quick Note hot corner. If you prefer, you could instead assign this hot corner to something else. I personally find these hot corners more distracting than helpful, and turn all four of them off.

Remember: anything you can do with a hot corner, you can do with the MacOS built-in Spotlight feature.

Click the drop down for the lower-right hand corner and set it to "–" which means nothing will happen when you move your cursor to the lower right hand corner of your screen.

Step #5: Click the OK Button and Close Mission Control

Congratulations. You have disabled the Quick Note hot corner. It shouldn't pop up anymore.

I hope this has been helpful. Have a fun, productive day.