System Requirements

GlamAR’s AR Try-On SDKs and APIs are built to deliver high-quality Augmented Reality (AR) experiences across multiple platforms and devices. To maintain consistent visual fidelity and smooth performance, your implementation should meet the recommended environment and hardware standards described below.

This guide outlines the supported platforms, browsers, and system conditions required to ensure optimal functionality and a reliable AR experience for end users.

Supported Platforms

Web SDK
Supports Chrome (desktop/mobile), Safari (iOS 11+), and Firefox.
Performance depends on device hardware and browser implementation of WebGL.

Android SDK
Compatible with Android 10+ (API 29).
Delivers optimal performance on Android 11 and newer devices with full Camera2 API support.

iOS SDK
Requires iOS 13+.
Performs best on iPhone XR, 11, and newer models that support Metal rendering.

React Native SDK
Runs on Android and iOS, following the respective native SDK specifications.
Expect slight overhead due to the JavaScript bridge between React Native and native code.

Flutter SDK
Available for Android and iOS.
Performance may vary depending on the Dart VM and platform-specific WebView implementation.

Smart Mirror SDK
Designed for Android-powered kiosks or smart mirror devices.
Requires mid-range or higher hardware (see detailed specifications in the next section).

Tablets
Fully supports Android tablets.
iPads are supported via the Web SDK only; landscape orientation is recommended for optimal AR alignment.

Info: In-app browsers (Instagram, Facebook WebView, TikTok, etc.) are not supported. Camera APIs in these environments are restricted, preventing AR functionality.

Browser Compatibility (Web SDK Only)

The GlamAR Web SDK runs on all major modern browsers that support WebGL 2.0, and WebAssembly APIs. Performance varies based on browser engine optimizations, device hardware, and operating system limitations.

Chrome

• Supported on: Android 66+, Desktop 66+
• Expected performance: ~8 - 28 FPS, hardware-dependent
• Notes: Chrome provides the most consistent WebGL performance across platforms.

Safari

• Supported on: iOS 11+, Desktop 11.1+
• Expected performance: ~6 - 24 FPS
• Notes: Uses Apple’s WebKit engine; camera and WebGL performance are limited by iOS sandboxing.

Firefox

• Supported on: Android 60+, Desktop 60+
• Expected performance: ~8 - 25 FPS
• Notes: Rendering quality is stable, but some mid-tier devices may show reduced frame rates.

Edge (Chromium)

• Supported on: Desktop 88+
• Expected performance: ~8 - 28 FPS
• Notes: Shares Chromium engine with Chrome, offering comparable results.

Performance Summary

• Chrome on iOS runs on WebKit, not Blink – performance mirrors Safari.
• Entry-level devices: ~6 - 12 FPS across browsers.
• Mid-range devices: ~14 - 25 FPS, with Chrome and Edge generally performing best.
• Flagship devices: 24 - 28 FPS or higher, with full WebGL 2.0 support and stable thermal behavior.

Tip: Always test performance on physical devices rather than simulators or browser throttling modes, as AR rendering heavily depends on hardware GPU capabilities.

Device Compatibility

The performance of GlamAR’s AR Try-On SDK depends heavily on device hardware, particularly the CPU, GPU, and camera subsystem.

Below are general guidelines to help you estimate real-world frame rates and select appropriate devices for development or deployment.

Performance by Hardware Tier

Entry-Level Devices
Typical CPUs: Snapdragon 4xx, Helio P22/P35

• Expected performance: ~10 - 15 FPS
• Recommended for: Basic try-on experiences or lightweight AR demos
• Notes: May show reduced tracking accuracy under low light or network load.

Mid-Range Devices
Typical CPUs: Snapdragon 6xx / 7xx, MediaTek Dimensity 700 - 900

• Expected performance: ~20 - 28 FPS
• Recommended for: Full-featured AR Try-On experiences
• Notes: Stable tracking and consistent performance for most use cases.

Flagship Devices
Typical CPUs: Snapdragon 8 Gen+, Apple A14 Bionic or newer

• Expected performance: 30 FPS or higher
• Recommended for: Premium or production-grade AR experiences
• Notes: Delivers the best visual fidelity, stable FPS, and quick startup times.

Tablet Support

Android Tablets

• Fully supported using the native Android SDK or Web SDK (via Chrome).
• Performance tiers typically range from mid-range to flagship, depending on CPU and GPU.

iPadOS

• Limited support via the Web SDK only (Safari).
• Uses iOS camera APIs; suitable for demos or light AR sessions rather than production deployments.

Example Models

• iPad Pro (2021+): Flagship tier, 26 - 30 FPS, 12 MP front camera with Apple Neural Engine.
• Samsung Galaxy Tab S8 / S9: Flagship tier, 28 - 30 FPS, excellent AR tracking and optics.
• Lenovo P12 Pro / Yoga Tab: Mid-range tier, 18 - 24 FPS, good camera quality for testing.

Tip: Maintain adequate lighting and stable device positioning for optimal face tracking and detection accuracy.

Smart Mirror and Kiosk Support

The GlamAR SDK can run on Android-powered kiosks and smart mirror devices when paired with mid-range or higher hardware.

Recommended Specifications:

• Camera: Logitech Brio 4K or Intel RealSense D415
• CPU: Intel i5/i7 (10th Gen or newer) or Apple M1/M2 chip
• RAM: Minimum 8 GB
• GPU: Not required unless performing on-device ML inference
• Display: 15" or larger, Full HD resolution; touch-enabled preferred

The Android SDK performs reliably on most kiosk builds that meet or exceed mid-range specifications.

Camera Requirements

The quality of the camera directly affects the accuracy and realism of AR Try-On experiences.

While the GlamAR SDK works with standard front-facing cameras, using higher-quality or depth-enabled sensors can significantly improve tracking precision and detection stability, especially in professional or in-store environments.

Recommended Camera Specifications

Smart Mirrors

• Minimum spec: 720p or higher, fixed-position, high-lumen front camera
• Requirement: Must support low-latency capture to maintain real-time response during AR rendering
• Recommendation: Use wide-angle lenses and ensure consistent, well-lit setups for best results.

Web SDK (General Use)

• Minimum spec: 480p or higher browser-accessible camera
• Environment tip: Avoid extreme over or underexposed lighting conditions for accurate facial mapping and color rendering.

Note: For most use cases, a standard webcam or smartphone front camera provides sufficient accuracy.

GlamAR does not require motion-tracking or depth-sensing cameras, but these devices can significantly enhance accuracy for advanced use cases such as:

• Pupillary Distance (PD) measurement
• Smart mirror and in-store kiosk experiences
• High-precision facial tracking and sizing visualization

If you’re deploying GlamAR in retail environments, smart mirrors, or other professional setups, we recommend using a depth camera (such as Intel RealSense or Azure Kinect) to improve stability and calibration.

3D Model Specifications

The GlamAR SDK supports modern 3D file formats optimized for web and mobile rendering. Follow these guidelines to ensure your models load quickly and render with accurate materials and lighting.

Format
Use .glb or .gltf whenever possible. These formats are optimized for runtime streaming and texture compression. The SDK also supports .fbx and .usdz, but they may require additional processing before import.

Maximum File Size
Keep individual model files under 10 MB. Smaller assets reduce load time and memory footprint, improving startup speed, especially on mobile networks.

Texture Resolution
Target 2048 × 2048 (2K) texture maps for balanced quality and performance. Higher resolutions offer diminishing visual returns but increase GPU load.

Hosting
Host models on PixelBin CDN or serve them via a secure HTTPS URL. Using PixelBin-hosted assets ensures optimal caching and faster regional delivery.

Network Requirements

GlamAR’s AR Try-On SDK delivers 3D assets, models, and live camera streams in real time. Stable network connectivity is essential to ensure smooth rendering, low latency, and consistent user experience.

Recommended Connectivity:

Downlink Speed

• Minimum: 2 Mbps
• Recommended: 3 - 5 Mbps
• This bandwidth ensures fast model downloads and responsive rendering even for high-resolution assets.

Latency

• Minimum: < 300 ms
• Recommended: < 150 ms
• Lower latency improves synchronization between camera frames, face tracking, and AR overlays.

Content Delivery

• Models and textures are served through PixelBin CDN and cached locally per session.
• Using a CDN significantly reduces model load times and repeat download overhead.

Network Types

• Fully compatible with Wi-Fi, 4G+, and 5G networks.
• Avoid unstable mobile networks (e.g., 3G or captive portals) that may block asset streaming or camera permissions.

Best practices:

• Cache frequently used 3D models to minimize repeat fetches.
• For large product catalogs, use progressive model loading.
• Monitor initial load times on target networks; aim for < 2 seconds on high-speed connections.
• Always initialize the SDK over HTTPS to comply with browser and OS camera-access restrictions.

Performance Benchmarks

Hardware Performance Tiers

The GlamAR AR Try-On SDK uses advanced face-detection and 478-point 3D facial landmark-tracking models that demand substantial compute and GPU resources. Performance varies across device classes; the following tiers describe expected results and optimal configurations.

Entry-Level Hardware:

Typical Components

• CPU: ARM Cortex-A53/A55, Snapdragon 4xx series, MediaTek Helio P22/P35
• GPU: Adreno 505/506, PowerVR GE8300/8320, Mali-G52 MP1/MP2
• RAM: 3 - 4 GB

Expected Performance

• ≈ 10 - 15 FPS during AR VTO rendering
• Adequate for basic try-on experiences and small product catalogs

Platform Notes

• Android: 10 - 12 (API 29 - 31); future optimizations planned
• iOS: iPhone 7 / 8, iPad (6th gen); limited AR capability

Mid-Range Hardware:

Typical Components

• CPU: ARM Cortex-A76/A78, Snapdragon 6xx/7xx, MediaTek Dimensity 700 - 900
• GPU: Adreno 618/640, Mali-G76 MP4/MP12, PowerVR GM9446
• RAM: 6 - 8 GB

Expected Performance

• ≈ 20 - 28 FPS for full-featured AR Try-On sessions
• Stable tracking and smooth rendering under most lighting conditions

Platform Notes

• Android: 11 - 14 (API 30 - 34), full feature support
• iOS: iPhone XR / 11 / 12, iPad Air (3rd gen +), excellent performance

Flagship Hardware:

Typical Components

• CPU: ARM Cortex-X1/X2, Snapdragon 8 Gen 1+, Apple A14 Bionic or newer
• GPU: Adreno 730+, Mali-G710/G715, Apple GPU (A14+)
• RAM: 8 GB or more

Expected Performance

• 30 FPS or higher, delivering premium AR experiences with maximum visual fidelity
• Fast model loading and minimal latency

Platform Notes

• Android: 14 + (API 34 +), latest runtime optimizations
• iOS: iPhone 13 +, iPad Pro (M1/M2), peak performance tier

Performance tips:

• Ensure the device is well-lit and thermally stable; sustained high GPU load can reduce FPS over time.
• On mid-tier devices, limit simultaneous AR objects or background filters to maintain stability.

Real-Time AR Try-On Performance

The GlamAR SDK performs real-time face detection and 3D landmark tracking using high-precision neural models.

Performance varies by hardware tier and platform implementation. The following ranges represent typical frame rates observed during active AR Try-On sessions.

Face Detection and Landmark Tracking

Hardware Tier	Face Detection FPS	Landmark Tracking FPS	Overall FPS
Entry-Level	15 - 20	12 - 15	10 - 15
Mid-Range	25 - 30	20 - 25	20 - 28
Flagship	30+	30+	30+

Platform-specific Performance

Platform	Entry-Level	Mid-Range	Flagship	Notes
Web SDK (Chrome)	8 - 12 FPS	18 - 25 FPS	28+ FPS	WebGL performance dependent
Web SDK (Safari)	6 - 10 FPS	14 - 20 FPS	24+ FPS	WebKit limitations apply
Android Native	12 - 15 FPS	22 - 28 FPS	30+ FPS	Optimal performance
iOS Native	10 - 14 FPS	20 - 26 FPS	30+ FPS	Metal rendering advantage
React Native	10 - 13 FPS	18 - 24 FPS	26 - 30 FPS	Bridge overhead
Flutter	11 - 14 FPS	19 - 25 FPS	28 - 30 FPS	Dart VM performance

Model Processing Benchmarks

The GlamAR SDK uses deep-learning models for face detection and 3D landmark tracking.
Processing speed and memory footprint vary depending on the device’s hardware tier.

The following benchmarks reflect typical performance measured during runtime.

Face Detection Model

Hardware Tier	Input Resolution	Processing Time	Memory Usage
Entry-Level	192 x 192	80 - 120 ms	150 - 200 MB
Mid-Range	192 x 192	40 - 60 ms	200 - 250 MB
Flagship	192 x 192	20 - 35 ms	250 - 300 MB

Note: Higher-end CPUs and GPUs can process face detection in under 35 ms per frame, keeping latency imperceptible to users.

3D Landmark Model

Hardware Tier	Input Resolution	Processing Time	Memory Usage
Entry-Level	256 x 256	100 - 150 ms	200 - 300 MB
Mid-Range	256 x 256	50 - 80 ms	300 - 400 MB
Flagship	256 x 256	25 - 45 ms	400 - 500 MB

Note: Landmark tracking is computationally heavier than detection, particularly on entry-tier hardware where performance may dip under 20 FPS.

3D Model Loading Performance

Model loading time depends on asset size, compression, network speed, and device hardware. The values below represent typical load times measured during AR Try-On initialization across hardware tiers.

Scenario	Entry-Level	Mid-Range	Flagship	Notes
First-time load	4 - 8 seconds	2 - 4 seconds	1 - 2 seconds	Includes fetch + compile
Cached Model load	1.5 - 2.5 seconds	800 ms - 1.2 seconds	400 - 700 ms	Browser app caching
Optimized GLB	3 - 6 seconds	1.5 - 3 seconds	800 ms - 1.8 seconds	Compressed models

Performance Optimization Recommendations

The GlamAR SDK dynamically scales its AR rendering pipeline across device tiers.
Below are current best practices and upcoming SDK-level enhancements designed to optimize AR performance for various hardware classes.

Entry-Level Hardware Optimizations:
The following SDK-level optimizations are planned for future releases to improve performance on low-end devices. These features will automatically activate based on device capability detection.

• Automatic frame skipping: Processes every second frame to maintain responsiveness under heavy load.
• Dynamic camera resolution: Adjusts capture resolution down to 480p to reduce GPU strain.
• Progressive model loading: Loads models in stages to show content sooner.
• Simplified AR overlays: Reduces visual complexity for smoother rendering.
• Performance mode detection: Automatically detects hardware tier and applies optimal configuration.

Note*:* These optimizations require SDK-level implementation and cannot be achieved through application-layer modifications. Significant performance improvements for entry-level devices will become available in future releases.

Mid-Range Hardware Optimizations:

• Maintain a standard 720p camera resolution for balance between clarity and performance.
• Keep the full AR feature set enabled (lighting, filters, face mesh tracking).
• Implement adaptive quality to respond to thermal throttling or power-saving states.
• Preload frequently used 3D models during app idle time to minimize user-perceived load times.

Flagship Hardware Optimizations:

• Use up to 1080p camera resolution for maximum visual fidelity.
• Enable enhanced AR effects and animations such as reflections, particle effects, and advanced lighting.
• Leverage multi-model parallel processing for simultaneous product try-ons or comparisons.
• Utilize advanced rendering techniques (e.g., Metal/Vulkan pipelines) for the most realistic output.

Memory Requirements by Hardware Tier

The GlamAR SDK performs advanced facial tracking and 3D rendering, which can be memory-intensive.

Below are the approximate memory thresholds required for smooth performance across hardware classes.

Entry-Level Devices

• Minimum RAM: 3 GB
• Recommended: 4 GB
• Peak usage: 600 - 800 MB during active AR sessions
• Sufficient for lightweight try-on experiences; memory spikes may occur with multiple models.

Mid-Range Devices

• Minimum RAM: 4 GB
• Recommended: 6 GB
• Peak usage: 800 MB - 1.2 GB
• Ideal for full-featured AR sessions with high-resolution textures.

Flagship Devices

• Minimum RAM: 6 GB
• Recommended: 8 GB or more
• Peak usage: 1.2 - 1.8 GB
• Handles complex multi-model scenes and premium visual effects smoothly.

Network Impact on Performance

Network speed directly influences how quickly AR assets are fetched, compiled, and rendered in real time.

3G / Slow 4G

• Model download: 15 - 30 seconds
• Real-time performance: Possible stuttering or delayed model load
• Recommended for: Entry-level devices only

4G / LTE

• Model download: 3 - 8 seconds
• Real-time performance: Generally smooth with occasional frame drops
• Recommended for: Mid-range and above

5G / Wi-Fi

• Model download: 1 - 3 seconds
• Real-time performance: Near-instant loading and stable tracking
• Recommended for: All hardware tiers

Built-in SDK optimizations:

The GlamAR SDK includes several automatic optimizations to maintain consistent performance across devices and networks:

• Intelligent Model Caching: Models are stored locally after the first load, reducing repeat network requests.
• CDN-Optimized Delivery: PixelBin CDN accelerates global asset distribution, minimizing load latency.
• Progressive Loading: Models stream in stages, improving perceived performance and reducing wait times.
• Thermal Management: The SDK scales internal performance to prevent overheating and sustain long sessions.

Note*:* Additional entry-level hardware optimizations are under development and will be delivered via SDK updates. These improvements require core SDK integration and cannot be implemented through application-layer code.

Summary

The GlamAR AR Try-On SDK is engineered to run efficiently across a wide range of devices, browsers, and network conditions, from entry-level smartphones to high-end flagship hardware.

To achieve smooth real-time rendering and accurate facial tracking, developers should target mid-range or higher devices, ensure stable connectivity, and optimize 3D assets for low latency and memory efficiency.

Key Takeaways:

• Hardware: Minimum 3 GB RAM and Android 10 / iOS 13 or newer. Aim for 6 GB+ RAM for sustained 30 FPS performance.
• Camera: Use 720 p or higher, with consistent front lighting and stable positioning.
• Network: Maintain ≥ 3 Mbps downlink and < 150 ms latency; leverage PixelBin CDN for fast asset delivery.
• Models: Keep file sizes ≤ 10 MB, prefer .glb/.gltf.
• Performance: Benchmark on physical devices, not emulators; validate across tiers (entry, mid, flagship).
• SDK Optimizations: Built-in caching, progressive loading, and thermal management improve runtime stability.
  Future releases will further enhance entry-level device performance.