OS X Yosemite v10.10
This article summarizes the key technology changes and improvements in OS X v10.10. For a detailed list of API changes, see OS X v10.10 API Diffs.
Please file any bug reports about this release or this documentation at http://bugreport.apple.com/.
OS X Yosemite v10.10.3
Force Touch Trackpad Support
AppKit contains new properties and methods that support Force Touch trackpads. Developers can now write apps that respond to force clicks (pressing harder) and changes in pressure as the user operates the trackpad. In the Calendar app, for example, a user can force click a date to create a new event. In QuickTime, a user can adjust the speed of fast forward and rewind with variable pressure.
Buttons and segmented controls can also now be set as spring loaded. This feature allows a user to activate a button or segment by dragging selected items over it and force clicking without dropping the selected items. The user can then continue dragging the items, possibly to perform additional actions. A practical example of this feature can be found in the Calendar app. A selected calendar event can be dragged over the Calendars button in the toolbar. Force clicking on the button displays the calendar list without releasing the selected event. The event can then be dropped onto a calendar in the list, which assigns it to that calendar.
The following sections highlight changes and enhancements in the AppKit framework that are related to Force Touch Trackpad support.
NSButton now includes the following new properties:
NSButtonType constant of
NSButtonCell now includes the following button types:
NSAcceleratorButton—When the user force clicks (applies pressure), an accelerator button sends repeating actions as pressure changes occur. It stops sending actions when the user releases pressure entirely.
NSMultiLevelAcceleratorButton—A multilevel accelerator button is a variation of a normal accelerator button that allows for a configurable number of stepped pressure levels. As each one is reached, the user receives light tactile feedback and an action is sent.
pressure now support pressure events.
NSEvent now includes the following new properties:
stage—Pressure events can go through multiple stages, each representing a pressure curve—not enough pressure for a click, enough pressure for a click, or more than enough pressure for a click (force click). This property indicates the current stage of the event.
stageTransition—This property is specifically intended to provide a value for the transition animation between the stages of a pressure gesture event.
associatedEventsMask—This property pertains to mouse events, and may be used to determine if the input device issuing the event can simultaneously issue pressure events.
NSEventType constant of
NSEvent now includes an
NSEventTypePressure event type.
The NSEventMaskFromType constant of
NSEvent now includes an
NSGestureRecognizer now includes a new method
pressureChangeWithEvent:, which is invoked when a pressure change occurs as the result of an event.
NSResponder now includes a new method
pressureChangeWithEvent:, which is invoked when a pressure change occurs as the result of an event.
NSSegmentedControl now includes the following new properties:
springLoaded—Indicates whether spring loading is enabled for the control.
trackingMode—The type of tracking behavior the control exhibits.
NSSegmentedControl includes a new method
doubleValueForSelectedSegment, which returns the value of the selected segment when the tracking mode of the segmented control is set to
NSSegmentSwitchTracking constant of
NSSegmentedControl now includes an
NSSegmentSwitchTrackingMomentaryAccelerator tracking type, which specifies that a segment should activate when the user force clicks it, send actions at repeating intervals or as changes in pressure occur, and deactivate when the user releases pressure entirely.
OS X Yosemite v10.10
OS X lets you extend select areas of the system with an app extension, which is code that enables custom functionality within the context of a user task. For example, if you have an app for a great photo sharing service, you can provide an extension within your app so your service becomes available throughout OS X from the Share menu. In this example, your custom sharing extension provides the code that accepts, validates, and posts the user’s photos. The system lists the extension in the sharing menu and instantiates it when the user chooses it.
You create an app extension by adding an app extension target to an app. After users install an app that contains extensions, they can enable the extensions in System Preferences. When users are running other apps, enabled extensions can be made available in the appropriate system UI, such as the sharing menu.
OS X supports app extensions for the following areas, which are known as extension points:
Share. Share content with social websites or other entities.
Action. Perform a simple task with the selected content.
Today. Provide a quick update or brief function in the Today view of Notification Center.
Finder Sync. Enable services for custom file and sync providers.
Each extension point defines APIs that an app extension uses to communicate with the extension point. When you use an Xcode app extension template to begin development, you get a default target that contains method stubs and property list settings defined by the extension point you chose.
For more information on creating extensions, see App Extension Programming Guide.
Handoff enables users to begin an activity on one device, then switch to another device and resume the same activity on the other device. For example, a user who is browsing a long article in Safari moves to an iOS device that's signed into the same Apple ID, and the same webpage automatically opens in Safari on iOS, with the same scroll position as on the original device. Handoff makes this experience as seamless as possible.
To participate in Handoff, an app adopts a small API in Foundation. Each ongoing activity in an app is represented by a user activity object that contains the data needed to resume an activity on another device. When the user chooses to resume that activity, the object is sent to the resuming device. Each user activity object has a delegate object that is invoked to refresh the activity state at opportune times, such as just before the user activity object gets sent between devices.
If continuing an activity requires more data than is easily transferred by the user activity object, the resuming app has the option to open a stream to the originating app. Document-based apps automatically support activity continuation for users working with iCloud-based documents.
For more information, see Handoff Programming Guide.
Starting in Xcode 6, you can use storyboards to lay out all the different views you will show your users, arranging them much like the storyboard for a movie. Each view, also called a scene, is connected to other views by transition or containment relationships known as segues. You specify a trigger for a segue in terms of an action such as a button click or a menu item choice.
Mac storyboards work much like iOS storyboards do, but with a greater focus on containment of views rather than transitions between them. For example, on the Mac you express the containment between a tab view controller and its tab scenes with containment segues.
Mac storyboards depend on capabilities provided by the new view controller classes
NSTabViewController, and enhancements to the
NSWindowController classes. For more information, refer to the overview sections in the corresponding reference documents.
iCloud includes changes that impact the behavior of existing apps and that will affect users of those apps.
Document Data Migration
The iCloud infrastructure is more robust and reliable when transferring documents and data between user devices and the server. When a user installs OS X v10.10 and logs into the device with an iCloud account, the iCloud server performs a one-time migration of the documents and data in that user’s account. This migration involves copying the documents and data to a new version of the app’s container directory. This new container is accessible only to devices running OS X v10.10 or iOS 8. Devices running older operating systems will continue to have access to the original container, but changes made in that container will not appear in the new container and vice versa.
Cloud Kit (
CloudKit.framework) provides a conduit for moving data between your app and iCloud. Unlike other iCloud technologies where data transfers happen transparently, Cloud Kit gives you control over when transfers occur. You can use Cloud Kit to manage all types of data.
Apps that use Cloud Kit directly can store data in a repository that is shared by all users. This public repository is tied to the app itself, so it’s available even on devices without a registered iCloud account. As the app developer, you can manage the data in this container directly and see any changes made by users through the Cloud Kit dashboard.
For more information, see Cloud Kit Framework Reference.
Frameworks and Framework Technologies
The following sections highlight changes to frameworks and framework technologies in OS X v10.10.
Many frameworks on OS X have adopted small interface changes that take advantage of modern Objective-C syntax:
Getter and setter methods are replaced by properties in most classes. Code using the existing getter and setter methods should continue to work with this change.
Initialization methods are updated to have a return value of
Designated initializers are declared as such where appropriate.
In most cases, these changes do not require any additional work in your own app. However, you may also want to implement these changes in your own Objective-C code. In particular, you may want to modernize your Objective-C code for the best experience when interoperating with Swift code.
For more information, see Adopting Modern Objective-C.
The following frameworks are new in OS X v10.10:
Crypto Token Kit (
CryptoTokenKit.framework). The Crypto Token Kit framework provides native support for smart cards, including:
Enumerating connected smart card readers and monitoring them for card insertion and removal
Transmitting commands and responses to and from smart cards in the reader
Supporting new smart card reader hardware
FinderSync.framework). The FinderSync framework enables Finder extensions to:
Express interest in specific folder hierarchies
Provide "badges" to indicate the status of items inside those hierarchies
Provide dynamic menu items in Finder contextual menus, when the selected items (or the window target) are in those hierarchies
Provide a Toolbar Item that displays a menu with dynamic items (even if the selection is unrelated)
Hypervisor.framework). The Hypervisor framework allows virtualization vendors to build virtualization solutions on top of OS X without needing to deploy third-party kernel extensions (KEXTs). Included is a lightweight hypervisor that enables virtualization of the host CPUs.
Multipeer Connectivity (
MultipeerConnectivity.framework). The Multipeer Connectivity framework brings OS X to parity with iOS and allows cross-platform connections between devices running iOS 7, iOS 8, and OS v10.10.
Notification Center (
NotificationCenter.framework). The Notification Center framework helps you create and manage extensions—typically called widgets—in the Today view. The framework provides an API you can use to specify whether a widget has content to display and to customize aspects of its appearance and behavior on both platforms. In OS X, the Notification Center framework also enables you to customize the editing and searching experience in a widget.
For more information, see Notification Center Framework Reference.
AppKit Framework Changes
The following sections highlight changes and enhancements in the AppKit framework.
NSWindowController has a new
contentViewController property that mirrors the
contentViewController property of the associated window. An
NSWindowController object that’s part of a storyboard is required to have a
contentViewController—a requirement that the Xcode storyboard editor helps you to fulfill when you drag a window controller (
NSWindowController) into the storyboard canvas.
NSViewController now has a suite of methods for presentation hooks:
See the header comments in
NSViewController.h for more details.
NSViewController adds a
-viewDidLoad method that can be overridden for instances that want to know when the view has been loaded in order to perform additional setup work.
NSViewController adds the following new features, all commented in great detail in
Parent/child container view controller methods
View controller presentation options
View controller transition options
The new class
NSVisualEffectView enables you to create translucent backgrounds and support vibrancy.
NSVisualEffectView is automatically used by the system in many places, including
NSTableView "source lists” and sidebars, and sheets. Please see the header for detailed information.
Gesture recognizers are now available in AppKit. The API is nearly identical to the UIKit version. See
NSGestureRecognizer.h. There is a
NSGestureRecognizer (NSSubclassUse) category that is explicitly provided for subclassers to override and call. Non-subclassers should never directly access these category methods and properties.
In Mac OS X v10.10, named images are now retained. Previously, named images had been weakly referenced, and sometimes cached. Retention allows applications to register a named image using
-[NSImage setName:] and retrieve it later using
+[NSImage imageNamed:]. To achieve the same pattern on prior releases, it was necessary to hold an extra reference to the image.
AV Foundation Framework Changes
AV Foundation framework adds support for a broad cross-section of audio functionality at a higher level of abstraction than Core Audio. The new AV Foundation audio capabilities are available in both OS X and iOS and include a new API that allows manual control of the camera focus, white balance, and exposure settings. In addition, bracketed exposure captures allow automatic capturing of images with different exposure settings.
You can now capture metadata over time while shooting video. This capability allows arbitrary types of metadata to be embedded with a video recording at various points in time. For example, you might record the current physical location in a video created by a moving camera device.
Other new capabilities in AV Foundation include:
Audio recording and playback
Audio file parsing and conversion
Audio units that allow for the creation of sound effects, filters, audio distortion, and reverberation effects
Pitch and playback speed management
A built-in equalizer and mixer that you can use in your applications
Stereo and 3D audio environments
Automatic access to audio input and output hardware
For information about the classes of this framework, see AV Foundation Framework Reference.
Core Data Framework
The Core Data framework (
CoreData.framework) enables you to update multiple records in a store without first loading the record data into memory.
For information about the classes of this framework, see Core Data Framework Reference.
Core Image Framework
The Core Image framework (
CoreImage.framework) includes the following changes:
Accessing the second GPU in the Mac Pro is significantly easier. Use the
offlineGPUCountmethod to find the number of GPUs that are not currently driving a display and can be used for image processing. Use the
offlineGPUAtIndexmethod to create a
CIContextbased on an offline GPU index.
You can use core image detectors to detect rectangles and QR codes in an image.
For information about the classes of this framework, see Core Image Reference Collection.
Core Location Framework
The Core Location framework (
CoreLocation.framework) now allows you to determine which floor the device is on if the device is in a multistory building.
For information about the classes of this framework, see Core Location Framework Reference.
Foundation Framework Changes
The following sections highlight changes and enhancements in the Foundation framework.
NSString Encoding Detection
NSString adds an API that can be used to detect the string encoding of an array of bytes. This API is used to detect the string encoding of raw data and can also do lossy string conversion. It converts the data to a string in the detected string encoding.
Date Interval Formatter
NSDateIntervalFormatter class is new in OS X v10.10. It’s used to format a date interval in a locale-sensitive way. A date interval is defined by two—for example, September 1st, 2013 - October 1st, 2013. In different countries and different regions, people use different languages and different formats to express a date interval.
NSDateIntervalFormatter is designed to easily format a date interval into a localized string.
Date Components Formatter
Foundation now provides localized formatting of durations and quantities of time using the new
NSDateComponentsFormatter class. The header file
NSDateComponentsFormatter.h is extensively commented with examples, information, and usage guidelines.
Three new unit formatters have been added in OS X v10.10:
NSEnergyFormatter. These formatters can format a combination of a value and a unit into a localized string. They can also be used to get a localized string of a unit and to determine whether the unit is singular or plural, based on the given value. These formatters do not support either parsing or unit conversion.
NSXPCConnection Progress Reporting
In OS X v10.10,
NSProgress have been integrated to work together seamlessly. To receive progress updates from work done in another process, make an
NSProgress object current before calling out to your
remoteObjectProxy object. If the other side supports reporting progress, the
NSProgress object in your process is updated as work is completed in the remote process.
NSFileCoordinator has a new reading option that facilitates uploading user documents to web services, such as web pages or mail servers, that only understand regular files and not file packages.
To use this API, request a coordinated read on any user document, the same that you would for normal reading, but use
NSFileCoordinatorReadingForUploading. Before your accessor block is invoked,
NSFileCoordinator determines whether the file is a directory. If it is, it creates a zip archive of that directory in a temporary folder that your app can access. If the file is not a directory, then it is copied to that directory. The URL to the newly created temporary file is accessible within your accessor block.
Game Kit Framework
The Game Kit framework (
GameKit.framework) has the following changes:
Features that were added in iOS 7 are now available on OS X 10.10, making it easier to use these features in a cross-platform game.
GKSavedGameclass makes it easy to save and restore a user’s progress. The data is stored on iCloud; Game Kit does the necessary work to synchronize the files between the device and iCloud.
Methods and properties that use player identifier strings are now deprecated. Instead, use
GKPlayerobjects to identify players. Replacement properties and methods have been added that take
For information about the classes of this framework, see Game Kit Framework Reference.
Scene Kit Framework Changes
The Scene Kit framework includes several enhancements to support developing casual 3D games and apps with 3D content:
Integration with Sprite Kit. Use the
overlaySKScenemethod to render a Sprite Kit scene above the 3D content in a Scene Kit view—this option is useful for adding a heads-up display to a game. You can also use Sprite Kit textures (see the
SKTextureclass) or entire animated scenes (see the
SKSceneclass) in Scene Kit materials, mapping their contents onto 3D objects.
Game development features. Use the
SCNActionclass for a declarative way to animate your scene (matching the
SKActionprogramming model in Sprite Kit). You can also use the
SCNActionclass to implement new methods in the
SCNSceneRendererDelegateprotocol to manage your game’s scene graph in a traditional update/render loop.
Physics. Scene Kit physics simulation models the effects of forces and collisions on objects, and it updates the displayed node tree automatically. Use the
SCNPhysicsBodyclass to add physics characteristics to nodes. Use the
SCNPhysicsWorldobject attached to your scene to control global attributes of the physics simulation.
Advanced physics features include fields that apply forces to all bodies in their area of effect (see the
SCNPhysicsFieldclass); joints for connecting physics bodies (see the
SCNPhysicsBehaviorclass); and vehicle behaviors that easily and efficiently simulate cars or similar vehicles (see the
Visual effects and animations. Use the
SCNGeometryobjects to create smooth surfaces from low-resolution geometry. The
SCNLightclass supports new shadow rendering options. The
SCNSkinnerclass can now create and edit skeletal animations for 3D models. The
SCNTechniqueclass enables you to build custom shader-based post-processing techniques such as color grading, motion blur, and screen-space ambient occlusion. The
SCNParticleSystemclass implements animated 3D particle effects that you can add to a scene, such as fireworks, smoke, and rain. Use the Scene Kit Particle System editor in Xcode 6 to experiment with particle system settings.
Asset management. All Scene Kit objects support the
NSSecureCodingprotocol, so you can save and restore entire scene graphs—including Scene Kit features such as physics, particle systems, and constraints—with the
NSKeyedUnarchiverclasses. Scene Kit can now load scene content from files in Alembic (ABC) format, used widely in the 3D authoring industry, in addition to existing support for reading and writing files in Digital Asset Exchange (DAE) format. Use
.scnassetsfolders in Xcode 6 to optimize 3D assets for quick loading and smooth rendering at runtime.
In addition, the default behaviors of several Scene Kit classes change for apps built with the OS X v10.10 SDK or later:
Animations loaded from scene files automatically play repeatedly using the system time. To change this behavior, use the
Lights that cast shadows use forward rendering. This option improves performance but disables shadow coloring. Use the
shadowModeproperty to enable deferred shadowing (the default on OS X v10.9 and earlier).
The default type for newly created lights is
locksAmbientWithDiffuseproperty of materials defaults to
shininessproperty of materials no longer has a maximum of
Scene Kit is also available in iOS 8, so you can build cross-platform games or create custom tools for OS X to aid development of your own 3D games for iOS.
For information about the classes of this framework, see Scene Kit Framework Reference.
Sprite Kit Framework Changes
The Sprite Kit framework (
SpriteKit.framework) adds new features to make it easier than ever to support advanced game effects. These features include built-in support for custom OpenGL ES shaders and lighting, integration with Scene Kit, and support for advanced new physics effects and animations.
Xcode 6 also incorporates many new Sprite Kit editors, including shader and scene editors that save you time as you create your game. Create a scene’s contents, specifying which nodes appear in the scene and characteristics of those nodes, including physics effects. The scene is then serialized to a file that your game can easily load.
For information about the classes of this framework, see Sprite Kit Framework Reference and Sprite Kit Programming Guide.
Store Kit Framework Changes
The Store Kit Framework adds support to the In-App Purchases API for a deferred transaction—a transaction for which there is an indeterminate delay before the transaction reaches its final state of succeeded or failed.
WebKit Framework Changes
The WebKit framework introduces a unified, extensible API for iOS and OS X and exposes the new underlying multiprocess architecture.
Deprecated Frameworks and APIs
Periodically, Apple adds deprecation macros to APIs to indicate that those APIs should no longer be used in active development. When a deprecation occurs, it is not an immediate end of life for the specified API. Instead, it is the beginning of a grace period for transitioning from that API and to newer and more modern replacements. Deprecated APIs typically remain present and usable in the system for a reasonable time past the release in which they were deprecated. However, active development on them ceases, and the APIs receive only minor changes to accommodate security patches or to fix other critical bugs. Deprecated APIs may be removed entirely from a future version of the operating system.
As a developer, avoid using deprecated APIs in your code as soon as possible. At a minimum, new code you write should never use deprecated APIs. And if your existing code uses deprecated APIs, update that code as soon as possible. Fortunately, the compiler generates warnings whenever it spots the use of a deprecated API in your code. You can use those warnings to track down and remove all references to those APIs.
The following frameworks and APIs are deprecated in OS X v10.10:
The IOAudioFamily framework
Methods and properties in Game Kit that use player identifier strings
NSGarbageCollectorclass (execution support for garbage collection is not affected)
NS_DEPRECATED_MACattribute has been added to many previously soft-deprecated AppKit methods. Searching AppKit headers for
NS_DEPRECATED_MACand filtering for 10_10 will yield a list of affected symbols.
The following frameworks are no longer part of the OS X SDK as of version 10.10:
Notable in OS X v10.10 are changes to Safari.
Safari includes a variety of enhancements, such as:
WebGL. Safari support for WebGL allows developers to create 3D experiences that work natively in the browser.
IndexedDB. The IndexedDB API allows web developers to store structured data for web applications that work online or require large amounts of data to be cached client side.
CSS Shapes and Compositing. Using CSS, websites can now easily flow text around images and geometry shapes, and perform image compositing operations on DOM elements.
SPDY. Safari supports SPDY, an open networking protocol that websites can adopt to reduce page load latency and improve security.
HTML5 Premium Video. Websites that provide video can now take advantage of EME to deliver encrypted, energy-efficient video in the browser.
Xcode Tools Enhancements
Xcode 6 adds numerous features that support OS X v10.10, notably:
Swift. Swift is a new object-oriented programming language for iOS and OS X development. Swift is modern, powerful, expressive, and easy to use.
View debugging. The View Debugger makes debugging an app’s appearance as easy as debugging the lines of code. A single button click pauses your running app and “explodes” the paused UI into a 3D rendering, separating each layer of the stack of views. The View Debugger immediately shows why an image may be clipped and invisible, and the order of the graphical elements becomes clear.
Live rendering. Interface Builder displays your custom objects at design time, appearing as they do when your app is run. When you update the code for your custom view, the Interface Builder design canvas updates automatically with the new look you just typed into the source editor, with no need to build and run.
Performance testing. The enhanced XCTest framework now supports performance tests and an asynchronous testing API, fully integrated into both Xcode and Xcode Server. Asynchronous testing allows you to test code that is distributed in asynchronously executing blocks. With performance tests, you can quantify the performance of each part of an application.
Extensions support. Add an extension target to any iOS or OS X app to expose your app’s functionality more deeply in the OS. Xcode connects to the extension when launched, debugging the extension as it runs in the safe, embedded OS context.
Storyboards for OS X. Storyboards come to OS X with Xcode 6, taking advantage of the new View Controller APIs in App Kit. Storyboards make it easy to wire together multiple views quickly and define segue animations without writing code.
For more information about Xcode enhancements, see What’s New in Xcode.