# ARKit-CoreLocation: GPS-Accurate AR Annotations for iOS

> ARKit-CoreLocation (ARCL) is a Swift library that combines ARKit's spatial tracking with CoreLocation's GPS data to place AR annotations at real-world geographic coordinates. It targets apps that need to show AR overlays tied to map locations rather than to nearby tracked surfaces.

**AndrewHartAR/ARKit-CoreLocation** — Combines the high accuracy of AR with the scale of GPS data.

- Repository: https://github.com/AndrewHartAR/ARKit-CoreLocation
- Stars: 5,525 · Forks: 725
- Language: Swift
- License: MIT
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/andrewhartar-arkit-corelocation

## Placing AR Objects at Geographic Coordinates

ARKit-CoreLocation solves a specific problem: placing an augmented reality object not at a point in space tracked by the camera but at a specific latitude, longitude, and altitude on the globe. The README describes the library as combining the high accuracy of AR with the scale of GPS data. This combination matters when building apps like AR navigation, tourist guides, or any experience that needs to tie a floating label or marker to a real-world address.

Without a library like ARCL, the developer would need to handle the coordinate transformation manually: take a GPS coordinate, compute its position relative to the device's current GPS location, convert that delta to ARKit scene units, and place a SceneKit node there. ARCL encapsulates that transformation in the SceneLocationView class and the LocationNode hierarchy.

The library comes with two main capabilities. First, it allows placing items in the AR world using real-world coordinates. Second, it implements an experimental improvement to location accuracy by combining recent GPS data points with knowledge about movement through the AR world. The README explicitly labels the improved accuracy as experimental.

## How ARCL Bridges ARKit and CoreLocation

ARKit uses camera and motion data to map out the local world as you move around it. It builds a spatial understanding of the immediate environment at centimeter-level precision, but it has no concept of global location. CoreLocation uses Wi-Fi and GPS data to determine your position on Earth but delivers accuracy measured in meters at best, sometimes tens of meters in dense urban areas.

ARCL bridges these two systems by anchoring the AR coordinate system to a GPS fix at startup. As the device moves, ARKit tracks motion with high precision. CoreLocation provides periodic GPS updates. The library correlates the two: it knows where you started (from GPS), how you have moved (from ARKit), and uses that to refine the position estimate of each placed annotation.

This approach is why the improved accuracy is labeled experimental. The combination is sound in principle but the accuracy gains depend on the quality of the initial GPS fix and on the device moving in ways that are trackable by ARKit. Indoor use, poor GPS signal, and rapid movement can degrade the estimates.

## Installing ARCL and Required Plist Entries

ARCL is available through CocoaPods. Add the following line to your Podfile.

```
pod 'ARCL'
```

Then, in your project folder, run:

```
pod update
pod install
```

Installation also requires Swift Package Manager and manual installation paths. For SPM, a Package.swift file is present in the repository. For manual installation, add all files from the `ARKit+CoreLocation/Source` directory and import ARKit, SceneKit, CoreLocation, and MapKit.

After installation, you must add two keys to your app's Info.plist before the device will grant the required permissions. Without these entries, iOS will not prompt the user for camera or location access and the app will fail silently.

```
NSCameraUsageDescription
NSLocationWhenInUseUsageDescription
```

The demo project in the repository includes these entries and can serve as a reference for the required configuration. The README specifically calls out reading the section on True North calibration as important before building, since ARKit's magnetic north calibration affects the accuracy of compass-based placement.

## Placing Annotations with SceneLocationView

The primary class is SceneLocationView, which manages the AR session and the collection of location-anchored nodes. You declare it as a property, call run() when the view comes into focus, and call pause() when it is interrupted.

```swift
import ARCL
import CoreLocation

class ViewController: UIViewController {
  var sceneLocationView = SceneLocationView()
}
```

To display a pin above a specific coordinate, you create a CLLocation with latitude, longitude, and altitude, then wrap it in a LocationAnnotationNode.

```swift
let coordinate = CLLocationCoordinate2D(latitude: 51.504571, longitude: -0.019717)
let location = CLLocation(coordinate: coordinate, altitude: 300)
let image = UIImage(named: "pin")!
let annotationNode = LocationAnnotationNode(location: location, image: image)
```

The README shows this example placing a pin above Canary Wharf in London at an altitude of 300 meters. Adding the node to the scene uses addLocationNodeWithConfirmedLocation.

```swift
sceneLocationView.addLocationNodeWithConfirmedLocation(locationNode: annotationNode)
```

LocationAnnotationNode can also be initialized with a UIView or a CALayer. The UIView path converts the view to a UIImage, which means the content cannot be updated dynamically after placement. The CALayer path allows live updates to the annotation's appearance while it is displayed in the scene.

## Touch Handling and the Scale Option

ARCL provides a touch delegate for responding to taps on annotation nodes. To receive touch events, you conform your view controller to LNTouchDelegate.

```swift
class ViewController: UIViewController, LNTouchDelegate {
```

The annotationNodeTouched method receives an AnnotationNode when a user taps a node created from a LocationAnnotationNode. AnnotationNode is a subclass of SCNNode with two properties: image (UIImage?) and view (UIView?). One of these will be populated depending on how the LocationAnnotationNode was initialized.

The locationNodeTouched method receives a LocationNode when the user taps a node created from polyline directions, such as the rendered waypoints of an MKRoute.

Annotation scaling has a configurable option. By default, the README states that annotations appear at a fixed screen size regardless of their distance from the viewer. Setting scaleRelativeToDistance to true on a LocationAnnotationNode changes this so that distant annotations appear smaller than nearby ones. The fixed-size default ensures that far annotations remain visible; the relative-scale option produces a more physically intuitive sense of depth.

## Device Requirements and Known Limitations

ARKit requires iOS 11. The README lists the supported device set: iPhone 6S and upwards, iPhone SE, iPad (2017), and all iPad Pro models. Devices not in this list do not have the motion coprocessor and camera combination that ARKit requires. The library has no path for older hardware.

The improved location accuracy remains experimental. In environments where GPS quality is low, such as indoors, in urban canyons, or at the start of a session before the GPS fix stabilizes, the accuracy benefit over raw CoreLocation data is uncertain. The README does not quantify the accuracy improvement or describe the conditions under which it reliably activates.

A known architectural limitation exists for UIView-based annotations. When you initialize a LocationAnnotationNode with a UIView, the view is immediately converted to a UIImage. After that point you cannot push updates to the annotation's visual content. If your annotation needs to display live data, you must use the CALayer initializer instead.

The most recent formal release is 1.2.1, from August 2019. The repository shows a commit on 2026-06-02, so the code base is not completely dormant, but the seven-year gap between releases and recent commits means the codebase may rely on ARKit APIs from iOS 11 or 12 that have since changed.

## ARKit-CoreLocation vs. MapKit Overlays

MapKit is Apple's built-in framework for displaying maps and annotations. An MKAnnotation displays a pin on a 2D map view. The fundamental difference from ARCL is dimensionality: MapKit annotations live on a flat map surface in a 2D top-down view, while ARCL annotations float in a 3D AR environment that the camera looks through.

For use cases where the user is looking at a map to navigate or find a location, MapKit is the appropriate tool. It requires no camera permission, works on all iPhone models, and has decades of documentation and community support.

For use cases where the user wants to point their phone at a building or a street corner and see an overlay appear above the actual physical location, ARCL is the path. The user experience is fundamentally different: instead of looking down at a map, the user looks through the camera at the real world.

ARKit-CoreLocation also includes a demo that shows MKRoute directions rendered as polyline nodes in the AR environment, bridging the two frameworks. This suggests the intended use case covers navigation assistance where turn-by-turn directions appear in the AR view rather than on a separate map screen.

## Conclusion

ARKit-CoreLocation is the right library for iOS developers who need to overlay AR annotations on real-world GPS locations, such as building markers, navigation waypoints, or points of interest. It is the wrong choice for apps that only need a 2D map pin, for projects targeting iOS versions below 11, or for use cases where the experimental location accuracy improvement has not been validated. The most recent formal release is 1.2.1, published in 2019. The repository has received commits since then, including a push on 2026-06-02, but the absence of new tagged releases means that using the library requires building from source or specifying the podspec reference rather than a stable release version.

## FAQ

### What does ARKit do in the context of ARKit-CoreLocation?

The README describes ARKit as using camera and motion data to map out the local world as you move around it. In ARCL, ARKit provides the high-precision spatial tracking that allows annotations to remain fixed at their intended positions as the user moves, compensating for the lower accuracy of GPS-only positioning.

### Which iPhones support ARKit and therefore ARCL?

The README lists the supported device set for iOS 11 ARKit: iPhone 6S and upwards, iPhone SE, iPad (2017), and all iPad Pro models. Devices older than iPhone 6S do not have the required hardware for ARKit.

### Can the content of a LocationAnnotationNode be updated dynamically after it is placed?

It depends on how the node was initialized. The README states that when initialized with a UIView, the view is immediately converted to a UIImage and cannot be updated dynamically. When initialized with a CALayer, the content can be updated live while the node is displayed in the scene.

## Sources

- [AndrewHartAR/ARKit-CoreLocation on GitHub](https://github.com/AndrewHartAR/ARKit-CoreLocation)
- [Issues](https://github.com/AndrewHartAR/ARKit-CoreLocation/issues)
- [License: MIT](https://github.com/AndrewHartAR/ARKit-CoreLocation/blob/develop/LICENSE)
- [README](https://github.com/AndrewHartAR/ARKit-CoreLocation/blob/develop/README.md)
- [Releases](https://github.com/AndrewHartAR/ARKit-CoreLocation/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/andrewhartar-arkit-corelocation