Geti™ is an end-to-end Vision AI application that takes you from raw images to a deployed computer vision model. Geti™ runs locally as a single container or a native Windows app and is optimized for fast inference across the full Intel® XPU portfolio.
Important
This repo previously hosted the OpenVINO Training Extensions project, namely otx;
the development of that library now continues under the new name
getitune in the library folder, as the training engine of the broader Geti™ application. The package is
published on PyPI as getitune, while the old package otx is deprecated but
still available for download.
The development of the Geti™ application now continues in this repository in the application folder.
Previous versions of Geti™ are still available in a separate repository.
In general, we recommend upgrading to the latest Geti™ release whenever possible - not only to access new functionality,
but also to receive better support from Intel and the Geti™ community.
To upgrade from Geti™ v2 to v3, please follow the upgrade guidance.
Before you begin, make sure your machine meets the following requirements:
| Component | Requirement |
|---|---|
| CPU | 8 threads |
| RAM | 16 GB |
| Disk | 40 GB free |
| GPU | Optional - Intel® XPU or NVIDIA® GPU for larger models |
Geti can be installed as a Windows application, run as a container, or built from source code. Choose the option that best suits your environment below.
Windows Application
Download the latest Geti™ Windows installer suitable for your hardware (Intel® XPU, NVIDIA® CUDA or CPU-only) from the releases repository:
Install Geti™ Windows application and launch it from the Start menu.
Container image
Pull a pre-built container image for your hardware and launch it using just, which handles device passthrough, volumes, and WebRTC ports automatically:
# 1. Install just
curl --proto '=https' --tlsv1.2 -sSf https://just.systems/install.sh | bash -s -- --to /usr/local/bin
# 2. Clone the repository
git clone https://github.com/open-edge-platform/geti.git
cd geti/application
# 3. Pull the image for your hardware (choose one: cpu|cuda|xpu)
ACCELERATOR=xpu
docker pull ghcr.io/open-edge-platform/geti-${ACCELERATOR}
# 4. Retag the pulled image for use with just
docker tag ghcr.io/open-edge-platform/geti-${ACCELERATOR}:latest geti-${ACCELERATOR}:latest
# 5. Launch the application
just run-image --accelerator ${ACCELERATOR}Then get access to Geti™ user interface at http://localhost:7860.
Install from source code
To install the Geti™ stable development version from source code, use:curl -fsSL https://raw.githubusercontent.com/open-edge-platform/geti/develop/install.sh | bashInstalling from source gives you access to the latest features not yet available in released builds, including Ultralytics YOLO26 support.
Once Geti is up and running, follow the intuitive UI to train your first model.
Note
See the detailed step-by-step guidance on how to train your first model in "Training your first model" section in the Geti™ documentation. Full instructions and all options are available in Geti™ documentation.
Detailed installation guide is available in "Installation guide"
Geti's training engine is published on PyPI and can train, optimize, and deploy models from Python.
uv pip install "getitune[xpu]" --extra-index-url https://download.pytorch.org/whl/xpu # for Intel® XPU acceleration
uv pip install "getitune[cuda]" --extra-index-url https://download.pytorch.org/whl/cu128 # for NVIDIA® CUDA acceleration
uv pip install getitune # CPU-only by default
⚠️ Ultralytics YOLO Models: The PyPI package does not include Ultralytics YOLO26 models. Install from source to use them:git clone https://github.com/open-edge-platform/training_extensions.git cd training_extensions/library uv sync --extra xpu --extra ultralytics # Intel GPU + YOLO uv sync --extra cuda --extra ultralytics # NVIDIA GPU + YOLO uv sync --extra cpu --extra ultralytics # CPU + YOLOSee the library README for more details.
Discover available models and train a model in just a few lines of code:
from getitune.engine import create_engine
from getitune.utils import list_models
# Explore available models for your task
all_models = list_models() # List all model names
detection_models = list_models(task="DETECTION") # Filter by task
recipes = list_models(return_recipes=True) # Get full recipe YAML paths
# Create an engine using any model name or recipe path
engine = create_engine(
model="efficientnet_b0", # model name, recipe YAML path, or exported IR/ONNX
data="/path/to/dataset", # dataset directory or YAML path
work_dir="./my_workspace", # checkpoints and logs directory
device="auto", # "auto", "cpu", "gpu", "xpu".
)
# Train and validate
engine.train(max_epochs=50)
metrics = engine.test()
# Export to OpenVINO IR (default) for deployment
exported_model_path = engine.export()
# load exported OpenVINO model
ov_engine = create_engine(model=exported_model_path, data=engine.datamodule)
# optimize the model for edge deployment
optimized_model_path = ov_engine.optimize()
# test the optimized model
metrics = ov_engine.test()
# predict with the optimized model
predictions = ov_engine.predict()See the library README for the full list of recipes, advanced configuration, dataset support, backend-specific options, and deployment/optimization examples.
🏆 State-of-the-art model catalog
Train and fine-tune modern architectures such as RF-DETR, DINOv3 DETR, YOLO26, YOLOX, D-FINE, and Mask R-CNN. Would you like to see a specific model added? Let us know by opening a GitHub issue!
| Computer Vision Task | Model Architecture | Paper |
|---|---|---|
| Object Detection Locate and classify objects with bounding boxes, e.g. counting items, defect localization, surveillance. |
D-FINE M / L / X | DEIM + D-FINE |
| DINOv3 DETR S / M / L | DINOv3 + DEIMv2 + DETR | |
| MobileNet V2 ATSS | MobileNetV2 + ATSS | |
| MobileNet V2 SSD | MobileNetV2 + SSD | |
| RF-DETR S / M / L | RF-DETR | |
| RT-DETR R50 | RT-DETR | |
| YOLO26 Nano / Small / Medium | Ultralytics YOLO | |
| YOLOX Tiny / S / L / X | YOLOX | |
| Instance Segmentation Detect objects and produce pixel-precise masks per instance, e.g. measuring object area, robotics, medical imaging. |
RTMDet Tiny | RTMDet |
| Mask-RCNN EfficientNet B2 | EfficientNet + Mask R-CNN | |
| Mask-RCNN ResNet50 | ResNet + Mask R-CNN | |
| Mask-RCNN Swin-T | Swin Transformer + Mask R-CNN | |
| RF-DETR S / M / L | RF-DETR | |
| Classification (multi-class, multi-label) Assign one or more labels to an entire image, e.g. quality pass/fail, product categorization, content tagging. |
ViT Tiny | ViT |
| DINOv2 Small | DINOv2 | |
| EfficientNet B0 / B3 | EfficientNet | |
| EfficientNet V2 Small | EfficientNetV2 | |
| MobileNet V3 Large | MobileNetV3 |
🔄 Interactive end-to-end model training
Geti™ enables users to start building deep-learning computer vision models with as few as 10-20 images and take them to production in one environment - annotate, train, optimize, run inference, and improve accuracy in a rapid train-predict-annotate loop.
⚡ Hardware-accelerated inference & model optimization
Every model is automatically exported with OpenVINO™ for deployment across the full Intel® XPU portfolio (Arc™ GPUs, Core™ Ultra processors); NVIDIA® CUDA and CPU-only execution are also supported. Fine-tune and run inference directly on edge and client hardware - including Intel® Panther Lake and Arc™ Battlemage (B-series) GPUs - with no Kubernetes cluster or data-center GPU required. Built-in accuracy-aware INT8 quantization further reduces model size and latency on resource-constrained edge devices with minimal impact on accuracy.
🚀 Integrated deployment & inference
Build custom pipelines (source → model → sink) to deploy models inside Geti and monitor real-time predictions on video streams. Sources include USB/IP cameras and video files; optional sinks include folder, MQTT, and webhook. Complete pipelines can be exported as OpenVINO™-optimized bundles for edge deployment.
🎨 Multiple computer vision tasks
Geti™ supports multiple computer vision tasks that are commonly employed across various use cases - image classification, object detection and instance segmentation from the no-code web interface, with even more tasks available through the getitune library.
🧠 Smart annotations
Smart annotations in Geti™ enable users to easily create bounding boxes, rotated bounding boxes, segmentation boundaries, and more. These smart annotation features coupled with the AI-assisted annotations and state-of-the-art AI models such as the Segment Anything Model keep human experts in the loop while massively reducing the total annotation efforts needed by a human.
📦 Model & dataset management
Track how datasets and models evolve, link models to a specific dataset revision, view exact training hyperparameters, and fine-tune from any previous version. Import and export in COCO, Pascal VOC, YOLO, and a Geti-optimized native format, with label filtering to selectively include or exclude labels on import/export.
- Anomalib - An anomaly detection suite comprising state-of-the-art algorithms and features such as experiment management, hyper-parameter optimization and edge inference.
- Instant Learn - A framework for developing, benchmarking, and deploying zero-shot visual prompting algorithms on the edge.
- Datumaro - Dataset Management Framework, a Python library and a CLI tool to build, analyze and manage Computer Vision datasets.
- OpenVINO™ - Software toolkit for optimizing and deploying deep learning models.
- OpenVINO™ Model Server - A scalable inference server for models optimized with OpenVINO™.
- Model API - A set of wrapper classes for particular tasks and model architectures, simplifying data preprocessing and postprocessing as well as routine procedures.
- Physical AI Studio - An end-to-end framework for teaching robots to perform tasks through imitation learning from human demonstrations.
Geti™ is a powerful tool to build vision models for a wide range of processes, including detecting defective parts in a production line, reducing downtime on the factory floor, automating inventory management, or other automation projects. We have chosen to highlight a few interesting community members:
- Intel Foundry
- Royal Brompton and Harefield hospitals
- WSC Sports
- Dell NativeEdge
- Bravent
- ASRock Industrial
- PeopleSense.AI
- Capgemini
- To report a bug or submit a feature request, please open a GitHub issue.
- Ask questions via GitHub Discussions.
For those who would like to contribute, see Contributing guide for details.
Thank you 👏 to all our contributors!
Geti™ is licensed under the Apache License Version 2.0.
Geti™ utilizes FFmpeg.
FFmpeg is an open source project licensed under LGPL and GPL. See https://www.ffmpeg.org/legal.html. You are solely responsible for determining if your use of FFmpeg requires any additional licenses. Intel is not responsible for obtaining any such licenses, nor liable for any licensing fees due, in connection with your use of FFmpeg.
Ultralytics YOLO models are distributed under the AGPL-3.0 license, an OSI approved license ideal for open-source research, academic, and personal projects. For commercial use, enhanced support, and tailored licensing terms, please explore flexible Ultralytics licensing options at https://www.ultralytics.com/license.