Case 1: Shared Bicycle Service

The popularization of MiniApps helps make the shared bike a seamless service instead of a cumbersome application.

• A user chooses any of the MiniApp platforms on their mobile device, which is usually a super app that they already logged in to;
• A user scans the QR-code label attached to a shared bicycle within the super app;
• The hosted app will automatically navigate to the shared bicycle MiniApp and unlocks the bicycle instantly;
• Upon arrival, the user locks the bike on the MiniApp;
• The transaction completes, and a message of the payment detail is sent to the user.

For users, MiniApps can bring convenience from a few perspectives:

Case 2: AR Zoo

MiniApp developers can simply use HTML/CSS/JavaScript as the programming language, but MiniApp is more flexible, so it excels at quickly developing complex features in daily work.

This MiniApp tries to build an AR zoo with AI technologies to recognize the animals. Developers can easily do that by adding a few components or APIs that provide access to the native capabilities or advanced features (e.g., image recognition, AR 3D animal-model rendering, a speech API for speech synthesis, and AR navigation provided by the map SDK).

MiniApps can be discovered by search engines, MiniApp stores in the hosted app, or QR codes.

For the developers, the incentive to work on MiniApps is very obvious.

Case 3: MiniApp for Vehicle

One of the goals of MiniApp is to connect information and services across different platforms, so it's ideal for IoT applications such as Smart Automotive, voice-control speakers, and Smart TV.

Nowadays, it's possible to convert some MiniApps to adapt the vehicle screen and system. Also, a few MiniApp vendors have built a MiniApp platform specially designed for the vehicle system to help distribute or upgrade applications to various car models. This brings millions of Web developers to the automotive application ecosystem.

These automotive MiniApps can support many user scenarios, including gas filling, car washing, electronic toll collection, insurance, restaurant reservation, or entertainment. For example, when the system detects the remaining fuel is less than 20%, it can recommend a gas pumping MiniApp to the owner. The user can get the information of the nearest gas station and head there to complete the gas pumping, including the payment within MiniApp, "refueling without getting off the vehicle".

Case 4: MiniApp for IoT

IoT device is becoming another carrier running MiniApps. MiniApp for IoT intends to enable interoperability across multiple IoT device platforms and operating systems. Rather than dealing with the difference across the multiple IoT device platforms and IoT operating systems, by introducing MiniApps for IoT, developers only need to focus on the application development on IoT devices.

One example is the HVAC (heating, ventilating, and air-conditioning) application switch panel, which has a screen and several physical buttons. In this case, by introducing MiniApp for IoT, the switch panel’s screen UI can be designed and developed using Web technologies to display the HVAC information. For example, the target temperature value inputted by the physical and the measured real-time temperature value can be displayed.

Another example is smart speakers with a touch screen. In this case, by introducing MiniApp for IoT, the smart speaker’s touch screen UI can be designed and developed using Web technologies to play music and video, control the IoT devices at home, and shop online.

Case 5: MiniApp for TV

Unlike MiniApps running on mobile phones, where user interaction depends on the touch screen, the user interaction of MiniApps running on TV switches to the TV remote panel keyboard plus TV screen focus.

With MiniApp for TV, users can buy merchandise on TV through E-commerce MiniApp.

And also, users can play games on TV through Gaming MiniApps.

Separate the view layer from the logic layer

In a MiniApp, the view layer is usually separated from the logic layer.

The view layer is responsible for rendering MiniApp pages, including Web components and native components display, which can be considered hybrid rendering. For example, some Web components might not be supported by the WebView or have performance limitations, so MiniApp also relies on native components such as map, video, etc.

The logic layer is implemented with JavaScript Workers. A worker is responsible for MiniApp’s event processing, API calls, and lifecycle management.

Extended native capabilities usually come from the hosting native app or OS, including payment, file processing, image scanning, phone calls, etc. These features are called through specific APIs. When a MiniApp calls a native API, it transfers the API call to extended native capabilities for further processing via a JavaScript Bridge. It obtains the result from the extended native capabilities via the JavaScript Bridge.

The worker establishes a connection for each Render, transferring the need-to-be-rendered data to the Render for further processing.

If an event is triggered by a component in a MiniApp page, this page’s Render will send the event to the worker for further processing. At the same time, the Render will wait for the data sent from the worker to re-render the MiniApp page.

The rendering can be considered stateless, and all the states will be stored in the worker.

The benefits of separating the view layer and the logic layer include:

• Very handy for data sharing and interaction among multiple MiniApp pages.
• Having the same context within the lifecycle of MiniApp can provide a similar coding experience for those developers coming from native app development background.
• Separation and parallel implementation of render and JavaScript worker can prevent the situation where a JavaScript execution impacts or slows down the page rendering, which can help enhance the rendering performance.

MiniApp Pages and Components

A MiniApp is a bundle of one or more pages in a container. The MiniApp components, composed of structural, styling, and logic resources, are the building blocks for creating MiniApp pages. These scoped components are reusable. They may also share other common internal resources such as media files, stylesheets, scripts, or data, as illustrated in .

MiniApps usually have configuration files (or manifests) that contain metadata for user agents to configure and manage the execution environment of the app.

Rich APIs and Components

As mentioned in , the MiniApp components help developers build pages with fancy UI. The MiniApp platforms usually include essential components like `<view>`, `<form>`, and `<button>`, but also high-level components like `<map>`.

MiniApp vendors also offer many APIs for developers to access both Web services and the native capabilities, including basic interfaces such as UI display APIs, image processing API, and those advanced ones like user account API, map API, and payment API.

APIs usually work together with components. When a user clicks a specific component on a MiniApp page, it will call the related API to complete the user’s interaction and refresh the current MiniApp page if needed.

MiniApp Constructor

In order to obtain similar user experiences as in native apps, MiniApp resources are usually packaged together. After downloading and installing a MiniApp package, all the static resources (i.e., page templates, CSS, JavaScript files, and other documents) required by the MiniApp persist on the users' devices. These resources are always available without any redundant downloads until the next update.

A MiniApp package is a compressed ZIP archive, including:

• A configuration document located in the root directory of the package. The config file should include:
  • the general description of the entire MiniApp; and
  • the description of the pages, including their corresponding paths and configuration, for page setup and opening.
• One app-level logic file containing a script to deal with app-level lifecycle callbacks.
• One or several files, containing templates code for page structure, CSS stylesheets for page styling, and JavaScript codes for the page logic.
• Digital signature support for integrity validation.

For the purpose of locating a specific MiniApp while searching and executing, a MiniApp must have a package name or an identifier on the platform. An icon is also required for user recognition.

MiniApp Widgets

In addition to MiniApp pages, MiniApps can also be displayed as information fragments or MiniApp widgets. In this form, developers can put their service and/or content to various host scenarios, called host environments (e.g., assistants, global search of the device, etc.). This feature connects the services and content of the MiniApp with the concrete scenario, providing users with more convenience.

For example, when a user purchases a train ticket for a trip, the MiniApp widget on the smart assistant shows the train's latest status immediately. The user can click on this widget and jump to a full-screen MiniApp page for more detailed information.

Like in a MiniApp page, a widget is also described by URI scheme. The host environment specifies the MiniApp package and the corresponding widget to be loaded through its URI path and passes data to the widget through URI query parameters. After the widget is loaded, it is displayed and rendered in the host environment. Data from the host and widget, as well as data from different widgets are isolated to ensure security and independence.

In many scenarios, a widget can open a MiniApp page for more complicated operations. In such cases, widgets often need to share data with their corresponding MiniApp (e.g., maintain a consistent login status). Therefore, the data of the widget and the MiniApp can be accessed from each side. In other words, the MiniApp widget and the page have same data access rights.

One of the goals of the widget is to let the user forget the traditional app concept and truly meet the user's needs in the form of service. So, in addition to all app invocation paths, widgets can also be triggered by different methods in different scenarios, such as text keywords, voice analysis, picture recognition, scan code, and event intent.

Note: Widget is implemented by Quick App in China market.

Single-Instance, Multi-Entries

There are multiple entrances to discover, open and access MiniApps. Unlike the Web content in multi WebViews, only one instance will be created for the same MiniApp, so MiniApp keeps its status and data in a consistent manner globally. For example, after one user opens and logs in to a MiniApp through the entrance of a QR code for the first time, the user will remain logged in the next time when the user returns from another entry like a MiniApp store.

The entries for MiniApps include, but are not limited to:

• MiniApp marketplace
• Search engine
• Smart assistant
• QR code
• SMS/text
• Physical object (with AI)
• Browser
• Calendar items
• Voice message (with AI)

Performance and User Experience

MiniApps try to improve their performance and user experience with a few mechanisms that have been proved to be effective through practice.

Packaging

With MiniApp's constructor, a user only needs to download the package when the MiniApp is first opened, and then the static resources (e.g, pages, scripts, and CSS) in the MiniApp needn't be downloaded again, so that the loading and jumping of the following pages are more efficient. This feature improves user experience and saves network traffic.

Meanwhile, the MiniApp has a pre-download mechanism, which can download the MiniApp packages in advance, or pre-downloads separately for the first page, and perform streaming decompression in parallel during download to minimize the time-consuming of MiniApp startup phase and balance the loss of the first page performance when opening first time.

Multiple Rendering Views

The MiniApp uses native page stack management between render views, and the page switching is driven by native code. Therefore, the gesture operation in the page, the switching between pages can achieve the exact same smooth experience as native.

Because of the isolation of the view and logic layers, the view layer can be rendered independently. Without being blocked by JavaScript logic code, the rendering speed of the page can be greatly improved.

Pre-built and reuse of runtime environments

MiniApp's runtime environment is usually pre-built before launching a mini-app, thus reducing the time to launch a MiniApp. Pre-built content includes rendering views, static resources, developer-defined prefetch requests, and MiniApps runtime container. After a MiniApp is activated, it will take over the pre-built rendering view, and then we will continue to pre-build a new render view into the cache pool for the next one. There is a limit on render view quantity. When any render view gets closed or the quantity limit is exceeded, the oldest opened render view will be destroyed. When the MiniApp application exits, the runtime is destroyed, and the application environment and resources can be reused.

Pre-defined Component and API

MiniApp platforms provide very rich components and APIs. These components and APIs are usually well designed to meet the developers' performance requirements.

JavaScript framework presets and hot reload

MiniApp's runtime environment contains two major parts, the basic capabilities provided by native code and a framework, including developer API and some components implemented by JavaScript. The JavaScript framework is built in native apps and will be loaded into the MiniApp runtime environment in advance before executing the MiniApp. The JavaScript framework can be hot reloaded (reload during usage), which brings lots of possibilities to improve performance.

Login

The MiniApp platforms provide a variety of ways for a user to log in to the MiniApp. If the user has already logged in to the platform with identity authentication, the login information of the platform can be shared with MiniApp, quickly realizing the interoperability of MiniApp’s own account system and the platform account system, which makes the access process of the MiniApp more smooth.

For example, the traditional login process with SMS verification is more time-consuming; users need to manually enter their cell phone number first and then enter the verification code after receiving the SMS to log in. The advantage of MiniApp is that developers can use the components / APIs provided by the platform to obtain users' cell phone numbers securely and conveniently, prompting the user to authorize a one-click login process with their cell phone numbers, which makes the entire process simple for the user and reduces the cost of obtaining user information for developers.

Subpackaging

MiniApp subpackaging is a build mechanism for improving the MiniApp package development process. It helps developers divide different business modules into different subpackages.

For developers: a MiniApp has the main package by default; it contains the startup page files and public resources. Subpackage is a building type that flexibly divides the developer's business modules. Users can open special pages after loading different sub-packages on demand.

For users: when the user starts the MiniApp, the main package will be downloaded by default, and the page in the main package will be launched. If the user needs to open a page in the subpackage, the MiniApp Runtime will start to download and load the subpackage and start the subpackage page.

Through such a subpackage building mechanism is better to decouple and collaborate when multiple teams develop together. When users use the MiniApps, the subpackaging mechanism can improve the loading speed of the MiniApp homepage, load subpackages on demand, and optimize the user experience.

Add-ons

In a MiniApp, an add-on/extension is an encapsulated module that adds a specific feature to an existing MiniApp, and it could be a component, a JavaScript module, or a page. The add-on/extension can only be executed in a MiniApp instead of running separately. Developers can develop an add-on/extension just like a MiniApp, and upload it to the MiniApp platform for other MiniApps to reuse.

MiniApp supports add-on/extensions to:

• reduce development costs by code reuse and help developers easily add new features
• update functionality automatically without the awareness of developers
• reduce the package size of MiniApps by not loading unused functions

The add-on/extension mechanism lowers the barriers to developing MiniApps and brings more developers to the MiniApp ecosystem.

Hybrid Rendering

MiniApp is a hybrid solution of Web rendering and native rendering. It'd be great if there is a good way to combine the rendering results from the Web and the native.

Proposal: MiniApp needs a standardized API to help integrate the native rendering result into the Web rendering outcome.

Transition Animation

MiniApp would like to provide transition animation during page switching so that users can have a similar experience as when they are using a native app, but it's almost impossible to do that now.

Proposal: MiniApp needs an API to add transition animations during MiniApp page switching.

Standardise the Package Constructor of MiniApp

MiniApp can form a package and parsing convention for multiple MiniApp hosting platforms through a standardized distribution format. Currently, each MiniApp hosting platform provides different development tools (different packaging methods), and the MiniApp is parsed differently in different MiniApp hosting environments.

Proposal: The MiniApp is actually a packaged (compressed) collection of files during the distribution process. We can describe a MiniApp (.ma) with a uniform file suffix and specify how to create the .ma file and how to parse the .ma file.

Standardise the navigation to a MiniApp page

For a hot page in a MiniApp, it may be referenced in another MiniApp, and it is expected to be accurately evoked when the user visits.

Proposal: Define a standardized protocol (URI scheme) to access MiniApp.

MiniApp Widgets

Like Android widgets or Apple dashboard, users can directly get information and/or finish their task with a MiniApp widget without opening any Web or app pages. A MiniApp widget can be displayed in an environment outside of Web browsers, such as on desktops or dashboards.

Proposal:

• A MiniApp widget can be displayed within a host environment, either a WebView or a native app page. The host environment loads a widget with its corresponding URI path, which describes a package and widget page.
• A MiniApp widget can access local data or data from a server. Meanwhile, a MiniApp widget can communicate with MiniApp in the same package.
• A MiniApp widget should be interactive, meaning that it should be responsive to any user behaviors/interactions. A MiniApp widget should have the ability to open a Web or app page.

Define an event for "time to interactive" in MiniApp

MiniApp needs to know when the MiniApp page Time to Interactive (TTI) has been completed.

Proposal: A standardized event to notify that the MiniApp page Time to Interactive has been completed.

3D Model Element

3D models have become more and more popular thanks to their rich details. Combined with AR, they will provide a better user experience than 2D. The business cases might include online shopping, advertisement, education, etc. However, the current Web lacks a standard and convenient way to deal with 3D models. In this document, we propose to define an HTML tag to directly handle 3D models, similar to the way we handle audio, video, and image with corresponding HTML tags:

• 360 view

  Users can view a 3D model from different angles via gestures. And the 3D model can be zoomed in/out as well. It can be viewed on full screen or embedded in an webpage, shown together w/ other HTML contents.

• View with AR

  Users can place the 3D model in the real world with the camera. Users can specify different locations to place the model.

Proposal: A <xmodel> element to specify a 3D model on the Web and power interactive 3D contents with AR.

Face Tracking

Face tracking can be used in many 3D scenarios.

Face Effects in Live Video

Add effects on the face in live video. These effects include a full-screen filter, face reshape and makeup, 2D sticker, 3D headdress, etc. Most of these effects depend heavily on real-time face tracking from a video source.

Gaming

Game developers can design game strategies based on the tracked face, like triggering a specific game logic when the eye blinks or checking if the dropping fruit is in the opened mouth.

Virtual Makeup

Let users try lipsticks, eye shadows, glasses, and hats on the product page to help them decide.

Proposal: A Face Tracking API use a video element as input and updates face tracking output every frame, which includes:

• Bounding box of each face
• 4x4 pose matrix of each face
• Normalized (x, y) landmarks points
• Face geometry data including vertices, normals, texture coordinates

Hand gestures tracking and recognition

Hand gestures can be used in video effects and AR/VR game scenarios to make apps more impressive and interactive.

Proposal: A high-level API to track hand movement and get the hands outline.

Low level AR APIs based on ARCore and ARKit

There are a few AR APIs in MiniApps we would migrate to the Web, as they help provide a better AR experience in gaming, 3D model preview, and interactive ads.

Proposal: Provide low-level AR APIs based on ARCore and ARKit, which include:

Camera view matrix for world tracking

Provide the 4x4 view matrix of the spatial location and orientation of the mobile phone, which can be used to update the camera matrix in their 3D virtual world in real-time by developers. Thereby the position of the real world can be correlated with the position of the object in the virtual world.

Plane detection and tracking

Detect planes in the real world and track these planes in real-time. Provide the 4x4 transform matrix, which represents the center position and orientation of each plane. It can be used for placing 3D virtual objects on the ground/desktop.

Anchor

Anchor defines a fixed position and orientation in the real-world. Developers can create an anchor from a 4x4 transform matrix, which can be got by hit test. This matrix will be updated each frame to ensure that the virtual object corresponding to the matrix can be fixed in one position and direction in the real scene.

Hit test

Get a 4x4 transform matrix representing a position and orientation in the real world space corresponding to the screen position to implement functions such as clicking and placing virtual objects.