--- updatedAt: 2026-09-17T11:17:33.000Z agentTools: projectIndex: https://docs.sixfab.com/llms.txt --- # Sixfab Model Zoo A ready-to-run library of pre-compiled .dxnn vision models, object detection, face detection, pose estimation, and segmentation that deploy without training or compiling across all Sixfab edge AI hardware {`

Sixfab Model Zoo

Pre-compiled .dxnn vision models for Sixfab edge AI hardware, ready to run on the DEEPX NPU. Download, deploy, and benchmark in minutes, with no compiler workflow and no training pipeline.

DEEPX DX-M1 family .dxnn pre-compiled INT8 precision Vision tasks Fastest time-to-demo
AI Model Deployment · Sixfab Model Zoo · Updated 2026-05-16
What is the Sixfab Model Zoo?

The Sixfab Model Zoo is a ready-to-run library of AI vision models for Sixfab edge AI hardware. Every file in the zoo (extension .dxnn) is already converted, optimised, and packaged to run on the DEEPX NPU, so you do not need to train or compile anything. Pick a task (detect objects, find faces, estimate human pose, or segment images), download the matching file, and run it with the dxrt-runtime you installed at first boot. No DXNN SDK, no Ubuntu compile host, no training pipeline. The same .dxnn files run on the Sixfab AI HAT+ for Raspberry Pi 5, the Sixfab Edge AI Expansion Board, and ALPON X5 AI without modification.

Quick demo

The sixfab-dx package installed during Quickstart ships with a single Hello World demo so you can confirm the NPU is alive in one line. There is nothing to download, no model path to type, and no camera required. The same command runs unchanged on every product in the AI Model Deployment surface.

bash · target device
Run on target 
# Run the bundled Hello World demo (no flags, no model path)
run_hello_world
Where the demo lives, per product

On AI HAT+ and Edge AI Expansion Board, run_hello_world is on the path the moment the sixfab-dx APT package is installed during AI HAT+ Quickstart or Edge AI Expansion Board Quickstart. On ALPON X5 AI, the tools and demo ship pre-installed in the factory image, so the same one-liner works out of the box.

run_hello_world is a sanity check, not a model catalog. To run the full set of vision demos, with rendered output, configurable input sources, and 50+ examples, clone the sixfab-dx-examples repository covered in Deploy pattern below.

Model catalog

The zoo covers the vision tasks shipped in the sixfab-dx-examples repository: object detection (find and label things in an image), face detection (find faces specifically), pose estimation (find the joints of a person's body), instance segmentation (find each object and outline its exact shape), and semantic segmentation (classify every pixel in a scene). Detection models also come in PPU-accelerated and async variants. Every model is a single .dxnn file you can drop in and run.

Vision today INT8 quantised YOLOv5 / v8 / v9 / SCRFD / DeepLabV3 Detection · Face · Pose · Segmentation PPU + Async variants
What does "PPU" mean on some of the models below?

After an object-detection model finds objects, there is a clean-up step called non-maximum suppression that removes duplicate boxes around the same object. Normally this clean-up runs on the host CPU. A PPU (Post-Processing Unit) version of a model does that clean-up directly on the NPU instead, keeping the host CPU free and producing a higher frame rate.

PPU is on by default for every model in this zoo. The post-processing step is baked into the .dxnn file itself, so there is no flag to set and nothing to enable. If a card below is marked Detection · PPU, the file already contains it; the label is informational, not a separate variant.

YoloV8N.dxnn
Spots everyday objects in images (people, cars, dogs, traffic signs, and so on) and draws a coloured box around each one. The smallest, fastest YOLOv8 model. Best place to start; this is the one the Quick demo above uses.
Detection · PPU ~35 FPS · 25 TOPS
YoloV8S.dxnn
Same task as YOLOv8n (boxes around objects), but the "small" model is a step up in accuracy. Slower, fewer frames per second, but spots smaller and harder objects more reliably.
Detection FPS pending
YoloV8M.dxnn
The largest YOLOv8 model in the zoo (the "medium" size). Highest accuracy at the cost of frame rate. Good when you have time to process and want the best detections.
Detection FPS pending
YoloV9S.dxnn
Same idea as YOLOv8 (boxes around objects) using the newer YOLOv9 architecture. The "small" variant. Generally more accurate than YOLOv8s at a similar speed.
Detection FPS pending
YoloV9C.dxnn
The "compact" YOLOv9 build. Sits between YOLOv9s and the medium model: a bit more accurate than the small one, a bit faster than the medium one.
Detection FPS pending
SCRFD500M.dxnn
Finds faces specifically (not general objects). Lightweight and built to handle scenes with many faces at once, like a crowd or a classroom. Good for visitor counters and access control.
Face FPS pending
YoloV5Pose.dxnn
Detects people and pinpoints 17 body joints on each one (head, shoulders, elbows, wrists, knees, ankles, and so on). Useful for fitness apps, sport analytics, and any project that cares how a person is moving, not just where they are.
Pose FPS pending
YoloV26S-Seg.dxnn
Instance segmentation with a YOLOv26 small backbone. Finds each object and produces a pixel-accurate mask of its shape, instead of just a bounding box. Useful when precise outlines matter, for example counting irregular items on a conveyor or measuring crop coverage.
Segmentation FPS pending
More demos ship with sixfab-dx-examples

The cards above are the .dxnn files with measured or pending per-product performance. The sixfab-dx-examples repository ships a wider demo collection on top of the same files: a Python launcher with 28 demos and a C++ launcher with 26. Categories beyond the base catalog above include:

  • PPU-accelerated variants (scrfd_ppu, yolov5_ppu, yolov5pose_ppu, yolov7_ppu). Image preprocessing offloads to dedicated hardware on the NPU module, freeing CPU resources and lifting throughput.
  • Async inference (yolov8_async). The host pipeline keeps capturing while the NPU is busy, using the non-blocking RunAsync / Wait pattern.
  • Semantic segmentation with DeepLabV3+. Classify every pixel in the frame, not just object instances.
  • Classification backbones for whole-image labelling: EfficientNet, MobileNet, and YOLOv26-cls.
  • Wider detection coverage across YOLOv5, v7, v8, v9, v10, v11, v12, v26, and YOLOX, all driven from the same launcher.
  • Pose estimation across architectures (YOLOv5-Pose, YOLOv26-Pose) and a 21-point hand landmark demo (hand_landmark).
  • Face detection paired with emotion classification (C++ emotion_demo) on top of the SCRFD face card.
  • Re-identification with OSNet (C++ osnet_reid_demo). Match the same person across cameras and over time.
  • Analytics pipelines built on detection: people tracking, smart traffic counting, queue analysis, zone intrusion, and 4-channel concurrent grid inference (multi_channel_4).

Every demo accepts the same input sources: Raspberry Pi camera, USB webcam, video file, single image, or RTSP stream. The python-examples.md and cpp-examples.md guides in the repo list every demo, its CLI flags, and the YAML / JSON configuration for each.

Per-product performance

Each row below is one model, run on the three NPU variants in the AI Model Deployment surface. The confirmed figure is YOLOv8n with PPU on the 25 TOPS DEEPX DX-M1M, which lands at roughly 35 FPS at 640×640 input on the Sixfab AI HAT+ for Raspberry Pi 5. All other cells are pending characterisation and marked as such; nothing is estimated or extrapolated.

Model Task Input DEEPX DX-M1M, 25 TOPSAI HAT+ on Raspberry Pi 5 DEEPX DX-M1ML, 13 TOPSAI HAT+ on Raspberry Pi 5 DEEPX DX-M1, 25 TOPSEdge AI Expansion Board / ALPON X5 AI
YoloV8N.dxnn Detection · PPU 640×640 ~35 FPS FPS pending FPS pending
YoloV8S.dxnn Detection 640×640 FPS pending FPS pending FPS pending
YoloV8M.dxnn Detection 640×640 FPS pending FPS pending FPS pending
YoloV9S.dxnn Detection 640×640 FPS pending FPS pending FPS pending
YoloV9C.dxnn Detection 640×640 FPS pending FPS pending FPS pending
SCRFD500M.dxnn Face detection 640×640 FPS pending FPS pending FPS pending
YoloV5Pose.dxnn Pose estimation 640×640 FPS pending FPS pending FPS pending
YoloV26S-Seg.dxnn Segmentation 640×640 FPS pending FPS pending FPS pending

The same .dxnn file runs on all three products without a rebuild. The differences in FPS across columns come from two factors only: the DEEPX silicon variant (25 TOPS at INT8 for DX-M1M and DX-M1 versus 13 TOPS at INT8 for DX-M1ML) and the host CPU (Raspberry Pi 5 for AI HAT+ and Edge AI Expansion Board, Raspberry Pi Compute Module 5 for ALPON X5 AI).

Deploy pattern

The sixfab-dx-examples repository is the canonical source for runnable demos. It ships a Python collection and a C++ collection, each with an interactive launcher, and covers every model in this catalog plus the PPU-accelerated, async, and analytics demos shown in the Model catalog above. Output is rendered to a window (camera, RTSP, or video file) or to disk, so you actually see the model working.

What auto-install.sh does

The setup script validates the DEEPX runtime, downloads every model, sample video, and sample image from the GitHub release, installs Python dependencies into the shared Sixfab virtual environment at /opt/sixfab-dx/venv, and builds every C++ demo binary. After it finishes, both launchers are ready and the full model catalog is on disk.

bash · target device
Run on target 
# 1. Clone the examples repo and run the one-shot setup
git clone https://github.com/sixfab/sixfab-dx-examples.git
cd sixfab-dx-examples
./auto-install.sh

# 2. Activate the shared Sixfab virtual environment (every new shell)
source /opt/sixfab-dx/venv/bin/activate

# 3a. Launch the Python TUI (interactive menu, 28 demos)
bash python_examples/start.sh

# 3b. Or launch the C++ TUI (interactive menu, 26 demos)
bash cpp_examples/start.sh

# 3c. Or run a C++ binary directly with an explicit input source
./cpp_examples/build/object_detection/yolov8_demo --source libcamera

Every demo accepts the same set of input sources: Raspberry Pi camera (rpicam), USB webcam (webcam), video file (video), single image (image), or RTSP stream (rtsp). The repository README documents how to switch sources per demo.

Same command on all three products

Both run_hello_world and the entire sixfab-dx-examples collection behave identically across the Sixfab AI HAT+, the Sixfab Edge AI Expansion Board, and ALPON X5 AI. The working directory and the device IDs reported by dxrt-cli -s can differ, but command signatures and .dxnn file formats do not. A snippet that runs on AI HAT+ runs unchanged on the Edge AI Expansion Board and on ALPON X5 AI.

Where the .dxnn files live today

Model files live in two places, and which one matters depends on what you are doing. The bundled run_hello_world demo is fully self-contained inside the sixfab-dx APT package; the full catalog of vision models, sample videos, and sample images is downloaded by auto-install.sh when you clone the sixfab-dx-examples repository.

run_hello_world is a single command, no separate download

Previous releases shipped a demo.zip archive that had to be fetched and unpacked separately. That step has been retired. The sixfab-dx APT package now installs a self-contained Hello World demo and exposes it as the run_hello_world command on the path. There is nothing to download, no path to type, and no archive to manage.

bash · target device
Run on target 
# Bundled with the sixfab-dx APT package, no download step
run_hello_world

# Full model catalog and demos, downloaded by auto-install.sh
git clone https://github.com/sixfab/sixfab-dx-examples.git
cd sixfab-dx-examples
./auto-install.sh

For the full catalog, auto-install.sh fetches the model archive from the sixfab-dx-examples GitHub release and unpacks it into the repository's resource directory, where every demo expects to find it. Pre-built dx_engine and numpy wheels for both Python 3.11 and Python 3.13 live in /opt/sixfab-dx/wheels/ for users who prefer an isolated virtual environment over the shared one at /opt/sixfab-dx/venv; see the repository README for the manual install path.

Custom Models Need a model not in this catalog? Compile your own ONNX model to .dxnn with the DXNN SDK and deploy it to any product in the AI Model Deployment surface. Two-machine workflow: compile on an Ubuntu host, run on the target device. Deployment Workflow → Supported Models Catalog Want to know which architectures are supported? Reference list of model architectures and DEEPX operators that compile cleanly to .dxnn. Check this before training a model you plan to deploy on the NPU. Supported Models →
`}