See it in
action.
The complete flow — from gallery to colorized result.
Home — Gallery Grid
Processing — Lottie Animation
Result — Touch to Compare
On-device AI colorization for Android.
Cloud AI means your photos leave your phone. On-device AI means they never do.
The complete flow — from gallery to colorized result.
Every image colorized 100% locally — no cloud, no API, no data leaving your phone.
Original
Colorized
Original
Colorized
Original
Colorized
Every component chosen for on-device performance. No shortcuts.
Deep colourization model predicting chrominance channels in CIE Lab colour space. Tiny FP16 variant optimized for mobile.
129 MB ONNXMicrosoft's cross-platform ML inference engine. 4-thread parallel execution on-device with ALL_OPT optimization level.
v1.19.2Image preprocessing and postprocessing. RGB→Lab conversion, channel splitting, chrominance upscaling back to original resolution.
v4.5.3100% declarative UI with Material Design 3. No XML layouts. Single-activity architecture.
Material 3Native libraries compiled for arm64-v8a, armeabi-v7a, x86, and x86_64. Runs on every Android device.
4 ABIsNo INTERNET permission. No analytics. No telemetry. The APK itself proves it — grep the manifest.
Privacy FirstFrom gallery picker to colorized output — the complete on-device ML flow.
The user selects a black & white photo from the device gallery. The app decodes it into a Bitmap for processing.
OpenCV converts the image from RGB to CIE Lab colour space. The L (luminance) channel carries all structural detail.
The DDColor-Tiny model predicts the a and b chrominance channels at 512×512 resolution using 4 parallel CPU threads.
The predicted chrominance is resized back to the original image resolution, then merged with the original L channel.
Lab is converted back to RGB. The app displays a side-by-side comparison — original on the left, colorized on the right.
// DDColorEngine.kt — 102 lines of pure inference class DDColorEngine(private val context: Context) { private val env = OrtEnvironment.getEnvironment() private val session: OrtSession init { val modelBytes = context.assets .open("ddcolor-tiny-fp16.onnx") .readBytes() val opts = OrtSession.SessionOptions().apply { setOptimizationLevel(ALL_OPT) setIntraOpNumThreads(4) setInterOpNumThreads(4) } session = env.createSession(modelBytes, opts) } fun colorize(input: Bitmap): Bitmap { // 1. RGB → Lab, extract L channel // 2. Resize to 512×512, normalize // 3. ONNX inference → predict a,b // 4. Upscale a,b to original size // 5. Merge L + a,b → RGB Bitmap } }
The entire app — UI, inference engine, image processing — fits in 6 source files. The ONNX model does the heavy lifting. The Kotlin code is the orchestration layer.
ONNX Runtime handles thread management, memory allocation, and CPU optimization. OpenCV handles colour space math. Compose handles the UI. Each tool does one thing well.
The APK has no INTERNET permission. No analytics SDK. No crash reporting. No tracking. This isn't a policy — it's architecture.
Hours of executive meetings. Spreadsheets. ROI projections. We saved you the trouble.
Chromis is open source under MIT. That means you can audit every line, fork the repo, build it yourself, and still pay exactly $0.00. Our investors hate this one weird trick.
Chromis uses DDColor-Tiny, a deep learning colourization architecture exported to ONNX format (FP16). It predicts the a and b chrominance channels in CIE Lab colour space from a grayscale input, while preserving the original luminance channel for maximum detail retention.
Cloud colourizers upload your photos to remote servers. Chromis runs the entire pipeline on your device — no network calls, no data leaving your phone. The APK doesn't even have the INTERNET permission declared. This is architectural privacy, not a privacy policy.
The DDColor model was trained and exported in ONNX format. ONNX Runtime provides cross-platform inference with aggressive graph optimizations and multi-threaded CPU execution. It's the standard format for model interoperability — train anywhere, run anywhere.
Android 8.0 (API 26) or higher. The app uses Jetpack Compose which requires API 21+, but ONNX Runtime and the native libraries target API 26+.
Processing typically takes 1-3 seconds on modern devices (Snapdragon 8-series, Tensor, Dimensity 9000+). Older devices may take 5-8 seconds. The model runs on 4 CPU threads with ONNX Runtime's ALL_OPT optimization level.
Yes. The entire project is open source under the MIT license on GitHub. The inference engine is 102 lines in DDColorEngine.kt. The Compose UI is 393 lines in MainActivity.kt. Total Kotlin: 555 lines across 6 files.
Download the APK. Explore the code. Verify the privacy claims yourself.