Overview

tflite wraps TensorFlow Lite — Google's framework for on-device ML inference. Models trained in TensorFlow, Keras, or converted from PyTorch/ONNX are compiled to the .tflite FlatBuffer format and executed directly on CPU, GPU, or accelerator hardware without a network connection.

The package covers the full inference lifecycle: loading models, creating interpreters, allocating tensor memory, filling inputs, running inference, and reading outputs. Hardware delegates (GPU, NNAPI) plug in with a single call.

Inference Workflow

Every TFLite inference follows the same six-step sequence. Skipping or reordering steps causes undefined behavior or crashes.

Key Capabilities

Capability	Detail
Delegates	GPU (OpenGL ES on Android/Linux, Metal on Apple), NNAPI (Android Neural Networks API), Core ML, Hexagon DSP. Apply with ApplyDelegate before AllocateTensors.
Quantization	INT8 and INT16 post-training quantization for 4× smaller models and faster CPU inference. Use SetInputInt8 / GetOutputInt8 with quantized models.
Operations count	170+ built-in ops covering convolutions, LSTM, GRU, attention, depthwise separable conv, batch norm, and common activations.
Metadata	Models may embed input/output labels, normalization parameters, and descriptions. Read with GetModelInfo and GetTensorInfo.

vs Other Inference Runtimes

Runtime	TFLite advantage	When to prefer the other
ONNX Runtime	Smaller binary, better mobile/edge support, Android NNAPI integration	ONNX Runtime when your model originates in PyTorch and you need CUDA on desktop
PyTorch Mobile	TFLite binary is significantly smaller; broader hardware delegate ecosystem	PyTorch Mobile when you need full PyTorch op coverage or custom C++ extensions
OpenVINO	TFLite is hardware-agnostic; runs on ARM, Android, microcontrollers	OpenVINO when you target Intel CPUs/GPUs/VPUs and need maximum throughput on x86

Quick Start

Image classification (one-liner)

uses tflite;

{ High-level helper: loads model, runs inference, returns top-3 label strings }
var labels := ClassifyImage('mobilenet_v2.tflite', imageRGBBytes, 224, 224, 3);

for var i := 0 to Length(labels) - 1 do
  WriteLn(labels[i]);

Custom model with float32 tensors

uses tflite;

{ Load and inspect }
var model := LoadModel('my_model.tflite');
var info  := GetModelInfo(model);
WriteLn('Inputs: '  + IntToStr(info.InputCount));
WriteLn('Outputs: ' + IntToStr(info.OutputCount));

{ Create interpreter (4 threads) }
var interp := NewInterpreter(model, 4);
AllocateTensors(interp);

{ Check input tensor shape }
var tin  := InputTensor(interp, 0);
var tinfo := GetTensorInfo(tin);
WriteLn('Input: ' + tinfo.Name + ' type=' + IntToStr(Ord(tinfo.TypeKind)));

{ Fill input with normalized float32 pixel data }
SetInputFloat(interp, 0, pixelFloats);  { array of Single, length = 1*224*224*3 }

{ Run inference }
Invoke(interp);

{ Read scores from output tensor 0 }
var scores := GetOutputFloat(interp, 0);
WriteLn('Output classes: ' + IntToStr(Length(scores)));

{ Cleanup }
FreeInterpreter(interp);
FreeModel(model);

GPU delegate

uses tflite;

var model  := LoadModel('detector.tflite');
var interp := NewInterpreter(model, 1);

{ Create GPU delegate and apply BEFORE AllocateTensors }
var gpu := NewGPUDelegate();
ApplyDelegate(interp, gpu);

AllocateTensors(interp);

{ Fill inputs, run, read outputs as usual }
SetInputUInt8(interp, 0, imageBytes);
Invoke(interp);
var boxes := GetOutputFloat(interp, 0);

FreeDelegate(gpu);
FreeInterpreter(interp);
FreeModel(model);

TTFLiteType Enum

Tensor element types. Check TTFLiteTensorInfo.TypeKind to select the correct SetInput* / GetOutput* variant.

Value	Ordinal	Description
tftNoType	0	Unset / unknown type
tftFloat32	1	32-bit float — most common for non-quantized models
tftInt32	2	Signed 32-bit integer
tftUInt8	3	Unsigned 8-bit — default quantized type for Android deployment
tftInt64	4	Signed 64-bit integer (e.g. token IDs in NLP models)
tftString	5	Variable-length string tensor
tftBool	6	Boolean tensor
tftInt16	7	Signed 16-bit integer (INT16 quantization)
tftComplex64	8	64-bit complex number (32-bit real + 32-bit imaginary)
tftInt8	9	Signed 8-bit integer — INT8 quantized models
tftFloat16	10	16-bit float (half precision)
tftFloat64	11	64-bit float (double precision)

Types

Handle types

type
  TTFLiteModel       = Integer;  { loaded .tflite model }
  TTFLiteInterpreter = Integer;  { inference interpreter }
  TTFLiteTensor      = Integer;  { tensor handle }
  TTFLiteDelegate    = Integer;  { hardware delegate handle }

TTFLiteType

type
  TTFLiteType = (
    tftNoType    = 0,  tftFloat32 = 1,  tftInt32   = 2,
    tftUInt8     = 3,  tftInt64   = 4,  tftString  = 5,
    tftBool      = 6,  tftInt16   = 7,  tftComplex64 = 8,
    tftInt8      = 9,  tftFloat16 = 10, tftFloat64 = 11
  );

TTFLiteTensorInfo

type
  TTFLiteTensorInfo = record
    Name     : string;               { tensor name from model metadata }
    TypeKind : TTFLiteType;          { element type (see TTFLiteType enum) }
    Dims     : array of Integer;    { shape, e.g. [1, 224, 224, 3] }
    ByteSize : Integer;              { total bytes in the tensor }
    IsInput  : Boolean;
    IsOutput : Boolean;
  end;

TTFLiteModelInfo

type
  TTFLiteModelInfo = record
    InputCount  : Integer;  { number of input tensors }
    OutputCount : Integer;  { number of output tensors }
    Description : string;  { embedded model description, if any }
  end;

Model Functions

Function	Description
LoadModel(Path)	Load a .tflite FlatBuffer from the filesystem. Returns a model handle.
LoadModelBuffer(Data)	Load from an in-memory string buffer (e.g. after downloading over the network).
FreeModel(M)	Release the model and its memory. Do not use the handle after freeing.
GetModelInfo(M)	Returns a TTFLiteModelInfo with input/output counts and the embedded description string.

Interpreter Functions

Function	Description
NewInterpreter(M, NumThreads)	Create an interpreter for model M. Pass 0 for NumThreads to let TFLite choose automatically.
FreeInterpreter(I)	Destroy the interpreter and release tensor buffers.
AllocateTensors(I)	Allocate memory for all input and output tensors. Must be called after NewInterpreter (and after ApplyDelegate) before the first Invoke.
ApplyDelegate(I, D)	Attach a hardware delegate. Must be called before AllocateTensors.
Invoke(I)	Execute inference. Blocks until complete. Input tensors must be filled first.

Tensor Functions

Function	Description
InputCount(I)	Number of input tensors the model expects.
OutputCount(I)	Number of output tensors the model produces.
InputTensor(I, Index)	Handle to input tensor Index (zero-based).
OutputTensor(I, Index)	Handle to output tensor Index (zero-based).
GetTensorInfo(T)	Returns TTFLiteTensorInfo: name, type, shape, byte size, and I/O flags.
ResizeTensor(I, Index, NewDims)	Resize an input tensor for dynamic-shape models. Call AllocateTensors again after resizing.

Fill Input Tensor Functions

Select the function that matches TTFLiteTensorInfo.TypeKind for tensor 0 (or whichever input index you are filling).

Function	Element type	Description
SetInputFloat(I, Index, Data)	tftFloat32	Copy a array of Single into the input tensor. Length must match the tensor's total element count.
SetInputUInt8(I, Index, Data)	tftUInt8	Copy a array of Byte. Typical for quantized MobileNet / EfficientDet models.
SetInputInt8(I, Index, Data)	tftInt8	Copy a array of ShortInt. Use with INT8-quantized models that store signed values.

Read Output Tensor Functions

Function	Element type	Description
GetOutputFloat(I, Index)	tftFloat32	Returns array of Single with the raw logits or scores.
GetOutputUInt8(I, Index)	tftUInt8	Returns array of Byte for quantized output tensors.
GetOutputInt8(I, Index)	tftInt8	Returns array of ShortInt for signed INT8 output tensors.

Delegate Functions

Function	Description
NewGPUDelegate()	Create a GPU delegate. Uses OpenGL ES on Android/Linux; Metal on Apple platforms. Apply before AllocateTensors.
NewNNAPIDelegate()	Create an Android Neural Networks API delegate. Routes ops to DSP, NPU, or GPU as available on the device.
FreeDelegate(D)	Release the delegate after the interpreter is also freed.

Convenience Functions

Function	Description
ClassifyImage(ModelPath, ImageRGB, Width, Height, TopN)	Load model, run inference on an RGB byte buffer (Height × Width × 3), and return the top-N label strings with scores. One-shot, manages its own interpreter lifecycle.
DetectObjects(ModelPath, ImageRGB, Width, Height, Threshold)	Run object detection and return a JSON string with bounding boxes, class labels, and confidence scores above Threshold.
TFLiteVersion()	Returns the linked TFLite runtime version string (e.g. "2.14.0").