The ARKit framework is Apple’s augmented reality platform that enables developers to create AR applications for iOS without deep knowledge of computer vision. According to Apple ARKit Documentation, 2025, the framework uses Visual-Inertial Odometry for precise tracking of device position in space without external markers. Semantic Scene Understanding allows recognizing horizontal and vertical planes, determining lighting, and placing virtual objects in the real environment.
Key Takeaways
ARKit is Apple’s augmented reality framework, announced at WWDC 2017 alongside iOS 11. It combines camera capabilities, M-series motion coprocessor, and the neural engine of A-chips to deliver an immersive AR experience without specialized hardware — just an iPhone or iPad.
ARKit uses Visual-Inertial Odometry (VIO), which combines data from the camera and Core Motion inertial sensors to accurately track device movement in space. VIO allows the framework to understand where the device is relative to its environment without using GPS or external markers.
According to Apple WWDC 2024, ARKit 6 is supported on devices with A12 chip and newer (iPhone XS, iPad Pro 2018+). The number of AR apps in the App Store has exceeded 15,000, and the total area of recognized planes across all AR sessions exceeds 100 billion square meters.
Over six versions, ARKit has received significant improvements: ARKit 1.0 (iOS 11) — basic tracking and plane recognition; ARKit 2.0 — shared AR sessions via ARWorldMap and 3D object detection; ARKit 3.0 — human body tracking, people segmentation, and simultaneous front and back cameras.
ARKit 4.0 introduced the LiDAR Scanner for instant depth and object occlusion determination, as well as Location Anchor for attaching AR content to GPS coordinates. ARKit 6 added 4K video with HDR, Plane Estimation using LiDAR, and improved occlusion handling.
import ARKit
let configuration = ARWorldTrackingConfiguration()
configuration.planeDetection = [.horizontal, .vertical]
configuration.environmentTexturing = .automatic
let arView = ARSCNView(frame: view.bounds)
arView.session.run(configuration)
arView.debugOptions = [.showFeaturePoints]
view.addSubview(arView)
ARKit operates through an AR session loop, which starts with a configuration and continuously analyzes the video stream from the camera. Each frame, the framework calculates device position (6 degrees of freedom), updates the map of recognized planes, and adjusts virtual object positions — all at 60 frames per second.
The VIO process consists of two parallel pipelines: the visual odometry algorithm tracks the movement of feature points between frames, while Core Motion inertial sensors predict movement over short intervals when the camera moves quickly or the image is blurred. Combining both methods gives tracking accuracy of up to 1 centimeter.
According to Apple, ARKit processes up to 500 feature points per frame, and the environment map (ARWorldMap) can reach up to 100 meters in diameter. Scanning the environment and building the map takes about 2–3 seconds after session launch — during this time ARKit accumulates data from the camera and sensors.
ARAnchor is a key object for placing content. When ARKit recognizes a plane, it creates an ARPlaneAnchor specifying the position, size, and orientation of the surface. The developer responds to the delegate method session(_:didAdd:) and places the 3D object at the detected plane location using SceneKit or RealityKit.
For implementing object dragging, ARHitTestResult is used: when the screen is touched, a hit-test is performed through the ARKit frame, which returns the ray intersection point with recognized planes. The found point is converted to an ARAnchor, and the object is fixed at that position.
func renderer(
_ renderer: SCNSceneRenderer,
didAdd node: SCNNode,
for anchor: ARAnchor
) {
guard let planeAnchor = anchor
as? ARPlaneAnchor else { return }
let boxNode = SCNNode(
geometry: SCNBox(
width: planeAnchor.extent.x,
height: 0.01,
length: planeAnchor.extent.z,
chamferRadius: 0
)
)
node.addChildNode(boxNode)
}
ARKit provides a set of technologies that make augmented reality realistic and functional: 6-degree-of-freedom motion tracking, scene understanding through plane and boundary recognition, lighting estimation for proper shadow rendering, people occlusion, and reflective surfaces based on environment maps.
Motion Capture (ARKit 3+) — technology for tracking the human body in real time through the camera. Allows animating characters with user movements without external sensors: 18 joints are recognized at 60 Hz. Used in fitness apps and for animation prototyping.
Shared AR sessions (ARKit 2+) allow multiple devices to see the same virtual objects in a shared space. ARWorldMap saves the environment map, which is transmitted to other devices over the network. Apple cites a synchronization accuracy example: two iPhone 12 Pro devices in the same room see the object with a deviation of no more than 2 centimeters.
The LiDAR scanner, built into the iPhone 12 Pro and newer, dramatically changes ARKit’s capabilities. Instead of software-based depth determination through image analysis, LiDAR instantly provides a depth map with accuracy up to 3 centimeters in a range of up to 5 meters. This allows ARKit to recognize planes instantly, without preliminary camera scanning.
With LiDAR, ARKit can determine object occlusion: a virtual object can be hidden behind a real chair or table. Additionally, Scene Reconstruction builds a 3D mesh of the environment in real time — up to 10 million polygons per room, used for collision physics simulation and realistic lighting.
// LiDAR Configuration
let lidarConfig = ARWorldTrackingConfiguration()
lidarConfig.planeDetection = [.horizontal]
lidarConfig.sceneReconstruction = .mesh
arView.session.run(lidarConfig)
// Plane Tap Detection
override func touchesBegan(
_ touches: Set<UITouch>,
with event: UIEvent?
) {
let location = touches.first?.location(in: arView)
guard let hitPoint = location else { return }
let results = arView
.raycastQuery(
from: hitPoint,
allowing: .existingPlaneInfinite,
alignment: .horizontal
)
}
Integrating ARKit starts with minimum requirements: Xcode 15+, iOS 17 SDK, a device with A12 Bionic chip or newer. The NSCameraUsageDescription key must be added to Info.plist — ARKit uses the camera for tracking and displaying the AR scene. Without this key, the app will crash when starting an AR session.
For content rendering, iOS offers three frameworks: SceneKit for medium-complexity 3D graphics, RealityKit for photorealistic rendering with PBR materials, and Metal for maximum performance. RealityKit is the recommended choice for new projects as it includes built-in support for ARKit features, animation, and physics.
According to Apple, the average time to integrate a basic AR screen into an existing app is about 2 hours for an experienced iOS developer. The main difficulties arise when working with UI element overlay on the AR scene and handling AR session interruptions — phone calls, app switching, or tracking loss in low light.
ARKit may lose tracking in several situations: insufficient lighting (less than 100 lux), lack of feature points (monochrome walls), fast camera movements, or lens obstruction. The ARSessionDelegate provides methods for handling these states — it is recommended to show user hints: “Move the device slower” or “Turn on the light.”
For recovery after a failure, ARKit automatically starts relocalization — it attempts to match the current video stream with the saved environment map. If relocalization is not possible, the session restarts with a new configuration. It is recommended to save the ARWorldMap when exiting the app for quick AR scene restoration upon return.
class ARViewController: UIViewController {
let arView = ARSCNView()
override func viewDidLoad() {
super.viewDidLoad()
arView.session.delegate = self
let config = ARWorldTrackingConfiguration()
config.planeDetection = [.horizontal]
config.frameSemantics = .personSegmentation
arView.session.run(config)
}
func sessionWasInterrupted(
_ session: ARSession
) {
showAlert("Session Interrupted")
}
}
Frequently Asked Questions
ARKit works on Apple devices with A12 Bionic chip and newer: iPhone XS, XR, 11, 12, 13, 14, 15, 16, and SE (2nd and 3rd generation), iPad Pro 2018+, iPad Air 2020+, iPad mini 2021+. LiDAR features require iPhone 12 Pro/Pro Max, iPhone 13 Pro/Pro Max, iPhone 14 Pro/Pro Max, iPhone 15 Pro/Pro Max, and iPad Pro 2020+.
Yes, ARKit can be used with Metal directly, but this requires writing custom shaders and rendering. SceneKit and RealityKit provide ready-made solutions with ARKit integration at the framework level. For beginners, RealityKit is the optimal choice as it automatically handles ARKit functions.
ARKit automatically evaluates scene lighting through the camera and provides data on direction, intensity, and color temperature of the light source via AREnvironmentProbeAnchor. This allows virtual objects to correctly cast shadows and reflect the environment, creating a realistic blend with the real world.
ARKit works only on iOS and uses Visual-Inertial Odometry for tracking, while Google’s ARCore works on Android and uses its own Motion Tracking based on IMU and camera. ARKit has an advantage through hardware integration with Apple chips, while ARCore offers cross-platform capability through Cloud Anchors.
Yes, ARKit is ideal for AR games. SceneKit and RealityKit support physics (SCNPhysicsBody, PhysicsSimulation), animation, sound, and particles. Well-known examples include Pokémon GO (uses its own engine with ARKit), Angry Birds AR, and Lego AR Studio. ARKit also supports multiplayer sessions via ARWorldMap.
Summary
We will develop a mobile application turnkey
IT Sectr creates iOS and Android applications for startups and businesses since 2017. We will advise you and propose the best solution.
Read also