Mobile VR Application Development for Training

We develop mobile VR simulators that turn training into a realistic experience. Simulation quality matters more than graphical realism—the brain engages the same motor patterns as in real work. One project for an oil company: operators mastered new equipment in 3 days instead of 2 weeks, and the number of errors on the real site dropped by 50%. Request a free consultation to evaluate the potential for your business.

How Mobile VR Training Accelerates Personnel Preparation

VR simulators reduce training time by up to 60% through immersion in a near-real environment. Studies show that retention rate after 3 months post-VR training is 80%, compared to 20% for lectures and 30% for video. Thanks to the VR simulator, our employees reach full productivity twice as fast—this is feedback from a client in industrial service. Contact us to discuss your scenario.

Types of Training Scenarios and Their Technical Requirements

Different training scenarios require different architectural solutions:

How to Choose the Interaction Type for Mobile VR

Google Cardboard has a single button. For full object manipulation, you need either an additional Bluetooth device (gamepad) or build interaction solely on gaze + dwell. Gaze-based interaction: the user looks at an object, a progressive indicator appears (filling ring), and after 1.5–2 seconds—activation. For step-by-step training, this works well because each step is already predetermined—no need to deal with arbitrary manipulation.

Scenario Engine: State Machine for Training Scenes

A training module is always a branching scenario with success conditions, errors, and transitions. A rigid script doesn't work: you need to track user actions and react.

// Unity: ScenarioManager based on ScriptableObject
[CreateAssetMenu(menuName = "Training/Scenario")]
public class TrainingScenario : ScriptableObject {
    public List<TrainingStep> steps;
    public int currentStepIndex;

    public TrainingStep CurrentStep => steps[currentStepIndex];

    public StepResult ValidateAction(TrainingAction action) {
        var step = CurrentStep;
        if (step.RequiredAction == action) {
            currentStepIndex++;
            return currentStepIndex >= steps.Count
                ? StepResult.ScenarioComplete
                : StepResult.StepComplete;
        }
        step.ErrorCount++;
        return StepResult.WrongAction;
    }
}

TrainingAction is an enum of all possible user actions: GrabObject, PressButton, NavigateTo, ConfirmChoice. Each step can have hints that appear when ErrorCount > threshold.

What Matters When Developing Training Scenarios

Key elements: clear step sequence, error control with hints, ability to repeat failed steps, and scenario completion with result calculation. In emergency simulations, timers and random events are added. For soft skills—dialogue trees with NPCs.

What Metrics Are Collected During Training

Training without progress measurement is useless. Every user action is logged:

public struct TrainingEvent {
    public string userId;
    public string scenarioId;
    public int stepIndex;
    public TrainingAction action;
    public bool isCorrect;
    public float timeSpent;
    public int attemptNumber;
    public DateTimeOffset timestamp;
}

Metrics based on this data:

• Completion rate—how far the user progresses
• Error rate per step—where errors occur most often (reason to improve instructions or UI)
• Time-to-complete—improvement trend with each repetition
• Drop-off points—at which step users leave

Data is sent asynchronously to analytics (Firebase, custom backend). Batch transmission upon network recovery.

Spatial Audio as an Instructor

In training simulations, sound is not just background. A voice instructor narrates instructions. Positional audio directs attention: sounds from the target object are louder when the user turns in the right direction. On Android—Resonance Audio SDK. On iOS—AVAudioEnvironmentNode with positional sources. Subtitles are mandatory: some users use devices without headphones.

Content Updates Without Recompilation

Training scenarios change: new equipment, updated regulations. The Asset Bundle system in Unity allows loading new 3D assets and ScenarioScriptableObjects from the server without updating the app in the Store.

// Loading new training module as Asset Bundle
async Task<TrainingScenario> LoadScenarioBundle(string bundleUrl) {
    var bundle = await AssetBundle.LoadFromUriAsync(bundleUrl);
    return bundle.LoadAsset<TrainingScenario>("scenario");
}

Our Work Process

1. Analyze training content: domain, action types, required metrics.
2. Develop scenario engine: state machine, steps, success/error conditions, hints.
3. 3D content: create or adapt equipment models, environment.
4. Gaze interaction system, spatial audio instructor.
5. Analytics: event logging, backend submission, progress dashboard.
6. Asset Bundle system for updating modules without release.

At each stage, you receive a demo version for testing. Contact us to discuss your project details.

What Is Included in the Deliverable

• Application source code (Unity/C#) with documented scenario engine
• 3D models and assets with usage rights
• Analytics system with dashboard (Firebase or custom backend)
• LMS integration via SCORM/xAPI or REST API
• Instructions for creating and loading new modules via Asset Bundle
• Support during deployment and a 3-month warranty

Estimated Timeframes

One training module with a linear scenario and gaze interaction: 2–4 weeks. A platform with multiple modules, analytics, LMS integration, and content update system: 2–4 months. Our team has 5+ years of experience in VR development and has completed over 20 projects for industry. Get a consultation—contact us to discuss the details.

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.