Developing Mobile VR Apps for Google Cardboard

Google Cardboard is the most accessible way to experience VR: a cheap cardboard viewer, your smartphone inside. For developers, this means stereoscopic rendering, orientation tracking via IMU, and strict performance constraints—all on ordinary mobile hardware without a dedicated VR processor. We develop VR applications for Cardboard on iOS and Android using Swift and Kotlin. Our team has 5 years of mobile VR development experience with over 20 projects. Our development services start at $2,000 for simple VR experiences and range up to $15,000 for fully interactive apps. Below we break down key technical challenges and their solutions.

How to Avoid VR Sickness in Google Cardboard

Motion sickness occurs when visual latency exceeds 20ms. The IMU runs at 200–1000Hz, but rendering is at 60Hz. To compensate, we use Asynchronous TimeWarp (ATW)—reprojecting the last frame with the latest head orientation between render and display. The Cardboard SDK implements ATW automatically. Make sure Cardboard.SDK.UpdateScreenParams() is called at the beginning of each Update(), not less frequently.

Scene Design recommendations to reduce discomfort:

• No acceleration-based locomotion (teleportation is preferred)
• A stable horizon or cockpit reference (interior) reduces nausea
• Do not scale the world relative to the player at runtime

Stereoscopic Rendering: Split-Screen

The display is split in half: left half for left eye, right half for right eye. Each half is rendered with a slight camera offset (IPD—interpupillary distance, ~63–65mm). The difference between the two images creates the stereo effect.

In Unity, this is managed via the CardboardCamera component with two render textures. Each texture renders separately, then barrel distortion correction is applied.

A critical performance issue: two-pass rendering doubles GPU load. On a mid-range smartphone at 1080p, this yields 30–40 FPS without optimization. Solutions:

• Foveated rendering—reducing resolution at the edges (the central area is visible through the lenses)
• Single Pass Instanced Rendering in Unity (both eyes in one draw call). This method is 2x faster than two-pass.
• Reducing render texture resolution to 0.7–0.8 of the screen resolution

Orientation Tracking and SDK Integration

After Google open-sourced the Cardboard SDK in 2021(Wikipedia), it became the official path for Cardboard apps on iOS and Android. The SDK provides:

• Distortion correction for lenses (each viewer has its own lens distortion profile, scanned via QR code)
• Head tracking through fusion of accelerometer and gyroscope data (IMU fusion)
• Eye matrices for correct projection per eye
• Trigger button handling (magnetic button in the cardboard viewer)

Unity integration: com.google.cardboard UPM package. After adding:

void Update() {
    Cardboard.SDK.UpdateScreenParams();
    // Head position/rotation applied automatically via CardboardCamera component
}

Native Android integration via CardboardHeadTracker and CardboardLensDistortion:

headTracker = CardboardHeadTracker.create();
lensDistortion = CardboardLensDistortion.create(encodedDeviceParams, width, height);
headTracker.getPose(monotonic_time_nanos, target_time_nanos, outEyeFromHead);

Input: Button and Gaze

The basic Cardboard has one button. All interaction is built on:

• Gaze input—the cursor follows the gaze, activation via dwell time (usually 1.5–2 sec)
• Trigger button—confirms selection, teleportation

Gaze reticle renders in world space at a fixed distance from the camera. Raycasting from the center of each eye determines the object under the cursor:

void Update() {
    Ray ray = new Ray(Camera.main.transform.position, Camera.main.transform.forward);
    if (Physics.Raycast(ray, out RaycastHit hit, maxDistance, interactableLayer)) {
        gazeTarget = hit.collider.GetComponent<IGazeable>();
        gazeTarget?.OnGazeEnter();
        gazeTimer += Time.deltaTime;
        if (gazeTimer >= DWELL_TIME) {
            gazeTarget?.OnGazeActivate();
            gazeTimer = 0f;
        }
    } else {
        gazeTarget?.OnGazeExit();
        gazeTimer = 0f;
    }
}

QR Scanning the Device Profile

On first launch, the user scans the QR code from the Cardboard viewer. The SDK loads the lens distortion profile for that specific viewer. Without this step, the distortion is incorrect—the image looks deformed. The Cardboard SDK saves the profile in SharedPreferences / NSUserDefaults after scanning. Add an instruction screen with a QR icon on first launch and an explicit “Re-scan device” button in settings.

What We Deliver (Deliverables)

• Source code of the application with comments
• API documentation and key component documentation
• User instructions for QR scanning
• Access to the project repository and development tools
• Training session for your team (up to 2 hours)
• Support during App Store and Google Play publication
• Testing on 5+ devices across different price segments
• Quality assurance report
• Guaranteed on-time delivery and certified Unity developers with proven experience
• Detailed project plan and progress reports
• Post-launch support for 30 days

Our Process

1. Analysis: Determine the app type (passive experience or interactive), target audience, and performance requirements.
2. Cardboard SDK setup: Integrate the Unity package or native SDK, configure projection.
3. Scene development: Model with VR constraints in mind, implement gaze input.
4. Optimization: Apply Single Pass Instanced, foveated rendering, LODs, FPS testing.
5. Testing: Test on devices of various price segments, assess comfort.
6. Deployment: Prepare builds, upload to App Store Connect and Google Play Console.

Timeline and Cost Estimates

A simple passive VR experience (360 content, basic gaze navigation) takes 1–2 weeks. An interactive VR application with game mechanics, multiple scenes, and full UI takes 2–3 months.

Development cost: simple experiences start from $2,000, interactive apps range $5,000–$15,000. Our rates are competitive—typical VR app for Cardboard costs between $2,000 and $15,000.

Estimate your project: contact us for a preliminary timeline and cost. Order mobile VR app development for Google Cardboard—get a consultation from an experienced engineer with a proven track record of 20+ successful projects and 100% client satisfaction.

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.