# Deploy LiteRT as a Python application

The following figure shows the steps involved in creating
an application using C++ APIs to run a LiteRT model:

![../_images/litert-create-app-workflow.png](data:image/png;base64,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)

**Workflow to create an application and run a LiteRT model**

## Load a LiteRT model

A LiteRT model is a FlatBuffers file that has information on model
operators and any associated weights and biases.

The contents of the FlatBuffers file include the following:

- Tensors (input and outputs of each operation)
- Buffers (weights and biases)
- Operations that create an execution graph

The LiteRT framework provides APIs to do the following:

- Load a LiteRT model file
- Unpack the content of the FlatBuffers file into memory

Use the following APIs to load a LiteRT model for inference:

include <cstdio>
    include <iostream>
    include "tensorflow/lite/interpreter.h"
    include "tensorflow/lite/kernels/register.h"
    include "tensorflow/lite/model.h"
    include "tensorflow/lite/optional_debug_tools.h"
    
    std::unique_ptr<tflite::FlatBufferModel> model;
    
    model = tflite::FlatBufferModel::BuildFromFile(model_name.c_str());
    
    if (!model) {
       std::cerr << "Failed to mmap model " << model_name << std::endl; exit(-1);
    }
    Copy to clipboard

## Create a LiteRT interpreter

Using the TensorFlow C/C++ APIs, you can build an interpreter to run
the model. The interpreter interface helps you to do the following:

- Configure model execution on a chosen delegate.
- Assign the memory needed for forward propagation.

The following example code demonstrates how you can create an
interpreter. You can configure the interpreter instance to use a
specific delegate and perform forward propagation.

//Build the interpreter with the InterpreterBuilder.
    //Note: all Interpreters should be built with the InterpreterBuilder,
    // which allocates memory for the Interpreter and does various set up
    // tasks so that the Interpreter can read the provided model.
    
    tflite::ops::builtin::BuiltinOpResolver resolver;
    tflite::InterpreterBuilder builder(*model, resolver);
    std::unique_ptr<tflite::Interpreter> interpreter; builder(&interpreter);
    if (!interpreter) {
       std::cerr << "Failed to construct interpreter on provided tflite model" << std::endl;
    }
    if (interpreter->AllocateTensors() != kTfLiteOk) {
       std::cerr << "Failed to allocate tensors!" << std::endl; exit(-1);
    }
    Copy to clipboard

## Prepare a model with a chosen delegate

After creating an interpreter and allocating the necessary memory to
run the model, prepare the model with a chosen delegate. This step
creates an execution graph from the model loaded earlier and uses the
underlying library to perform inference on the delegate hardware.

The following example code creates the XNNPACK delegate for running a
LiteRT model on the Arm CPU. It creates the delegate by calling the
`TfLiteXNNPackDelegateCreate(...)` API. You can also customize the
delegate using the Delegate Options API.

TfLiteDelegate *delegate = NULL;
    TfLiteXNNPackDelegateOptions xnnpack_options = TfLiteXNNPackDelegateOptionsDefault();
    xnnpack_options.num_threads = num_threads;
    
    TfLiteDelegate* xnnpack_delegate = TfLiteXNNPackDelegateCreate(&xnnpack_options);
    if (interpreter->ModifyGraphWithDelegate(xnnpack_delegate) != kTfLiteOk) {
       // Report error and fall back to another delegate, or the default backend
    }
    Copy to clipboard

## Prepare input/output buffers

When you build a standalone LiteRT application, it’s essential to
prepare input data, such as camera frames, for the pipeline to run
LiteRT models.

Preprocessing operations, in the following cases for example, are
important to ensure that inference happens correctly:

- Resizing the input image to a resolution expected by the model
- Normalization
- Mean subtraction

## Run a model

To run inference on a model, you must invoke a delegate using the
`Invoke()` API. Before invoking this API, create the appropriate
input/output buffers and provide them to the interpreter.

After the inference is complete, you can parse the output from the
output buffers of the interpreter to generate the inference results.

An example of the `Invoke()` API running a model using a delegate is as
follows:

// Run Inference
    interpreter->Invoke()
    Copy to clipboard

After the inference is complete, you can find the output tensors from
the LiteRT `Invoke()` API in the output buffers of the interpreter. To
perform further postprocessing on these outputs, you can parse them
from the interpreter.

For a comprehensive example, see the `label_image` example in the
[TensorFlow GitHub repository](https://github.com/tensorflow/tensorflow/tree/master/tensorflow/lite/examples/label_image).

For more information, see the [LiteRT documentation](https://ai.google.dev/edge/litert).

Last Published: Jun 23, 2026

[Previous Topic
Deploy LiteRT with an IMSDK application](https://docs.qualcomm.com/bundle/publicresource/80-80022-15B/topics/deploy-litert-with-an-imsdk-application.md) [Next Topic
Customize LiteRT](https://docs.qualcomm.com/bundle/publicresource/80-80022-15B/topics/customize-litert.md)