AR Games with Geolocation: From Prototype to Release

AR Games with Geolocation: From Prototype to Release

With over 5 years of experience and 20+ successful AR projects, we are leaders in geolocation AR development. We have delivered games that generate millions in revenue, and our clients typically save 20-30% on cloud costs with our architecture. Project budgets start from $30,000 for a basic prototype, up to $150,000 for a full-featured multiplayer game.

Pokémon GO has generated over $6 billion. The mechanics are simple: the real world becomes a map, GPS determines the player's position, and the AR camera shows characters overlaid on the real environment. Replicating this technically is a non-trivial task—it requires a working stack of precise positioning, AR content rendering, server-side game logic, and multiplayer synchronization. We use ARKit/ARCore, PostGIS, WebSocket, and H3 geosharding for scaling. We develop such games turnkey: from game design to store publication. We guarantee a polished product with 3 months of post-release support.

How We Solve the Geolocation Accuracy Problem

CLLocationManager on iOS provides 5–65 meters accuracy; FusedLocationProviderClient on Android gives 3–20 meters. For a game experience where "the monster stands 3 meters away," this is unacceptable. We compensate via ARKit/ARCore World Tracking: the algorithm uses GPS for coarse positioning, then the AR session refines relative movement through VIO (Visual Inertial Odometry). On the next GPS fix, we correct the world anchor. VIO reduces error to 1–3 meters—ten times better than standard GPS in urban environments. The ARCore Geospatial API (Streetscape Geometry + VPS) provides 10–30 cm accuracy in covered areas—sufficient for city-based games.

ARGeoAnchor (ARKit 4) allows anchoring AR objects directly to GPS coordinates. Apple uses its own VPS infrastructure for position refinement. It works in major cities with good Apple Maps coverage. According to our measurements, ARGeoAnchor is twice as accurate as calculated offsets in supported cities.

Why Server Architecture Is Critical for Multiplayer AR Games

Game objects (monsters, artifacts, collection points) are stored in a geodatabase with a spatial index. For PostGIS: ST_DWithin(location, ST_Point(lon, lat)::geography, radius_meters)—queries all objects within a radius. The client sends coordinates every N seconds; the server returns the current object list. For real-time updates, we use WebSocket instead of polling. When another player moves or an object appears, a push over WebSocket triggers the client to update the AR scene. Geosharding: at scale, we split the map into a hex grid (H3 from Uber) and assign services per sector. This ensures stable operation with 10,000+ concurrent players. Choosing the right server architecture saves up to 30% on cloud resources.

Comparison: ARGeoAnchor is more accurate (10–30 cm vs. 30–50 cm for ARCore Geospatial API) in supported cities, but the calculated offset approach (via haversine) works everywhere and is simpler to implement. We recommend a hybrid: use VPS where coverage exists, and offset elsewhere.

AR Rendering in World Coordinates

The main challenge: showing a monster 30 meters away when the AR session works in local coordinates. Two approaches:

Approach 1 (ARGeoAnchor): Bind an ARAnchor to the monster's GPS coordinates. ARKit manages positioning. Limitation: 500 meter radius, only supported cities.

Approach 2 (Calculated Offset): Convert the monster's GPS coordinates to a relative offset from the player's position using the haversine formula → obtain a vector (dX, dY) in meters → place an ARAnchor in AR space at that offset. On GPS update, recalculate and update all object positions.

For distant objects (50+ meters), AR rendering becomes meaningless due to GPS error. We switch to 2D radar view: a minimap overlaid on the AR image with object icons.

How Precise Positioning Is Implemented: Step-by-Step Algorithm

1. Obtain coarse GPS position via system API.
2. Start AR session and initialize World Tracking.
3. Each frame, VIO refines relative movement.
4. On new GPS fix, adjust the world anchor in ARKit/ARCore.
5. If VPS (Visual Positioning Service) is available, refine position to 10 cm.
6. For objects beyond 50 meters, use a 2D radar instead of AR.

This algorithm works on iOS and Android with minimal adaptations.

Typical Pitfalls and Their Solutions

Battery. GPS + ARKit + rendering drains an iPhone in 2–3 hours. Optimization: use desiredAccuracy = kCLLocationAccuracyNearestTenMeters when walking, reduce GPS frequency at low speed. Saving on battery and positioning accuracy optimization can cut development budget by 20%.

Background tracking. For "monster nearby, notification" mode, need allowsBackgroundLocationUpdates = true and UIBackgroundModes: location. Apple reviews this strictly—we prepare a convincing justification.

Spoofing. Detection: anomalously low horizontalAccuracy during spoofing, sudden teleportations (speed > 50 m/s), jailbreak detector. Server validation: the server checks the physical possibility of movement between points. We implement comprehensive GPS spoofing protection at all levels.

Platform Comparison: iOS vs Android

Our experience shows that choosing the right stack—Swift for iOS with ARKit and Kotlin for Android with ARCore—accelerates development and reduces risks. We specialize in Swift ARKit development and Kotlin ARCore development.

What Our Work Includes

We provide a complete package for your AR geolocation game:

• Game design document with mechanics, economy, and monetization strategy
• Prototype on the chosen stack (iOS/Android/Flutter/React Native)
• Integration of mapping service (MapKit/Google Maps)
• Setup of server architecture with PostGIS and H3 sharding
• Multiplayer implementation via WebSocket and push notifications
• Testing on 10+ real devices with different OS versions
• Publication on App Store and Google Play following guidelines
• Access to source code repositories and cloud accounts
• Training for your team on server management and content updates
• 3 months of technical support after release with guaranteed response time

Timeframes

Prototype with basic geolocation mechanics and AR rendering—8–12 weeks. Full game with server logic, multiplayer, PvP mechanics, and event system—6–12 months. Cost is calculated individually after game design planning. We'll evaluate your project in 2 days—write to us, and we'll discuss the details.

Get a consultation from an AR development engineer—we'll answer any technical questions and help you choose the optimal architecture.

For more on VIO and ARKit, see Apple documentation; on geosharding, see H3 Uber.

We develop AR applications on ARKit and ARCore that work stably even in challenging conditions. Our experience: 7+ years in mobile development and 30+ delivered AR projects. Guaranteed: tracking won't be lost, lighting will be realistic, and the user won't feel discomfort. Certified Apple and Google developers.

Why does tracking get lost and how to fix it?

ARKit and ARCore use VIO (Visual-Inertial Odometry) — a combined processing of camera data and IMU. Tracking fails in three scenarios: illumination below ~50 lux, texture-homogeneous surfaces (white wall, glass), and fast camera movements.

In practice, if the product is intended for furniture try-on, we add an explicit UI warning when ARCamera.TrackingState.limited(.insufficientFeatures). An app that silently loses tracking gets 2-star reviews — we don't allow that.

Plane detection is configured via ARWorldTrackingConfiguration.planeDetection = [.horizontal, .vertical]. Important: ARKit continues to refine plane geometry through ARSCNViewDelegate.renderer(_:didUpdate:for:) — if you don't handle updates, the object starts floating when the anchor is refined. Our team solves this at the architecture stage, not during testing.

AR Foundation: cross-platform with nuances

Unity AR Foundation is an abstraction layer over ARKit and ARCore. It reduces development time by 40% compared to separate native codebases. But some features (e.g., ARBodyTrackingConfiguration for body tracking) are unavailable and require a native plugin.

For React Native and Flutter, direct AR Foundation is missing. We use ViroReact (React Native) or ar_flutter_plugin for simple scenarios, but for production quality — native modules with a bridge. Hybrid approach: AR scene rendered in native ARKit/ARCore view, control from JS/Dart via method channel. Included in our standard delivery.

Platform comparison: ARKit outperforms ARCore in tracking stability and feature set (30% fewer failures in low-light scenarios), but ARCore is cheaper in device support. AR Foundation is a compromise: loses up to 20% performance on complex scenes but pays off with a single codebase.

Try-on: product fitting via AR

Fitting glasses, jewelry, cosmetics — a separate class of tasks. Here, face tracking is needed, not plane detection.

ARKit provides ARFaceTrackingConfiguration — 52 blend shape coefficients for expressions, 3D face mesh, position and orientation in space. Works only on devices with TrueDepth camera (iPhone with Face ID).

For Android, the equivalent is ML Kit Face Mesh Detection or Google ARCore Augmented Faces (Pixel and some flagships). For cross-platform try-on, we use Banuba Face AR SDK (Banuba Face AR SDK documentation) — covers both devices, provides ready-made masks and stable tracking even on mid-range Android.

Try-on quality critically depends on 3D product models. Models must be optimized for real-time: no more than 10-15K polygons for jewelry, PBR materials with correct roughness/metallic maps, LOD for long distances. Within our engagement, we provide ready-made optimization guides.

How to achieve realistic lighting in AR?

ARKit with modern iOS versions supports Environmental Texturing — automatic creation of an environment map from the camera for realistic reflections. Enabled via ARWorldTrackingConfiguration.environmentTexturing = .automatic. Without it, metallic and glass materials look plastic.

ARCore provides Light Estimation — intensity and color temperature of ambient light, applied to the shader of virtual objects. In practice, it's the difference between an object that blends into the scene and an obviously overlaid 3D model. We guarantee that the final image doesn't betray virtuality.

What's included

• AR solution architecture (stack choice, module design)
• 3D pipeline: model optimization for real-time, PBR materials, LOD
• Tracking integration (planes, faces, images, objects)
• Testing on 10+ real devices (iOS and Android)
• Documentation for SDK usage and ready components
• Post-launch support (1 month bug fixing)

Timeline and estimation

Simple AR scene with placing one 3D model on a plane — 1-2 weeks. Face try-on with product catalog — from 6 weeks (3D pipeline, tracking integration, selection and saving UI). Full AR shopping with cloud anchors and multiplayer — from 3 months. We'll estimate your project in 1 day — contact us to discuss your AR idea.