iOS Developer Library


SpriteKit Framework Reference


Classes   Protocols   Other Reference  

SpriteKit is a graphics rendering and animation infrastructure that you can use to animate arbitrary textured images, otherwise known as sprites. SpriteKit provides a traditional rendering loop that alternates between determining the contents of and rendering frames. You determine the contents of the frame and how those contents change. SpriteKit does the work to render that frame efficiently using graphics hardware. SpriteKit is optimized for applying arbitrary animations or changes to your content. This design makes SpriteKit more suitable for games and apps that require flexibility in how animations are handled.

Getting Started with SpriteKit

SpriteKit implements content as a hierarchical tree structure of nodes. A node tree consists of a scene node as the root node and other nodes that provide content. Each frame of a scene is processed and rendered to a view. The scene executes actions and simulates physics, both of which change the contents of the tree. Then the scene is rendered efficiently using SpriteKit.

To start learning SpriteKit, you should look at these classes in the following order, before moving on to other classes in the framework:

SpriteKit Programming Guide includes an exercise that teaches these classes.



NSObject is the root class of most Objective-C class hierarchies.


An SKAction object is an action that is executed by a node in the scene (SKScene).


An SKConstraint object describes a mathematical constraint on a node’s position or orientation.


An SKKeyframeSequence object specifies values for keyframes so that when a particle in an emitter node is simulated, that particle gets its keyframe values from the keyframe sequence (instead of from the normal emitter properties controlling that particle).


An SKPhysicsBody object is used to add physics simulation to a node.


An SKPhysicsContact object is created automatically by Sprite Kit to describe a contact between two physical bodies in a physics world.


An SKPhysicsJoint object connects two physics bodies so that they are simulated together by the physics world.


An SKPhysicsJointFixed object fuses two physics bodies together at a reference point.


An SKPhysicsJointLimit object imposes a maximum distance between two physics bodies, as if they were connected by a rope.


An SKPhysicsJointPin object allows two physics bodies to independently rotate around the anchor point as if pinned together.


An SKPhysicsJointSliding object allows the anchor points of the two physics bodies to slide along a chosen axis.


An SKPhysicsJointSpring object simulates connecting two physics bodies together with a spring.


An SKPhysicsWorld object simulates collisions and other physical properties.


An SKRange object defines a range of CGFloat values.


An SKReachConstraints object is used to describe the range of motion for an SKNode object whenever an inverse kinematic (IK) action is executed.


An SKRegion object defines a mathematical shape and is typically used to determine whether a particular point lies inside this area.


An SKShader object holds a custom OpenGL ES fragment shader.


An SKTexture object is an image that can be applied to SKSpriteNode and SKShapeNode objects or particles created by an SKEmitterNode object.


An SKMutableTexture object is a Sprite Kit texture whose contents can be dynamically updated.


An SKTextureAtlas object is a collection of related texture objects created from a texture atlas stored inside the app bundle.


An SKTransition object is used to perform an animated transition between a SKScene object already presented by an SKView object and a new incoming scene.


An SKUniform object is used to hold uniform data for a custom OpenGL or OpenGL ES shader.


The UIResponder class defines an interface for objects that respond to and handle events.


The SKNode class is the fundamental building block of most SpriteKit content.


A SK3DNode object is a Sprite Kit node that renders a Scene Kit scene as a 2D textured image.


A SKAudioNode object is used to add an audio to a scene.


An SKCameraNode object is used to specify a position in the scene that the scene can be rendered from.


An SKCropNode crops the pixels drawn by its children so that only some of the pixels are rendered to the parent’s framebuffer.


An SKEffectNode object renders its children into a buffer and optionally applies a Core Image filter to this rendered output.


An SKScene object represents a scene of content in Sprite Kit.


A SKEmitterNode object is a node that automatically creates and renders small particle sprites.


A SKFieldNode applies physics effects to physics bodies within a specific part of the scene.


An SKLabelNode is a node that draws a string.


A SKLightNode object is used to add lighting into a scene.


An SKReferenceNode object is a node that creates its children from an archived collection of other nodes.


An SKShapeNode object draws a shape defined by a Core Graphics path.


An SKSpriteNode is a node that draws a textured image, a colored square, or a textured image blended with a color.


An SKVideoNode object is a node that uses the AV Foundation framework to display live video content.


The UIView class defines a rectangular area on the screen and the interfaces for managing the content in that area.


An SKView object is a view that displays SpriteKit content.



An object that implements the SKPhysicsContactDelegate protocol can respond when two physics bodies are in contact with each other in a physics world.


The SKSceneDelegate protocol is used to implement a delegate to be called whenever the scene is being animated.

Other Reference

SpriteKit Function Reference