# Where to Find the LiteRT Repository: Official GitHub Location and Source Structure

> Locate the LiteRT repository on GitHub. Access the full source code for Google's lightweight ML runtime, including build configurations, at google-ai-edge/LiteRT.

- Repository: [google-ai-edge/LiteRT](https://github.com/google-ai-edge/LiteRT)
- Tags: getting-started
- Published: 2026-03-13

---

**The LiteRT repository is publicly hosted on GitHub at https://github.com/google-ai-edge/LiteRT, containing the complete source code for Google's lightweight machine learning runtime, including CMake and Bazel build configurations.**

The **LiteRT repository** serves as the official home for Google's next-generation lightweight runtime for machine learning inference. Hosted under the `google-ai-edge` organization, this open-source project provides the core runtime libraries, build tools, and example implementations needed to deploy TensorFlow Lite models efficiently. Developers can access the complete source code to build, customize, and integrate LiteRT into edge computing applications.

## Official Repository Location

The canonical source for LiteRT resides in the public GitHub repository `google-ai-edge/LiteRT`. You can browse the latest stable code, review release notes, and download the entire project directly from the main branch.

To obtain a local copy, use either HTTPS or SSH:

```bash

# Clone via HTTPS

git clone https://github.com/google-ai-edge/LiteRT.git
cd LiteRT

# Or clone via SSH (requires GitHub SSH key)

git clone git@github.com:google-ai-edge/LiteRT.git

```

Alternatively, download a ZIP archive directly from the GitHub interface using the "Code → Download ZIP" option.

## Repository Structure and Organization

The LiteRT repository follows a conventional Bazel-oriented layout while maintaining comprehensive CMake support. The top-level directories separate the core runtime from utilities, examples, and build tooling.

| Directory | Purpose |
|-----------|---------|
| `litert/` | Core LiteRT runtime, CMake build files, and documentation |
| `tflite/` | Helper utilities and type definitions used by the runtime |
| `weight_loader/` | APIs for loading external model weights |
| `third_party/` | External dependencies (e.g., `xdsl`) |
| `docker_build/` | Docker-based build scripts and environment specifications |
| `cmake_example/` | Minimal CMake example programs illustrating usage |

Key configuration files at the root include `BUILD*` targets, `WORKSPACE` for Bazel, [`README.md`](https://github.com/google-ai-edge/LiteRT/blob/main/README.md) for project overview, and [`RELEASE.md`](https://github.com/google-ai-edge/LiteRT/blob/main/RELEASE.md) for version guidance.

## Building from Source

LiteRT supports both CMake and Bazel build systems, accommodating different development workflows and platform requirements.

### CMake Build Process

The repository provides predefined CMake presets for streamlined compilation. In [`litert/CMakeLists.txt`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/CMakeLists.txt) and [`litert/CMakePresets.json`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/CMakePresets.json), the build logic defines targets for the runtime library and example applications.

```bash

# Clone and enter the repository

git clone https://github.com/google-ai-edge/LiteRT.git
cd LiteRT

# Create build directory and configure

mkdir -p build && cd build
cmake .. --preset=default

# Build the runtime library

cmake --build . --target litert

```

After successful compilation, run the minimal example in `cmake_example/run_model_simple.cc` to verify your build:

```bash
./cmake_example/run_model_simple <path/to/model.tflite>

```

### Bazel Build Process

For Bazel users, the repository includes `BUILD` files throughout the source tree and a root `WORKSPACE` file defining external dependencies. Build all targets using:

```bash
bazel build //...

```

Build definitions shared across the project reside in `litert/build_common/litert_build_defs.bzl`. For containerized builds, the repository provides `docker_build/hermetic_build.Dockerfile` for reproducible build environments.

## Core API and Usage Examples

The `litert/` directory contains the primary headers and implementation files for model loading and inference.

### Loading and Running Models

The runtime API, defined in [`litert/runtime.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/runtime.h) and [`litert/model.h`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/model.h), enables straightforward model execution. The [`tflite/util.h`](https://github.com/google-ai-edge/LiteRT/blob/main/tflite/util.h) header provides additional helper utilities for tensor handling.

```cpp
#include "litert/runtime.h"
#include "litert/model.h"
#include "litert/tensor.h"

int main() {
  // Load model from filesystem
  auto model = litert::Model::LoadFromFile("model.tflite");
  
  // Initialize runtime and allocate tensors
  litert::Runtime runtime;
  runtime.LoadModel(*model);
  runtime.AllocateTensors();
  
  // Execute inference
  runtime.Invoke();
  
  // Access output via runtime.GetOutputTensor(0)
  return 0;
}

```

### External Weight Loading

For scenarios requiring separated model weights, the [`weight_loader/external_weight_loader_litert.h`](https://github.com/google-ai-edge/LiteRT/blob/main/weight_loader/external_weight_loader_litert.h) interface loads external binary blobs:

```cpp
#include "weight_loader/external_weight_loader_litert.h"

// Load weights from external file
auto status = litert::ExternalWeightLoader::LoadFromFile("weights.bin");
if (!status.ok()) {
  // Handle error
}

```

## Summary

- The **LiteRT repository** is located at `https://github.com/google-ai-edge/LiteRT` under the `google-ai-edge` GitHub organization
- The project uses a hybrid build system with **CMake** (primary for development) and **Bazel** (for internal Google workflows)
- Core runtime code resides in the `litert/` directory, with helper utilities in `tflite/` and weight loading APIs in `weight_loader/`
- Predefined CMake presets in [`litert/CMakePresets.json`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/CMakePresets.json) streamline the build process
- The `cmake_example/run_model_simple.cc` file provides a minimal working example of model inference

## Frequently Asked Questions

### What is the exact URL for the LiteRT repository?

The official LiteRT repository is hosted at **https://github.com/google-ai-edge/LiteRT**. This URL provides access to the main branch containing the latest stable source code, build configurations, and documentation for Google's lightweight machine learning runtime.

### Does LiteRT support both CMake and Bazel builds?

Yes. The repository maintains full support for **CMake** through [`litert/CMakeLists.txt`](https://github.com/google-ai-edge/LiteRT/blob/main/litert/CMakeLists.txt) and [`CMakePresets.json`](https://github.com/google-ai-edge/LiteRT/blob/main/CMakePresets.json), making it accessible for standard open-source development. It also includes **Bazel** `BUILD` files and a `WORKSPACE` configuration used internally at Google and available for Bazel-based projects.

### Where can I find example code for running inference?

Practical examples reside in the `cmake_example/` directory, specifically `cmake_example/run_model_simple.cc`. This file demonstrates how to load a TensorFlow Lite model using `litert::Model::LoadFromFile()`, initialize the runtime, allocate tensors, and execute inference through `runtime.Invoke()`.

### How do I load model weights that are stored separately from the model file?

Use the **External Weight Loader** API defined in [`weight_loader/external_weight_loader_litert.h`](https://github.com/google-ai-edge/LiteRT/blob/main/weight_loader/external_weight_loader_litert.h). The `ExternalWeightLoader::LoadFromFile()` method allows you to load binary weight blobs from external storage, enabling flexible deployment scenarios where model architecture and weights are distributed separately.