What are Factory Apps:

In the context of this document, factory applications refer to the core set of applications that are pre-integrated into an RDK 8 image and work together to deliver the Reference User Interface (UI) shown on device boot.

The factory apps include:

• Reference UI
• WebKit browser runtime
• Base bolt package

Together, these components form the default user experience that is displayed immediately after an RDK 8 image boots.

How to get Factory Applications

At the time of writing this document, work is still in progress to open up and make the BOLT applications available to the wider RDK community. Due to legal constraints, RDK-M is currently unable to share or distribute pre-built binaries, including BOLT packages, to the community.

**This limitation is temporary and will be revisited once the legal situation around sharing BOLT applications is clarified.**

How are Factory Apps handled in RDK8

In RDK 8, factory applications are treated as external, deploy‑time components rather than being tightly coupled to the core RDK stack.

1. What Changed?:
   1. RDK7 Architecture

• • • The application layer built the Reference UI packages during image build time.
    • The middleware layer built components such as the WPE WebKit browser and the Cobalt runtime (YouTube).
    • All these components (RefUI, WPE WebKit) were open-source and compiled from source during the build.
    • As a result, community-built images contained all the necessary components for the Factory Reference UI to boot and run at runtime.

1. 1. RDK8 Architecture

RDK8 introduced major architectural changes:

• • • The application layer has been removed.
    • The WPE WebKit browser, Cobalt, and other native applications previously built in the middleware are no longer built as part of the image.
    • These components are now delivered as BOLT packages.
    • BOLT packages are built separately and downloaded at runtime rather than being included in the image itself.

This means that native browser, runtimes, and applications are no longer embedded during the image build.
However, when the device boots for the first time, the Factory App / Reference UI must already be present on the platform so the user has a default, pre‑installed application available at startup.

Factory App Deployment Options

Factory applications can be deployed to the device using one of the following approaches:

• Pre-installed during image build
  Factory apps can be integrated directly into the final RDK 8 image during the Image Assembler stage.

• Sideloaded on first boot
  Factory apps can be sideloaded onto the device during the initial boot-up process, after which the device is restarted to apply the changes.

Both approaches result in the factory applications being available for delivering the Reference UI experience.

Option 1: Pre-installed during image build

To pre-install factory applications and make them part of the final RDK 8 image, the BOLT-based factory apps must be built, signed, and integrated during the image build process.

The overall flow is outlined below.

Step 1: Build Factory App BOLT Applications Locally

All factory applications must be built locally by the integrator.

BOLT Application Build Steps

Build the following components:

• • • Base application
      → Build instructions: Build Base Bolt Package

    • WPE (WebKit runtime)
      → Build instructions: Build Wpe Bolt Package

    • Reference UI (RefUI)
      → Build instructions: Build Refui Bolt Package 

Each of these components is packaged as a BOLT application.

Step 2: Sign the BOLT Applications

• • All generated BOLT application packages must be signed
  • Signing is mandatory for the applications to be accepted and installed as factory apps
  • Refer: https://wiki.rdkcentral.com/x/F5OmGg

Step 3: Create the Factory Apps JSON File

Create a factory apps JSON file that describes the applications to be pre-installed.

The JSON file must include:

• • • File system location of each BOLT package

    • Corresponding SHA-256 checksum for integrity verification

    • JSON template: <link here>

Step 4: Update local.conf

Update the path to the factory apps JSON file in your local build configuration:

• • • Set the FACTORY_APPS_JSON_FILE variable in local.conf to point to the locally created JSON file

Step 5: Run the Image Assembler Build

• • Start the Image Assembler build process
  • The factory applications will be packaged into the final RDK 8 image as part of the build
  • On boot, the device will launch the pre-installed factory apps and display the Reference UI

Option 2: Sideloaded on first boot

Factory applications can also be sideloaded onto the device after the initial boot instead of being pre-installed as part of the image build.

In this approach, once the device completes its first boot and console access is available, the required BOLT applications can be copied to the device and installed manually.

Supported Sideloading Methods

There are two supported ways to install factory apps after the initial boot:

1. 1. Preinstall Manager–based installation
   2. Package Manager installation using curl

High-Level Steps

1. 1. Boot the device with the RDK 8 image
   2. Gain console access after the initial boot completes
   3. Copy the required BOLT application packages onto the device
   4. Install the applications using one of the methods described below
   5. Reboot the device to activate the factory apps (if applicable)

Method 1: Installation Using Preinstall Manager

This method leverages the preinstall manager, which installs applications automatically during the next boot.
Steps:

• • • Copy the BOLT application packages to the following directory on the device in the PREINSTALL PATH
      

      Preinstall Path in the platform changes from platform to platform. 

    • Reboot the device

On the next boot:

• • • The preinstall manager detects the packages
    • Factory applications are installed automatically
    • The Reference UI becomes available after installation

Method 2: Installation Using Package Manager (curl)

This method installs factory apps directly using the package manager APIs.

Steps

• • • Run the appropriate package manager curl command to install the BOLT application
    • Reboot the device to ensure the applications are launched correctly

Building Bolt Application

This section describes the steps required to build BOLT applications used as factory apps in RDK 8.

Building Base Bolt Package:

Repo: https://github.com/rdkcentral/meta-bolt-distro

git clone https://github.com/rdkcentral/meta-bolt-distro.git
cd meta-bolt-distro
git checkout <branch/revision/tag>
source setup-environment

# Create bolt-tools and hash it
bitbake bolt-env && hash bolt

# build base bolt package
bolt make base

Building Wpe Bolt Package:

Repo: https://github.com/rdkcentral/meta-bolt-wpe

git clone https://github.com/rdkcentral/meta-bolt-wpe.git
cd meta-bolt-wpe
git checkout <branch/revision/tag>
source setup-environment

# Create bolt-tools and hash it
bitbake bolt-env && hash bolt

#build wpe bolt package
bolt make wpe

Building Refui Bolt Package:

Repo: https://github.com/rdkcentral/rdke-refui

Steps: https://github.com/rdkcentral/rdke-refui/tree/develop/bolt

git clone https://github.com/rdkcentral/rdke-refui.git
cd rdke-refui
git checkout <branch/revision/tag>

cd develop/bolt/
./pack.sh
cd packages
bolt pack ../package-configs/com.rdkcentral.refui.json refui.tgz
# You should have com.rdkcentral.refui+0.0.1.bolt created in the packages directory.