Multimodal AI on React Native: On-Device Vision Language Models (2026)

Q: What is multimodal AI on React Native and why is it different from cloud AI?

Multimodal AI on React Native means running vision and language models on the device rather than calling cloud APIs — through CoreML, ONNX Runtime, MLC LLM, or llama.cpp invoked from native modules and surfaced to JavaScript through TurboModules built on JSI. It is a fundamentally different engineering problem from cloud AI: the constraints are memory (a 4GB Android cannot load a 4GB model), thermal (an iPhone 15 Pro throttles after 90 seconds of sustained inference), battery (a vision pipeline at 20fps burns 800 to 1100 mAh per hour), latency budgets that allow no network round-trip (vision at frame rate needs sub-50ms inference), and bundle size (App Store rejects multi-gigabyte binaries). Cloud AI scales by paying for more compute; on-device AI scales by picking the right quantised model for the right device tier and engineering every layer for thermal and battery efficiency. The skills overlap less than they appear, and React Native adds JSI bridge and TurboModule architecture as additional dimensions.

Q: Which on-device model format should I use — CoreML, ONNX, MLC, or llama.cpp?

CoreML for vision tasks on iOS — Neural Engine acceleration is unmatched on Apple silicon, sub-10ms per frame for a quantised MobileNetV3 on A17. ONNX Runtime Mobile for cross-platform pragmatism: one model, one inference path, runs on iOS via CoreML EP, Android via NNAPI EP, and CPU fallback everywhere — performance within 15 to 25 per cent of native paths, acceptable for the engineering simplicity. MLC LLM for cross-platform language models: compiles to Metal on iOS and Vulkan on Android, runs Phi-3 Mini 3.8B INT4 at 18 to 22 tokens per second on iPhone 15 Pro and 12 to 16 on Pixel 8 from a single source. llama.cpp for iOS-first language models with maximum control: small library (under 5MB), GGUF format, excellent Metal acceleration (30 to 40 t/s for Llama 3.2 1B INT4 on A17), best community traction. Quantisation matters as much as runtime — INT4 (Q4_K_M for GGUF) is the right balance, AWQ or GPTQ produce better INT4 quality than naive quantisation.

Q: What does the JSI bridge do and why is it essential for on-device inference?

The legacy React Native bridge serialised every native call through JSON, adding 8 to 15 milliseconds per call — which would have killed vision-at-frame-rate (a 50ms total budget cannot afford 30 per cent overhead per frame). JSI gives JavaScript direct access to native objects via C++ HostObjects: JS holds a reference to a C++ object, calls methods on it, receives results without any encoding step. For inference this means camera frames pass by reference (zero copy), model invocation is a direct C++ method call, results return as HostObjects read lazily — per-call overhead drops from 8 to 15ms to under 1ms. TurboModules formalise JSI native modules with type-safe specs: declare a TypeScript interface, codegen produces native C++ headers, implementation lives in Objective-C++ on iOS and JNI on Android. The result is type-safe access from JavaScript with sub-millisecond bridge overhead. Without JSI and TurboModules, on-device multimodal AI on React Native would not be a viable architecture.

Q: How do I structure the vision pipeline from camera frame to label?

Vision Camera library exposes camera frames through worklets running on a separate thread so inference never blocks JS. Each frame is a CVPixelBuffer (iOS) or ImageProxy (Android) shared by reference — the worklet calls TurboModule.predictFromCamera(frameId) and the native module reads the buffer directly. Preprocessing happens entirely in native code: YUV planes read directly from the pixel buffer, conversion to RGB via vImage on iOS or RenderScript Toolkit on Android, resize with Lanczos in the same pass, write straight to model input tensor — total preprocessing 2 to 4ms instead of 15 to 25ms in JavaScript. The model instance is loaded at app startup and reused across every inference (loading takes 200 to 800ms; reloading per frame is a critical bug). Postprocessing returns minimal data — top-k labels with confidences, not the full distribution. Realistic per-frame budget for 50ms target: capture 3ms, preprocessing 3ms, inference 8 to 15ms (quantised MobileNetV3 on ANE), postprocessing 1ms, JSI marshalling under 1ms — total 15 to 23ms with headroom for rendering.

Q: How does the language pipeline work with llama.cpp and what latencies should I expect?

llama.cpp is built as a static library linked into the iOS framework or Android AAR; the TurboModule exposes loadModel, generate (streaming), and unloadModel. Streaming is the critical UX feature — token-by-token output makes 30 t/s feel responsive, while waiting for the full completion at 30 t/s for a 200-token response feels like a 7-second hang. The streaming callback marshals each token through JSI as a string. KV cache is configurable; 2048-token context is the chat sweet spot. Realistic latencies on real devices: iPhone 15 Pro running Llama 3.2 1B INT4 — prefill 80ms for 100-token prompt, decode 35 to 40 t/s for first 60 seconds, throttles to 15 to 18 t/s after. iPhone 14 — prefill 140ms, decode 18 to 22 t/s, throttles to 8 to 10 t/s. Pixel 8 via MLC LLM — prefill 200ms, decode 12 to 16 t/s, throttles to 6 to 8 t/s. Galaxy S24 — prefill 130ms, decode 22 to 28 t/s, throttles to 10 to 14 t/s. Mid-range Snapdragon 7 Gen 3 — borderline 5 to 8 t/s cold, drops below 4 throttled, not really acceptable.

Q: How do I decide between local inference and cloud fallback per request?

The decision is per-request, not per-feature — a chat assistant does not need to be all-local or all-cloud, it needs to pick the right path for each prompt. Short factual questions answered well by a 1B model go local (no network round-trip, no token cost). Long-form generation, complex reasoning, prompts exceeding the local context window, or low-confidence local responses go cloud (better quality, slower, costs money). The router is a heuristic ladder, not another LLM — the temptation to route with a model is almost always wrong because the router runs before every inference. Heuristics that work: prompt length over 500 tokens go cloud, code-generation triggers go cloud, user has cloud-only mode enabled go cloud, otherwise local. Confidence-based escalation handles local failures: score the response (perplexity, top-token probability, repetition rate); if low confidence, escalate to cloud and replace the response. Network conditions enter the decision too — on a weak connection cloud may be 3 to 8 seconds and unreliable, making local the better path for that moment.

Q: What battery and thermal numbers should I expect for on-device multimodal AI?

Vision pipeline at 20fps continuous: 800 to 1100 mAh per hour — about 40 per cent of a 3000 mAh battery in one hour of use. Language model in chat mode (5 to 15 invocations per minute, average 80-token response): 200 to 350 mAh per hour on iPhone 15 Pro, 350 to 400 on Pixel 8 — a user spending 30 minutes in a session pays 5 to 7 per cent battery. Multimodal continuous use can flatten a phone in two hours. Thermal: iPhone 15 Pro sustains Bedrock-class inference for around 90 seconds before throttling the Neural Engine to 60 per cent of peak; Snapdragon 8 Gen 3 throttles its Hexagon NPU at around 60 seconds. Once thermally limited, inference drops to roughly one-third of peak and stays there until cooldown (3 to 5 minutes idle). Detect thermal state via NSProcessInfo.thermalState (iOS) or PowerManager.getCurrentThermalStatus (Android) and back off — drop framerate, suspend model, switch to smaller model, or fall back to cloud. Inform the user with a battery-saver indicator rather than degrading silently.

Q: How do I ship 750MB+ model files without failing App Store review?

Bundling model weights in the app binary fails App Store review — a 750MB Llama 1B INT4 plus a 100MB vision model plus runtime libraries can push the iOS IPA over the 4GB cellular install limit. Production apps download model weights post-install: first-launch experience is the user opting in to model download (with size and Wi-Fi recommendation), then progressive download with progress UI, then activation. Downloaded model files live in the app's Documents or custom directory, survive app updates, can be deleted independently when the user wants storage back. The TurboModule loads the model from this path at runtime — the app bundle ships only the runtime library, not the weights. This separation enables multiple model versions on the device simultaneously (current production, A/B variant). Every model has a version identifier, SHA-256 hash, and signed manifest from your server; the app verifies hash and refuses to load corrupted files. Update cadence decouples from app releases — a new model version rolls out to a percentage of users without App Store submission, and rolling back a bad model is a server-side change that takes effect on the next user session.

Q: What testing discipline catches multimodal AI regressions before production?

Four test categories on every release. Quality regression testing on a fixed eval set: a versioned dataset of inputs (images for vision, prompts for language) with expected outputs or quality metrics; metrics include accuracy or BLEU or perplexity; regression on any metric beyond a threshold blocks promotion. Latency regression testing on real devices: a device test farm runs the synthetic workload on every release; latencies are tracked over time; regressions of more than 10 per cent on any device class block the release; tests cover cold-start (first inference after model load), warm steady-state, and post-throttle. Memory and crash testing under pressure: simulate low-memory conditions and verify the model loads without crashing and unloads cleanly when the OS asks for memory; iOS jetsam events and Android low-memory kills should be metrics tracked per release. Thermal soak tests on the worst supported device: run the inference workload continuously for a full hour on the lowest-tier supported device; record temperature, throttling events, battery drain. Simulator measurements are useless for power and thermal — the simulator runs on a Mac with effectively unlimited cooling and no battery.

Q: What is the strategic insight for architects building multimodal AI on React Native?

The model is a commodity in 2026; the integration is the product. Eighteen years of building mobile applications teaches that the engineering decisions invisible in the architecture diagram are the ones that determine whether the product ships. Model quality is visible; thermal management is invisible until the phone is hot in the user's hand. Inference speed is visible; the JSI bridge architecture that enabled it is invisible. Bundle size shows up in the App Store; the OTA model update strategy that kept it under control is invisible. Architects who succeed at multimodal AI on React Native treat the invisible engineering as the product — a TurboModule structure that lets you swap inference backends without touching the JS layer, a tiered model strategy that ships the right model to the right device, an OTA path that decouples model evolution from App Store cadence, a measurement regime that makes thermal and battery first-class metrics. Get the integration right and the model can be replaced quarterly as the field evolves; get the integration wrong and the model is the smallest of your problems. Teams that get this ship features that feel magical — instant, always available, private, free at the margin.