KaiOS: what it is, system architecture and web applications

What is KaiOS?

KaiOS is a mobile operating system for feature phones developed by KaiOS Technologies. The system is based on the open source Boot to Gecko (B2G) project from Mozilla, which was originally created as a web-based replacement for Android for ultra-budget devices. The first commercial release was in 2017 on the Reliance JioPhone in India.

According to Counterpoint Research (Q2 2025), KaiOS holds 2.8% of the global mobile OS market, behind Android (72%) and iOS (27%), but ahead of other platforms. In India, KaiOS's share reaches 14% thanks to the JioPhone program. The average KaiOS device costs $20-30, making it key for emerging markets.

The key feature of KaiOS is that all applications are web applications. The developer writes code in HTML5, CSS and JavaScript, packages it in a ZIP archive with a manifest and publishes it on KaiStore. The system does not support installing native APK files — only Open Web Apps per the W3C Widget specification.

KaiOS version history

KaiOS 2.5 (2018) — first stable version on Gecko 48 kernel, shipped on JioPhone 1. KaiOS 2.5.3 (2021) — support for Google Assistant, Google Maps Go, YouTube Go. KaiOS 3.0 (2022) — Gecko 84, improved performance, WebGL 2.0, CSS Grid. KaiOS 3.1 (2024) — optimization for 256 MB RAM, new Audio Channel Web API, improved TLS 1.3 security.

KaiOS Architecture: Linux Kernel and Gecko Engine

KaiOS architecture consists of three key layers: Linux kernel (Gonk), Gecko web engine and Gaia user interface. Gonk is the hardware-dependent layer, including drivers, HAL (Hardware Abstraction Layer), RIL (Radio Interface Layer) modem stack and sensor support. The bootloader, drivers and some libraries are taken from Android Open Source Project (AOSP).

Gonk — hardware layer

Gonk provides Gecko with access to hardware: camera, Bluetooth, Wi-Fi, GPS, audio, vibration, sensors. Unlike Android, where apps are written for Dalvik/ART, in KaiOS apps access hardware through Web APIs translated by Gecko into Gonk IPC. The Radio Interface Layer (RIL) provides 4G VoLTE, SMS, USSD and SIM card management.

Gecko — web engine

Gecko in KaiOS is not just a browser engine but a full application runtime environment. All HTML5 applications run inside the Gecko Process Manager, which isolates each application in a separate process. Gecko implements the W3C Widget Packaging specification and Mozilla extensions for hardware access. The Gecko version determines which Web APIs are available to the developer.

Gaia — user interface

Gaia is the web interface of the OS itself: lock screen, home screen (launcher), notification panel, dialer, contacts, SMS client. All system applications are the same Open Web Apps. A developer can replace the standard camera or keyboard with their own app by registering the corresponding activity handler in the manifest.

// Checking KaiOS version and API availability
function checkKaiOSVersion() {
    const ua = navigator.userAgent;
    let version = 'unknown';

    if (ua.includes('KAIOS/2.5')) {
        version = '2.5';
    } else if (ua.includes('KAIOS/3')) {
        version = '3.0';
    }

    const features = {
        geolocation: 'geolocation' in navigator,
        vibration: 'vibrate' in navigator,
        mozMobileConnection: 'mozMobileConnection' in navigator,
        mozTelephony: 'mozTelephony' in navigator,
        mozSms: 'mozSms' in navigator,
        bluetooth: 'bluetooth' in navigator
    };

    return { version, features };
}

// Checking Google Apps availability (KaiOS 2.5.3+ only)
const systemInfo = checkKaiOSVersion();
console.log('KaiOS version:', systemInfo.version);
console.log('Available APIs:', JSON.stringify(systemInfo.features, null, 2));

// Using vibration with availability check
function triggerHapticFeedback() {
    if (navigator.vibrate) {
        navigator.vibrate([200, 100, 200]); // vibration, pause, vibration
    }
}

The checkKaiOSVersion function reads the User Agent to determine the KaiOS version and checks the availability of key Web APIs. In version 2.5, mozMobileConnection, mozTelephony, mozSms are available — they are absent in regular browsers and unique to KaiOS. The triggerHapticFeedback function uses the Vibration API with backward compatibility.

Creating an App for KaiOS: Structure and Manifest

A KaiOS app is a ZIP archive (format .zip, not .apk) containing HTML files, CSS, JavaScript, images and a manifest. The minimal app structure includes manifest.webapp (app description), index.html (entry point), style.css and icon.png (square icon 90×90 pixels). The manifest follows the W3C Manifest for Web Apps specification.

Manifest manifest.webapp

The manifest.webapp file is the root configuration file of a KaiOS app. Required fields: name, description (up to 140 characters), launch_path (path to index.html), icons (icon sizes 30×30, 60×60, 90×90, 120×120). The type field: 'certified' (system apps), 'privileged' (Web API access), 'web' (no special permissions). Permissions for privileged apps are specified in the permissions array.

// manifest.webapp — KaiOS application configuration
{
    "name": "Flashlight",
    "description": "Turns the camera flash on and off",
    "launch_path": "/index.html",
    "icons": {
        "30": "/icons/icon-30.png",
        "60": "/icons/icon-60.png",
        "90": "/icons/icon-90.png",
        "120": "/icons/icon-120.png"
    },
    "type": "privileged",
    "permissions": {
        "camera": {
            "description": "Required to enable the flash"
        }
    },
    "default_locale": "ru",
    "orientation": "portrait-primary",
    "fullscreen": true
}

The manifest specifies that the app is of type privileged — this grants access to the camera API through permissions. Icon sizes are strictly 30×30, 60×60, 90×90 and 120×120 pixels. The orientation field restricts portrait mode — feature phones usually don't have an accelerometer for screen rotation. fullscreen: true hides the status bar.

HTML page structure

An HTML5 page in KaiOS uses standard tags considering the limited screen (usually 240×320 pixels). The viewport meta tag is required: <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">. KaiOS does not support touch events (no touchscreen on feature phones); all navigation is via keys: ArrowUp, ArrowDown for moving, Enter for selecting, Back for returning.

// index.html — simple flashlight app for KaiOS
<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <meta name="viewport"
          content="width=device-width, initial-scale=1, maximum-scale=1">
    <title>Flashlight</title>
    <link rel="stylesheet" type="text/css" href="style.css">
</head>
<body>
    <div id="app">
        <div id="status" class="status-off">Off</div>
        <div id="hint">Press Enter to enable</div>
    </div>

    <script>
        const statusEl = document.getElementById('status');
        const hintEl = document.getElementById('hint');
        let isFlashOn = false;
        let camera = null;

        async function initCamera() {
            try {
                camera = navigator.mozCameras.getListOfCameras()[0];
                const cameraControl = await
                    navigator.mozCameras.getCamera(camera, { mode: 'picture' });
                return cameraControl;
            } catch (e) {
                showError('Camera unavailable: ' + e.message);
            }
        }

        async function toggleFlash() {
            const cam = await initCamera();
            if (!cam) return;

            isFlashOn = !isFlashOn;
            try {
                await cam.setConfiguration({
                    mode: 'picture',
                    flashMode: isFlashOn ? 'on' : 'off'
                });
                statusEl.textContent = isFlashOn ? 'On' : 'Off';
                statusEl.className = isFlashOn ? 'status-on' : 'status-off';
            } catch (e) {
                showError('Error: ' + e.message);
            }
        }

        // Handling the hardware Enter button
        document.addEventListener('keydown', function(e) {
            if (e.key === 'Enter') {
                toggleFlash();
            }
        });

        initCamera();
    </script>
</body>
</html>

The Flashlight app uses the MozCamera API to control the camera flash. The user presses the hardware Enter button — the keydown handler triggers, switching flashMode between on and off. The status is displayed in a text block with status-on/status-off classes for visual indication. MozCamera API is only available for privileged apps with camera permission in the manifest.

KaiOS Web API: Working with Phone and Hardware

KaiOS Web API is a set of JavaScript interfaces providing access to phone hardware capabilities. Most APIs are proprietary Mozilla extensions (moz-prefixed) and are not available in regular browsers. To use the API, the app must have type privileged or certified in the manifest.

Core Web APIs

MozMobileConnection — network information: operator, signal strength, network type (4G/3G/2G), IMEI, roaming status. MozTelephony — call management: dialing, accepting, ending, conference calling, call status. MozSms — sending and receiving SMS, MMS, managing SIM messages. MozContacts — reading and writing the phonebook. MozBluetooth — Bluetooth management: device discovery, pairing, file transfer. Push API — receiving push notifications from the server.

// Working with contacts and calls via KaiOS Web API
const TelephonyManager = {
    // Making a call by number
    async makeCall(phoneNumber) {
        if (!navigator.mozTelephony) {
            throw new Error('Telephony API unavailable');
        }

        const call = navigator.mozTelephony.dial(phoneNumber);
        call.onconnected = () => console.log('Call established');
        call.ondisconnected = () => console.log('Call ended');
        return call;
    },

    // Getting contact list from the phonebook
    async getContacts() {
        const cursor = navigator.mozContacts.getAll({
            sortBy: 'familyName',
            sortOrder: 'ascending'
        });

        const contacts = [];
        return new Promise((resolve, reject) => {
            cursor.onsuccess = function() {
                if (this.result) {
                    contacts.push(this.result);
                    this.continue();
                } else {
                    resolve(contacts);
                }
            };
            cursor.onerror = function() {
                reject(this.error);
            };
        });
    },

    // Sending SMS
    async sendSms(phoneNumber, message) {
        if (!navigator.mozSms) {
            throw new Error('SMS API unavailable');
        }
        const request = navigator.mozSms.send(phoneNumber, message);
        return new Promise((resolve, reject) => {
            request.onsuccess = () => resolve(request.result);
            request.onerror = () => reject(request.error);
        });
    }
};

// Usage example
TelephonyManager.getContacts()
    .then(contacts => console.log('Contacts found:', contacts.length))
    .catch(err => console.error(err));

The TelephonyManager object combines three key KaiOS APIs: mozTelephony for calls, mozContacts for the phonebook, and mozSms for messages. getAll() with a cursor is a pattern for async reading of large data volumes (typical for 1000+ contact entries). All APIs return a DOMRequest with onsuccess and onerror handlers.

Web API Limitations

KaiOS Web APIs have limitations: call and SMS APIs are only available on phones (not tablets), camera — only if a physical camera is present, Bluetooth — limited HSP/HFP profile. Push API requires Google Firebase (FCM) server support or a custom server. The geolocation API uses A-GPS or Cell ID depending on hardware support.

UI and Navigation: T9, Buttons and 240×320 Screen

KaiOS user interface is designed for T9 keyboard and hardware button control. The standard screen resolution is 240×320 pixels (QVGA) on most feature phones. The absence of a touchscreen means all navigation is implemented through keydown/keyup events: ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Enter, Back (or Escape).

Focus management

KaiOS does not support CSS :focus in the usual way — focus is managed through tabindex and JavaScript. The developer must manually track the currently selected element and move focus on key presses. Using data-index on list elements is recommended to simplify navigation. The selected element is typically highlighted with a .selected class with a contrasting CSS background-color.

// Focus navigation through list for KaiOS
class ListNavigation {
    constructor(containerSelector) {
        this.container = document.querySelector(containerSelector);
        this.items = this.container.querySelectorAll('[data-index]');
        this.currentIndex = 0;
        this.init();
    }

    init() {
        this.updateFocus();

        document.addEventListener('keydown', (e) => {
            switch (e.key) {
                case 'ArrowUp':
                    e.preventDefault();
                    this.moveFocus(-1);
                    break;
                case 'ArrowDown':
                    e.preventDefault();
                    this.moveFocus(1);
                    break;
                case 'Enter':
                    e.preventDefault();
                    this.selectItem();
                    break;
                case 'Backspace':
                case 'Escape':
                    e.preventDefault();
                    this.goBack();
                    break;
            }
        });
    }

    moveFocus(direction) {
        this.items[this.currentIndex].classList.remove('selected');
        this.currentIndex = (this.currentIndex + direction + this.items.length) % this.items.length;
        this.updateFocus();
    }

    updateFocus() {
        const el = this.items[this.currentIndex];
        el.classList.add('selected');
        el.scrollIntoView({ block: 'nearest' });
    }

    selectItem() {
        const el = this.items[this.currentIndex];
        const event = new CustomEvent('itemselected', {
            detail: { index: this.currentIndex, element: el }
        });
        this.container.dispatchEvent(event);
    }

    goBack() {
        history.back();
    }
}

// Initializing navigation for a menu list
const nav = new ListNavigation('#menu-list');
nav.container.addEventListener('itemselected', (e) => {
    console.log('Selected item:', e.detail.index);
});

The ListNavigation class implements full focus navigation for KaiOS. ArrowUp/ArrowDown move focus cyclically through elements with data-index. Enter triggers a custom itemselected event. Backspace/Escape returns to the previous screen. scrollIntoView with block: nearest automatically scrolls the screen when going out of the visible area.

CSS for KaiOS

KaiOS 2.5 supports CSS 2.1 + partially CSS3 (border-radius, box-shadow, gradients). Flexbox is partially supported in KaiOS 2.5, fully supported including CSS Grid in KaiOS 3.0. Float-based layout with fixed width is recommended for compatibility. The default font is TizenSans or Noto Sans CJK for Asian markets. Text size is 14-16px for main content, 18-20px for headings.

KaiStore and App Publishing

KaiStore is the official app store for KaiOS, pre-installed on all devices. Developers register on the KaiOS Developer Portal (developer.kaiostech.com), upload a signed ZIP package and fill in the description. Moderation checks security, stability and content policy compliance. Average review time is 3-5 business days.

App signing

KaiOS requires digital signing of the app through a KaiOS Certificate. The developer generates a key pair (private + public) using the kaios-sign utility, sends the public key to the KaiOS Developer Portal and receives a certificate. The signed .zip file contains the signature in the META-INF folder. Without a signature, the app can only be installed on dev devices.

Distribution model and monetization

KaiStore supports free apps, advertising through the KaiOS Ads SDK and in-app purchases through carrier billing (Direct Carrier Billing). KaiStore's commission is 30% of revenue. An alternative channel is pre-installation through OEM manufacturers (Jio, Nokia, Alcatel, Doro). Pre-installation requires a direct contract with the device manufacturer.

KaiStore limitations

KaiStore does not support paid apps in some countries (payment only via carrier billing). App size is limited to 10 MB for download over 2G/3G networks. An app must not use more than 50 MB of RAM. Access to the mozMobileConnection API is prohibited without explicit declaration in the manifest. Policy violations result in developer account suspension.