What is a Palette Menu?

A palette menu is an NSMenu whose items are presented horizontally instead of vertically, making it useful for compact groups of related choices: colors, tags, flags, drawing tools, annotation filters, ratings, priorities, and other visual options.

The Palette Menu Objective-C API

@interface NSMenu (NSPaletteMenus)

// Creates a palette menu displaying user-selectable color 
// tags using the provided array of colors and optional titles.
+ (instancetype)paletteMenuWithColors:(NSArray *)colors 
                               titles:(NSArray *)itemTitles 
                     selectionHandler:(nullable void (^)(NSMenu *menu))onSelectionChange API_AVAILABLE(macos(14.0)) NS_REFINED_FOR_SWIFT;

// Creates a palette menu displaying user-selectable color tags
// using the provided template image, tinted using the specified
// array of colors.
+ (instancetype)paletteMenuWithColors:(NSArray *)colors 
                               titles:(NSArray *)itemTitles 
                        templateImage:(NSImage *)image 
                     selectionHandler:(nullable void (^)(NSMenu *menu))onSelectionChange API_AVAILABLE(macos(14.0)) NS_REFINED_FOR_SWIFT; 

// The presentation style of the menu. 
@property NSMenuPresentationStyle presentationStyle API_AVAILABLE(macos(14.0));

// The selection mode of the menu.
@property NSMenuSelectionMode selectionMode API_AVAILABLE(macos(14.0));

// The menu items that are selected. 
@property (copy) NSArray *selectedItems API_AVAILABLE(macos(14.0));

@end

Unfortunately designing a palette menu in Interface Builder is not supported. There are two main ways to create a palette menu:

1) Use AppKit’s color-palette convenience constructors.
2) Create a normal NSMenu and set its presentationStyle to NSMenuPresentationStylePalette.

Example 1: A Simple Color Tag Palette

Here is a compact color picker for assigning a tag color:

// Helper method that builds the color tag picker.
- (NSMenuItem *)tagColorMenuItem
{
    NSArray *colors = @[NSColor.systemRedColor,
		                   NSColor.systemOrangeColor,
		                   NSColor.systemYellowColor,
		                   NSColor.systemGreenColor,
		                   NSColor.systemBlueColor,
		                   NSColor.systemPurpleColor,
		                   NSColor.systemGrayColor];
	
     NSArray *titles = @[@"Red",
	                             @"Orange",
	                             @"Yellow",
	                             @"Green",
	                             @"Blue",
	                             @"Purple",
	                             @"Gray"];
	

     NSMenu *paletteMenu = [NSMenu paletteMenuWithColors:colors
		                                  titles:titles
		                        selectionHandler:^(NSMenu *menu) 
     {		
         NSMenuItem *selectedItem = menu.selectedItems.firstObject;
	 NSInteger selectedIndex = (selectedItem) ? [menu indexOfItem:selectedItem] : NSNotFound;
	 if (selectedIndex != NSNotFound)
         {
	    NSColor *selectedColor = colors[selectedIndex];
	    NSLog(@"Selected color: %@",selectedColor);
	    // TODO: Apply the selected color here.
	 }
      }];
	
      paletteMenu.selectionMode = NSMenuSelectionModeSelectOne;
      
      // Wrap the paletteMenu in an NSMenuItem.	
      NSMenuItem *parentItem = [[NSMenuItem alloc] initWithTitle:@"Tag Color" action:nil keyEquivalent:@""];
      parentItem.submenu = paletteMenu;
	
      return parentItem;
}

To display the palette menu we simply add the item returned from the -tagColorMenuItem method to an NSMenu and present it like any other menu. The code below demonstrates how to do this:

// -showPaletteMenu: here is the action method of an NSButton.
-(void)showPaletteMenu:(NSButton*)sender
{
    NSMenu *menu = [[NSMenu alloc] initWithTitle:@"Palette Menus"];
    [menu addItemWithTitle:@"Palette Menus" action:nil keyEquivalent:@""];
    [menu addItem:[self tagColorMenuItem]]; // <-- This line adds the palette menu.
    	
    NSPoint location = NSMakePoint(NSMidX(sender.bounds) - (menu.size.width / 2.0),
		                   NSMinY(sender.bounds) + (menu.size.height));
	
    [menu popUpMenuPositioningItem:menu.itemArray.lastObject 
	                atLocation:location 
		            inView:sender];
}

The code above gives us the following result:

The titles are not displayed in the palette, but they are still important for accessibility features such as VoiceOver.

Example 2: A Palette with a Template Image

The second convenience constructor (+paletteMenuWithColors:titles:templateImage: selectionHandler:) lets you provide a template image. This is useful when a colored symbol communicates the choice better than a plain color dot. For example we can create a flag color picker with the following code:

- (NSMenuItem *)flagColorMenuItem
{
     NSArray *colors = @[NSColor.systemRedColor,
		                    NSColor.systemOrangeColor,
		                    NSColor.systemYellowColor,
		                    NSColor.systemGreenColor,
		                    NSColor.systemBlueColor];
	
     NSArray *titles = @[@"Red Flag",
		                     @"Orange Flag",
		                     @"Yellow Flag",
		                     @"Green Flag",
		                     @"Blue Flag"];
	
     NSImage *flagImage = [NSImage imageWithSystemSymbolName:@"flag.fill" accessibilityDescription:@"Flag"];
	
      __weak PMViewController *weakSelf = self;
      NSMenu *paletteMenu = [NSMenu paletteMenuWithColors:colors
		                                   titles:titles
		                            templateImage:flagImage
		                         selectionHandler:^(NSMenu *menu) 
       {
	    __strong PMViewController *strongSelf = weakSelf;
	    if (strongSelf == nil) { return; }
	    
            NSMenuItem *selectedItem = menu.selectedItems.firstObject;
	    if (selectedItem == nil) { return; }
			
	    NSUInteger index = [menu.itemArray indexOfObject:selectedItem];
	    if (index == NSNotFound) { return; } // This would be unexpected.
			
	    [strongSelf applyFlagColor:colors[index] title:titles[index]];
      }];
	
     paletteMenu.selectionMode = NSMenuSelectionModeSelectOne;
	
     NSMenuItem *parentItem = [[NSMenuItem alloc] initWithTitle:@"Flag Color"
	                                                 action:nil
		                                  keyEquivalent:@""];
     parentItem.submenu = paletteMenu;
	
     return parentItem;
}

- (void)applyFlagColor:(NSColor *)color title:(NSString *)title
{
    NSLog(@"Selected flag color %@ : %@",color, title);
    // TODO: Apply the color.
}

Bonus Tip: In this sample a stub method for -applyFlagColor:title: is shown. Note that the selection handler does not capture self directly to call the --applyFlagColor:title: method. This matters if the view controller keeps a strong reference to the menu, for example if the menu is to be reused in subsequent presentations. The menu owns its selection handler block, and blocks strongly capture Objective-C objects by default. If the block captured self, the ownership graph could become view controller -> menu -> block -> view controller, creating a retain cycle.

To avoid a retain cycle, assign self to a weak variable before creating the block, then promote it to a local strong variable inside the block. The local strong reference keeps the controller alive for the duration of the handler after it has been retrieved. The weak/strong pattern makes the lifetime behavior explicit and avoids the object disappearing halfway through the handler.

Example 3: A Manually Created Tool Picker Palette Menu

The palette menu class constructors are convenient, but they are not the only way to create a palette. To manually create a palette menu, instantiate an NSMenu instance and set its presentationStyle to NSMenuPresentationStylePalette.

menu.presentationStyle = NSMenuPresentationStylePalette;

Below is an example of how you can create a tool picker palette menu:

- (NSMenuItem *)toolPaletteMenuItem
{
     NSMenu *toolMenu = [[NSMenu alloc] initWithTitle:@"Tool"];
     toolMenu.presentationStyle = NSMenuPresentationStylePalette;
     toolMenu.selectionMode = NSMenuSelectionModeSelectOne;
	
     NSArray *> *tools = @[
		@{ @"title": @"Select", @"symbol": @"cursorarrow" },
		@{ @"title": @"Pen",    @"symbol": @"pencil" },
		@{ @"title": @"Text",   @"symbol": @"textformat" },
		@{ @"title": @"Shape",  @"symbol": @"square.on.circle" },
		@{ @"title": @"Erase",  @"symbol": @"eraser" }
     ];
	
     NSMenuItem *initialSelectedItem = nil;
	
    for (NSDictionary *tool in tools) {
	NSString *title = tool[@"title"];
	NSString *symbolName = tool[@"symbol"];
		
	NSImage *image = [NSImage imageWithSystemSymbolName:symbolName
                         	   accessibilityDescription:title];
	image.template = YES;
		
	// Give all menu items in the toolMenu the same target action.
 	NSMenuItem *item = [[NSMenuItem alloc] initWithTitle:title
			                              action:@selector(selectToolFromMenuItem:)
			                       keyEquivalent:@""];
	item.target = self;
	item.image = image;
	item.representedObject = title;
		
	[toolMenu addItem:item];
		
	if ([self.currentToolName isEqualToString:title])
	{
	   initialSelectedItem = item;
	}
     }
	
     if (initialSelectedItem != nil)
     {
	 toolMenu.selectedItems = @[ initialSelectedItem ];
     }
	
     NSMenuItem *parentItem = [[NSMenuItem alloc] initWithTitle:@"Tool"
                                                   	 action:nil
		                                  keyEquivalent:@""];
     parentItem.submenu = toolMenu;
	
     return parentItem;
}

- (void)selectToolFromMenuItem:(NSMenuItem *)sender
{
     NSString *toolName = sender.representedObject;
     self.currentToolName = toolName;
     NSLog(@"Selected tool: %@", toolName);
}

In this example, a __weak self variable is not required because selection is handled with the standard target/action pattern rather than a block. The menu item invokes selectToolFromMenuItem: on its target (a weak reference), and there is no selection-handler block capturing the view controller.

Where Palette Menus Fall Short

Palette menus are useful, but they are not always the best choice. They work best when the user is choosing from a small, fixed set of options. Once the interaction becomes more complex, you may have to embed a custom view inside a NSMenuItem or choose a different AppKit control.

Palette menus also do not provide room for explanation. A horizontal row of icons or colors is compact, but that compactness comes at the cost of context. If each option needs a description, preview, secondary value, keyboard shortcut explanation, or multiple lines of text, the palette layout cannot be used.

Another thing to watch for is item count. Palette menus are best for small groups. Five colors, four annotation modes, or three priority levels work well. As the number of items grows, the palette becomes harder to scan, harder to fit, and less menu-like. If you have a large collection of options, use a standard menu or build your own dedicated picker.

The color convenience constructors are intentionally specialized. They work well when your menu items can be described by a simple list of colors and titles, with an optional shared template image. If each item needs its own image, represented object, validation behavior, or command handling, skip the convenience constructors and build the menu items manually, as shown in Example 3.

Finally, be careful not to use palette menus just because they look modern. A vertical menu is often better for destructive actions, rarely used choices, or options that need keyboard discoverability. Palette menus shine when the choices are visual, compact, and frequently used. If the user has to stop and decode what each item means, the palette is probably the wrong interface.

Wait, Why macOS Sequoia 15.2 and Not 15.0?

When Sequoia 15.0 shipped, the familiar checkbox list used to enable Finder Extensions in System Settings completely disappeared. The only way users could enable Finder extensions on macOS 15.0 was via the command line (Terminal) or by installing third party apps. Apple acknowledged that this was a bug in the macOS operating system and fixed it in version 15.2. If you are running on a version of macOS Sequoia prior to 15.2, please update your operating system to restore Finder Extension functionality to System Settings.

A Brief Reminder of What Finder Extensions Are:

Finder extensions (sometimes called Finder Sync extensions) let apps bolt extra features onto the Finder like status-badge icons (✔︎/⚠︎), custom toolbar buttons, or right-click actions. They ship inside some of the apps you install but stay disabled until you turn them on in System Settings. 

Updated Instructions for macOS 15.2 and Later

1. Open System Settings.
2. In the sidebar choose General → Login Items & Extensions.
3. Click File Providers (you may only see it if at least one app on your Mac contains a Finder extension).
4. Turn on the toggle switch next to the extension’s name to enable it.

Note: Don’t get confused by the Finder section under “Login Items & Extensions”

If you open System Settings and go to General → Login Items & Extensions, you’ll notice that there is a “Finder” section right above the “File Providers” section. This area is for enabling what used to be called Finder “Quick Actions” (although the text in System Settings now suddenly calls Finder Quick Actions Finder Extensions, which is confusing). If you are looking to enable or disable a Finder extension for an app you downloaded from the Mac App Store or from a developer’s website, you want to go to the “File Providers” section.

Quick Summary: To Enable Finder Extensions on macOS Sequoia

Remember this path in System Settings:

System Settings → General → Login Items & Extensions → File Providers

What if I’m running a version of macOS prior to Sequoia?

-If you are macOS Ventura or macOS Sonoma to enable Finder Extensions follow the instructions here.

-To enable Finder Extensions on macOS Monterey or earlier follow the instructions here.

What is Natural Scrolling?

Natural scrolling is a feature that changes the way you interact with content on your computer by adjusting the direction of your scrolling gestures. Traditionally, when you move your fingers upward on a touchpad or scroll wheel, the on-screen content moves in the same direction, mimicking the physical motion of the input device. However, natural scrolling flips this paradigm, making the scrolling experience more akin to how we interact with touch-based devices like smartphones and tablets. With natural scrolling enabled, you move the scroll wheel upwards to scroll down.

Why Enable Natural Scrolling on Windows 11?

If you switch between macOS and Windows remembering to scroll in the opposite direction every time you change operating systems can be confusing and frustrating. Enabling natural scrolling on Windows 11 will give you a more consistent user experience on both desktop platforms.

A Note for Touchpad Users:
If you use a touchpad as your pointing device, you can enable natural scrolling on Windows 11 easily from the Settings app and you therefore should not follow this tutorial. However, if you use a mouse as your pointing device and are determined to enable natural scrolling on Windows 11, then continue reading.

How to Enable Natural Scrolling on Windows 11 in 9 Steps

Step 1: Open Device Manager

To get started, click on the Start button in the taskbar or press the Windows key on your keyboard. From the Start menu, search for “Device Manager” and then click the icon once it appears.

Step 2: Locate and Expand the “Mice and other pointing devices” Category

In the Device Manager window, find the “Mice and other pointing devices” category. Click on the arrow next to it to expand the list of devices.

Step 3: Find Your Mouse

Look for your mouse in the expanded list of devices. It may be listed as a “HID-compliant mouse” or have a specific model name. Right-click on your mouse device, and from the context menu, select “Properties.” This will open the Properties window for your mouse.

Step 4: Navigate to the “Details” Tab and Find the “Device instance path” for your Mouse

In the Mouse Properties window, navigate to the “Details” tab. From the “Property” dropdown menu, select “Device instance path.” See screenshots below for reference:

Step 5: Note the “Device instance path” Value

You will see a value in the “Value” box. Write down this value, as you will need it for step 7.

Step 6: Open Registry Editor

Open the Start menu again and search for “Registry Editor” and then click the icon to open Windows’ Registry Editor. Modifying the Registry Editor will allow us to enable natural scrolling on Windows 11.

Step 7: Navigate to the Mouse Registry Key

Using the Registry Editor’s left-hand navigation, expand the HKEY_LOCAL_MACHINE folder to reveal its subfolders. Then expand the following subfolders: SYSTEM -> CurrentControlSet -> Enum -> HID. Once HID is expanded look for the device instance path from step 5 as demonstrated in the screenshot below.


Note: There may be several entries within the HID section with similar names. Carefully look to ensure that you choose the one that matches the “Device instance path” value from step 5. Expand the subfolders to reveal a folder named “Device Parameters” and select it.

Step 8: Modify the FlipFlopWheel DWORD

Having the “Device Parameters” folder selected in the left-hand navigation reveals a list of entries in the right-hand navigation that includes an entry titled “FlipFlopWheel.” Right click on “FlipFlopWheel” and choose “Modify” from the context menu. This will reveal a “Edit DWORD” window. In this window change “Value data” from 0 to 1 and click the “OK” button. Then close the Registry Editor.

Step 9: Restart Your Computer

Restart your computer to apply the changes!

Conclusion:

To enable natural scrolling on Windows 11 for a mouse requires using the Device Manager and making a modification in the Registry Editor. While this method may seem a bit more technical, following these steps allows you to customize your mouse settings to align with your scrolling preferences. Always exercise caution when making changes to the registry, and ensure you follow the steps accurately.

Apple’s macOS Sonoma has brought a plethora of features to enhance your computing experience, and one of these is the ability to easily create apps from your favorite websites. This is particularly useful for services like ChatGPT, where having quick, streamlined access to the website can be a real game changer. In this tutorial, we’ll walk you through how to install ChatGPT as a Mac app using Safari’s “Add to Dock” feature.

Step 1: Open Safari

First things first, open your Safari browser. This feature is specific to Safari, so using Chrome or Firefox won’t work in this instance.

Step 2: Navigate to the ChatGPT Website

Type in the URL for ChatGPT or search for it in your Safari browser. Make sure you are on the official ChatGPT page.

Step 3: Access the Share Menu

Once the ChatGPT page has fully loaded, look at the top of your Safari window. You’ll find the share icon in the toolbar (it looks like a square with an arrow pointing upward). Click on this icon to open the share menu.

Step 4: Choose “Add to Dock”

In the share menu, you’ll see several menu options; select the one titled “Add to Dock.” This essentially saves the website as a standalone app you can open from the Dock and/or from Launchpad just like regular Mac apps.

It’s worth mentioning that you can also perform the “Add to Dock” action from the menu bar by choosing File -> Add to Dock as demonstrated in the screenshot below.

Step 5: Rename (Optional)

After selecting “Add to Dock,” you are given the option to rename the web app. You can keep it as ChatGPT or change it to something else that you’ll easily recognize.

Step 6: Locate the ChatGPT Icon in Your Dock

Once you’ve added ChatGPT to your Dock, you should see the icon appear. It’s usually at the end of your Dock, but you can click and drag it to change its position.

Step 7: Enjoy Your New ChatGPT Mac App

Congratulations, you now have ChatGPT installed as a Mac app! Just click on the icon in your Dock whenever you want to use ChatGPT. It will open in a window that’s separate from your main Safari browser, giving you an app-like experience.

Additional Tips and Tricks

• Internet Connection: Remember, since this is essentially a shortcut to the web version of ChatGPT, you’ll need an active internet connection to use it.
• Customization: Feel free to customize the web app further by changing its icon. You can do this by opening the Settings window from the menu bar when you have the ChatGPT app opened. From there, you can replace the icon with any image you’ve prepared.

Install ChatGPT as a Mac App and get a More Native Experience

And that’s it! You’ve successfully turned ChatGPT into a convenient app on your Mac. This process can be used for virtually any website, making your most visited pages more accessible than ever. Enjoy the seamless integration of ChatGPT into your macOS Sonoma experience!

In this tutorial, we will explain what Finder extensions are and how to enable a Finder extension on macOS Ventura.

What is a Finder Extension?

A Finder extension is a type of macOS plugin that adds functionality to the Finder app. These extensions can be created by developers to add new features to the Finder, such as the ability to perform custom actions on the files and folders you are viewing in Finder. Once enabled, Finder extensions can appear in the context menu when you right-click on a file or folder. A Finder extension can also add a custom button to Finder’s toolbar.

How to Enable a Finder Extension on macOS Ventura

Step 1: Open the System Settings app

The first step is to open the System Settings app. You can do this by clicking on the System Settings icon in the Dock or from Launchpad. You can also open the System Settings app by clicking on the Apple menu at the top left corner of your screen and select “System Settings” from the dropdown menu.

Step 2: Click on “Privacy”

In the System Settings window, click on the “Privacy & Security” option in the sidebar. Scroll all the way down in the main pane and choose “Extensions” as highlighted in the screenshot below:

Step 3: Enable the Finder Extension in the “Added extensions” List

Click on “Added extensions” to view the app extensions list. You will see a list of all available extensions provided by your installed apps here. It’s worth noting that other types of extensions are displayed in this list as well. To enable a Finder extension specifically, simply click on the “Finder extensions” checkbox that appears below the app name.

Step 4: Use the Extension

Once you have enabled the extension, open the Finder app and you can begin using the extension. It’s worth noting that some extensions may require additional permissions to work properly. If this is the case for your Finder extension, ask the the app developer what additional steps are required to get the Finder extension working.

Final Thoughts

Finder extensions are a powerful tool that can add a lot of functionality to the Finder app on macOS Ventura. By following the steps outlined in this tutorial, you can easily enable and use a Finder extension to streamline your workflow and make working with files and folders on your Mac even easier.

Want to use Finder extensions on your Mac now? Check out these great apps:

• File Cabinet Pro provides a Finder extension that allows you to create various text documents right in a Finder window.
• Desktop Ghost Pro provides a Finder extension that allows you to show and hide all the icons on your Desktop from the Finder when you are viewing the desktop directory.
• Open Directory in Terminal allows you to open the selected directories in Finder in a new Terminal window or tab.

Steps to Locate App Crash Reports on iOS 16:

Open the “Settings” app on your iOS 16 device and tap on “Privacy & Security” in the list.

Select “Analytics & Improvements” as demonstrated in the screenshot below:

Scroll down to the “Analytics Data” section and select it in the list.

Here in the “Analytics Data” section is where you can locate app crash reports on iOS 16. It’s worth noting that not all the files shown in the list represent crash reports (other diagnostic information is captured in files shown in the list). Look for any entries that include the name of the app that recently has crashed. You can filter the entries by typing the name of the app that crashed in the search bar to find a crash report.

Tap on a report to view more details.

You can save the report to a file, send it in a e-mail or text message from the Share Sheet by clicking the “Share” button in the upper right-hand corner of the screen.

Final Thoughts

By following the steps outlined in this tutorial, you should be able to easily locate crash reports on iOS 16. While these reports can be technical, they provide valuable information that can help you and app developers identify and fix issues that may be causing crashes. If you’re having trouble with a specific app, consider sharing the crash report with the app developer to help them improve their app and provide a better user experience for everyone.

Step 1: Divide the Decimal Number by 16

The first step in converting a decimal number to a hexadecimal number is to divide the decimal number by 16. Write down the quotient and remainder of the division.

For example, let’s convert the decimal number 4096 to hexadecimal.

4096 ÷ 16 = 256
Quotient = 256
Remainder = 0

Step 2: Convert the Remainder to Hexadecimal

The next step is to convert the remainder from the previous step to hexadecimal. To do this, you can use the following conversion chart:

In our example, the remainder is 0, so the hexadecimal equivalent is also 0.

Step 3: Repeat the Process Until the Quotient is 0

The next step is to repeat the previous two steps until the quotient is 0. In our example, we have:

256 ÷ 16 = 16
Quotient = 16
Remainder = 0

16 ÷ 16 = 1
Quotient = 1
Remainder = 0

1 ÷ 16 = 0
Quotient = 0
Remainder = 1

Step 4: Write the Hexadecimal Equivalent

Once the quotient is 0, you can write down the hexadecimal equivalent by writing the remainders from the last step in reverse order. In our example, the remainders are 0, 0, 0, and 1, so the hexadecimal equivalent of 4096 is 1000.

Therefore, the decimal number 4096 is equivalent to the hexadecimal number 1000.

Final Thoughts

Converting decimal to hexadecimal may seem complicated at first, but it’s actually quite simple once you understand the process. Just remember to divide the decimal number by 16, convert the remainder to hexadecimal, and repeat the process until the quotient is 0. By following these steps, you can easily convert decimal to hexadecimal for any number.

Want to convert Decimal to Hexadecimal Even Faster?

Hex Converter is an application for macOS that can instantly convert decimal numbers to hexadecimal (and vice versa); get Hex Converter on the Mac App Store at a very low price here!

Step 1: Launch the Mac App Store

The first step is to launch the Mac App Store on your Mac. You can do this by clicking on the App Store icon in the Dock or by searching for it using Spotlight.

Step 2: Sign in to your account

Before you can redeem a promo code, you need to sign in to your Apple ID on the Mac App Store. Click on the ‘Sign In’ button located at the bottom of the sidebar on the left-hand side of the screen. Enter your Apple ID and password and click ‘Sign In.’

Step 3: Access the Redeem Page

Once you’ve signed in, click on your name in the bottom left-hand corner of the screen. A dropdown menu will appear, and you should select ‘Redeem’ from the options listed.

Step 4: Enter the Promo Code

On the Redeem page, enter the promo code you received in the text field provided. Make sure to enter the code exactly as it was given to you. Promo codes are usually case sensitive, so be sure to enter uppercase and lowercase letters correctly.

Step 5: Confirm your Redeem

Click on the ‘Redeem’ button to confirm your code. If the code is valid, the app or item associated with the code will start to download. If the code is not valid or has already been used, you’ll receive an error message.

Step 6: Download and Install the App on your Other Macs

Once the code has been redeemed, you can download and install the app from the Mac App Store on any Mac signed in with the same Apple ID you used when you initially redeemed the code. You can do this by clicking on your name in the bottom left-hand corner of the Mac App Store screen again. The app will now appear in the “Purchased section” of your account and you can download it at no charge.

That’s it! You’ve successfully redeemed a promo code on the Mac App Store on macOS Ventura. Promo codes can be a great way to try out new apps for free, if the App developer is nice enough to give you one.

There is a sample project available on Github here.