The potential issue with enabling 64-bit mode on your Mac is that you (or an otherwise 64-bit app) will end up needing to launch a 32-bit app for whatever reason and it will be unavailable. The good news is that this process is reversible, so if you run into the aforementioned situation, you can always switch back to supporting 32-bit apps.
OverDrive for Mac and OverDrive MP3 audiobooks are not compatible with the newest macOS version, 10.15 (Catalina), because Apple requires all apps in macOS Catalina or newer to be 64-bit,.

In iOS 11 and later, all apps use the 64-bit architecture. If your app targets an earlier version of iOS, you must update it to run on later versions. Update Your App to the Latest SDK. Begin by updating your existing app to iOS 11 or later. By updating your app first, you can remove deprecated code paths, address any compiler warnings,.

To assist you in converting an existing application project to 64-bit, Apple provides a script that does most of the work. The script performs in-place substitutions on source-code files according to a set of rules. However, after you run the script you still need to look at everything that changed or was flagged and fix it if necessary. This procedure described below works as well for existing framework projects, plug-in projects, or other projects.

The Conversion Procedure

Start by eliminating the build warnings that your project currently generates; this will make it easier to focus on warnings that are specific to 64-bit conversion problems. Also save a copy of the project in case something goes wrong in the conversion process and you need to start over. Then in a Terminal shell run the conversion script ConvertCocoa64 located in /Developer/Extras/64BitConversion/. You can run the script on specific source and header files, as in this example:

Or you can run it on all .h and .m files in your project, as in this example:

As the script runs, it does the following things:

It converts most instances of int and unsigned int to NSInteger and NSUInteger, respectively. It doesn't convert ints in bit-field declarations and other inappropriate cases. During processing, the script refers to a hardcoded list of exceptions.
Important: The script converts instances of int and unsigned int that are properly the types of arguments and return values in POSIX calls. You must be aware of these instances and manually revert them (or leave them alone, if that is more appropriate).
It converts most instances of float to CGFloat, again leaving untouched those exceptions specified in a hardcoded list.
It does not convert enum declarations to types with guaranteed fixed sizes (as described in Enumeration Constants). You need to fix these declarations by hand.
It flags (with inline warnings) cases that need to be fixed manually. See Things to Look For During Conversion for details.

After the script completes processing all files, run the FileMerge development application on each changed file and an unchanged version of the same file. FileMerge visually highlights each modified section of code. After reading Things to Look For During Conversion, evaluate each of these sections plus the warnings generated by the script and make further changes if necessary.

Remember that any 64-bit change you make should help preserve binary compatibility of your project executable on 32-bit systems. You should use the constructs in Table 3-1 to mark off sections of code conditionally for each architecture: PowerPC versus Intel and 32-bit versus 64-bit.

**Table 3-1** Macros for architecture conditional code
Macro	Comment
`#if __LP64__`	PowerPC or Intel 64-bit. You should use this for most 64-bit changes.
`#ifdef __ppc__`	PowerPC 32-bit
`#ifdef __ppc64__`	PowerPC 64-bit
`#ifdef __i386__`	Intel 32-bit
`#ifdef __x86_64__`	Intel 64-bit
`#ifdef __BIG_ENDIAN__`	Big endian architectures

Things to Look For During Conversion

When the conversion script processes a source or header file, it often inserts warnings in the code to alert you to changes that you might have to make or pitfalls that you should try to avoid. These warnings are explained in the following sections.

Type Specifiers

Script action: Warns about potential problems; may generate false negatives.

Typically, in 32-bit code you use the %d specifier to format int values in functions such as printf, NSAssert, and NSLog, and in methods such as stringWithFormat:. But with NSInteger, which on 64-bit architectures is the same size as long, you need to use the %ld specifier. Unless you are building 32-bit like 64-bit, these specifiers generates compiler warnings in 32-bit mode. To avoid this problem, you can cast the values to long or unsigned long, as appropriate. For example:

Table 3-2 lists specifiers for formatting 64-bit types.

**Table 3-2** Type specifiers for 64-bit types
Type	Specifier	Comments
`NSInteger`	`%ld` or `%lx`	Cast the value to `long`.
`NSUInteger`	`%lu` or `%lx`	Cast the value to `unsigned long`.
`CGFloat`	`%f` or `%g`	`%f` works for floats and doubles when formatting (but not scanning).
`CFIndex`	`%ld` or `%lx`	Cast the value to `long`.
`long long`	`%lld` or `%llx`	`long long` is 64-bit on both 32-bit and 64-bit architectures.
`unsigned long long`	`%llu` or `%llx`	`unsigned long long` is 64-bit on both 32-bit and 64-bit architectures.

The script also inserts warnings in the related case of scanning functions such as scanf, but these introduce an additional subtlety. You need to distinguish between float and double types, using %f for float and %lf for double. Don't use CGFloat parameter in scanf-type functions; instead use a double parameter and assign the double value to a CGFloat variable. For example,

Important: Unless you cast appropriately, the %lf specifier (unlike the %ld specifier and long values) does not correctly represent CGFloat values on both 32-bit and 64-bit architectures.

Unkeyed Archiving

Script action: Warns of potential problems

The old style of Cocoa archiving relies on the sequence of encoded and decoded properties rather than keys as the means for identifying archived values; you must decode properties in the same order of their encoding. Developers are encouraged to move away from this old-style archiving to keyed archiving. However, applications may have to read old-style archives so they cannot abandon this key-less archiving altogether. And, fro

Convert 32-bit App To 64-bit Mac