On-Device Image Classification: TFLite on React Native or Core ML on Rork Max — How I Chose After Building Both

On Rork Max, Core ML is not faster at inference — it has a shorter runway

Rork Max emits native Swift rather than React Native. The same classification, written with Vision and Core ML:

// ImageClassifier.swift
import CoreML
import Vision
 
final class ImageClassifier {
    private let request: VNCoreMLRequest
 
    init(model: MLModel) throws {
        let vnModel = try VNCoreMLModel(for: model)
        request = VNCoreMLRequest(model: vnModel)
        // Let Vision handle resize and normalization. Not writing it yourself is the point.
        request.imageCropAndScaleOption = .centerCrop
    }
 
    /// Takes a CGImage as-is — no Base64, no intermediate file
    func classify(_ cgImage: CGImage) throws -> [(String, Float)] {
        let handler = VNImageRequestHandler(cgImage: cgImage, options: [:])
        try handler.perform([request])
 
        guard let results = request.results as? [VNClassificationObservation] else {
            return []
        }
        return results.prefix(5).map { ($0.identifier, $0.confidence) }
    }
}

That it is fewer lines is beside the point. What matters is that VNImageRequestHandler accepts a CGImage directly.

All the resizing, normalizing, and batch-dimension juggling I hand-wrote on the React Native side is Vision's job here. The preprocessing did not disappear — it stopped crossing a process boundary.

One thing Core ML does not fix: the first run is still a different animal. Model compilation and graph setup land on that first inference, so the very first image after launch is noticeably slow. Where you choose to pay that cost is a design question, and it runs alongside what I covered in Designing On-Device Core ML So Launch Weight and Thermals Do Not Break It.

Measure the same feature both ways, or you are not comparing anything

Compare on inference time alone and you will decide wrong. What a user feels is everything between finger-on-shutter and screen-changes.

So I put identical measurement points in both. React Native first.

// utils/latencyProbe.ts
type Stage = 'capture' | 'read' | 'decode' | 'preprocess' | 'infer' | 'postprocess';
 
export class LatencyProbe {
  private marks: Array<[Stage, number]> = [];
  private t0 = 0;
 
  start() {
    this.marks = [];
    this.t0 = performance.now();
  }
 
  /// Just record when each stage finished — deltas come later
  mark(stage: Stage) {
    this.marks.push([stage, performance.now()]);
  }
 
  /// Per-stage milliseconds plus the total
  report(): { breakdown: Record<string, number>; totalMs: number } {
    const breakdown: Record<string, number> = {};
    let prev = this.t0;
 
    for (const [stage, at] of this.marks) {
      breakdown[stage] = Math.round((at - prev) * 10) / 10;
      prev = at;
    }
    return { breakdown, totalMs: Math.round((prev - this.t0) * 10) / 10 };
  }
}

Call mark at each seam:

const probe = new LatencyProbe();
probe.start();
 
const photo = await cameraRef.current.takePictureAsync({ quality: 0.5, skipProcessing: true });
probe.mark('capture');
 
const b64 = await FileSystem.readAsStringAsync(photo.uri, { encoding: FileSystem.EncodingType.Base64 });
probe.mark('read');
 
const image = decodeJpeg(new Uint8Array(tf.util.encodeString(b64, 'base64').buffer));
probe.mark('decode');
 
const input = tf.tidy(() => tf.image.resizeBilinear(image, [224, 224]).div(127.5).sub(1).expandDims(0));
probe.mark('preprocess');
 
const logits = model.predict(input) as tf.Tensor;
const probs = await logits.data();
probe.mark('infer');
 
const top5 = toTop5(probs);
probe.mark('postprocess');
 
console.log(probe.report());
// Example: { breakdown: { capture: 118.4, read: 96.2, decode: 141.7, preprocess: 28.9, infer: 19.6, postprocess: 3.1 }, totalMs: 407.9 }

On the Swift side, name the same intervals with os_signpost and Instruments gives you the identical granularity.

import os
 
let log = OSLog(subsystem: "net.rorklab.classifier", category: .pointsOfInterest)
 
os_signpost(.begin, log: log, name: "decode")
let cgImage = try decodeImage(from: data)
os_signpost(.end, log: log, name: "decode")
 
os_signpost(.begin, log: log, name: "infer")
let results = try classifier.classify(cgImage)
os_signpost(.end, log: log, name: "infer")

Reading the breakdown

Here is one run from my setup. These numbers move a lot with device, model, and image size, so please take your own on real hardware. What is worth your attention is not the absolute values but the shape — which stage dominates.

Inference was roughly 5% of the total. Everything else went into moving the image around.

Which means shrinking the model from 14MB to 3.5MB with quantization takes 20ms down to 13ms. Nobody feels that. What you feel is read and decode going away.

Seen from here, quantization changes meaning. For me it is no longer a speed tactic — it is an app-size tactic. That framing lines up with Machine Learning Optimization on Rork Max — Core ML Integration, Per-Device Tuning, Quantization and Size Reduction.

Fix things in the order that pays

Once you have the breakdown, the order writes itself. Even staying on React Native, this is how far I got.

1. Stop the Base64 round trip. Move to a JSI-backed library and hand over the ArrayBuffer. The read stage vanishes.
2. Shoot smaller. If you are downscaling to 224×224, there is no reason to capture 12MP. Beyond quality on takePictureAsync, use a smaller preset where you can.
3. Push decode native. A frame processor means never writing the file at all.
4. Hide the runway. Run one dummy inference at startup so the first-run cost lands outside any user interaction.

Number four is unglamorous and moved perceived speed more than anything else on the list. The first run costs a few hundred extra milliseconds no matter what. If it is unavoidable, pay it somewhere nobody is looking.

Do all four and the hesitation largely disappears on React Native. Which is the real point: only requirements that survive all four are a reason to consider Rork Max.

$200/month is not justified by image classification alone

Back to money. Regular Rork is free to start, $25/month paid. Rork Max is $200/month. That is $175/month, $2,100 a year.

Honestly, if all you want is one image classifier, I found that gap hard to justify. The four fixes above bring React Native comfortably into usable territory.

What changes the answer is question three — what else on the device will you want to touch — coming back "something."

My wallpaper app had to ship to Android from the same code, so I stayed on React Native. Had it been Apple-only with classification results going into a widget, I would have taken Rork Max without hesitating.

Treating these as a premium tier and a basic tier leads you astray. The generated foundation is genuinely different — Swift versus React Native — so the criterion is not price. It is how far into Apple's own capabilities you intend to go.

If you do end up owning a Core ML model yourself, the conversion and operational side is laid out in Rork and Core ML: Custom Model Development and On-Device AI.

The decision, in one line

Count the device features you will want six months from now. Zero means React Native. One or more means Rork Max.

Raw classification speed contributed almost nothing to that call, because inference was 5% of the timeline. The time I spent stalled, trying to choose on speed, was the genuinely wasted part.

Measure the breakdown first — your device, your image sizes. The moment the dominant stage shows itself, the path narrows to one on its own. Mine turned out to be read and decode, and the answer was never "switch engines." It was "stop turning the image into a string."

The probe is above. Thanks for reading.