oak-examples: a catalogue of runnable DepthAI and OAK camera examples

A reference library, not a package

The repository holds the demonstrations, tutorials and examples that showcase different capabilities of DepthAI and OAK devices, with each category focused on a specific aspect of the technology. There is nothing to install and nothing to import. What you get is a directory of small, self-contained projects, each with its own media folder and usually its own README, and the value is in the fact that somebody has already solved the problem you are about to solve. The hardware angle matters, because these are camera devices with a neural network accelerator and a depth sensor, and the hard part of any such project is not the model but the plumbing around it, the pipeline configuration, the codec, the runtime, the deployment. Luxonis publishes those worked examples rather than keeping them private, and the forum at discuss.luxonis.com and the documentation at docs.luxonis.com are where the projects themselves are explained.

DepthAIv3 in C++, and where the old examples went

The C++ category is the one to start with if you want to understand the platform, because it covers DepthAIv3 examples implemented in C++ including host builds and OAK app deployment guides, and the readme suggests beginning with the camera_stream sample to learn how to stream frames from a native depthai-core application. That ordering is deliberate. A streaming sample teaches the device API and the pipeline model without any model in the way, and the deployment guide tells you how the same code runs on the device rather than on your laptop, which is the distinction that trips up people moving from a desktop camera to an embedded one. The older material is not deleted. The repository points you at the master branch for legacy content and examples built with the previous DepthAIv2 version, so if you are working from a tutorial written two years ago, the matching code is still there. The default branch is main, and the clone command in the readme pins it explicitly.

Camera controls and depth measurement

Two categories cover the device rather than the model. Camera controls holds examples for focus, exposure, white balance and the other camera parameters, which sounds mundane until you try to write a camera that keeps a subject sharp as it moves. The manual camera control example is the reference for driving those parameters from code, and the parameters are the ones a vision system needs to be reliable in a room where the light changes. Depth measurement covers depth perception, and the readme names the three things it demonstrates: spatial calculations, depth visualization and 3D measurements including pointcloud. The stereo runtime configuration example is the one worth reading, because the depth pipeline has to be configured correctly for the stereo pair to produce sensible output, and getting that wrong produces a depth map that looks plausible and is wrong. Together these two categories are what turn a camera into a measuring instrument.

Neural networks and the streaming codec list

The neural networks category is the broad one, described as a comprehensive collection of model usage including object detection, classification, segmentation and many more, and the human machine safety example is a good illustration of what these projects are for, since detecting a person near a machine is a safety case rather than a demo. The streaming category is the one that decides whether your system works at all. It covers MJPEG, H.264, H.265, MQTT, TCP, RTSP and WebRTC, and the POE power over ethernet MQTT client example is the one to read first, because running a camera over a single cable changes what you can put on the network. The list is effectively the specification of what the platform can do, and the practical lesson from these examples is that the streaming format is a design decision with real consequences: MJPEG is simple and expensive in bandwidth, H.264 and H.265 are efficient and add a pipeline, and RTSP is what a standard player expects, and WebRTC is what a browser expects.

Integrations, and building a front end of your own

The integrations category shows how to connect DepthAI to the tools teams already use, and it names four: Luxonis Hub, Foxglove, Rerun and Roboflow. The difference between them is worth understanding, because they solve different problems. The custom frontend category then goes the other way and shows how to build your own interface, using React together with the @luxonis/depthai-viewer-common package to connect to a DepthAI application. The example there is an open vocabulary object detection one, which is the right choice of demonstration because the open vocabulary models are the ones where a user interface earns its place, since the set of things the model can detect is not fixed in advance.

How the examples are written and checked

The root of the repository contains the rules for contributing, and they are unusually explicit. There is an EXAMPLE_AUTHORING.md that presumably sets out how an example is expected to be structured, an ESSENTIAL_KNOWLEDGE.md, an INDEX.md that indexes the collection, an AGENTS.md, a CONTRIBUTING.md, a .pre-commit-config.yaml for the checks that run before a commit, a requirements-dev.txt for the shared development dependencies, and a scripts and tests directory for the tooling around the examples. There is also an .agents directory and a .gitmodules file, which means some parts of the collection are separate repositories pulled in as submodules. The licence is Apache 2.0 unless otherwise noted in a subdirectory or a file header, which is the pattern to expect when examples embed assets or third party code. The apps category is the other category with a distinct character, since it holds ready to use applications built with DepthAI plus the demos the author presents at conferences, which are less a starting point and more a set of finished pieces to take apart.

Getting the code and setting expectations

Getting the examples is a single shallow clone of the main branch:

git clone --depth 1 --branch main https://github.com/luxonis/oak-examples.git

The depth of one keeps the download small, which matters for a repository with a lot of media in it, and then you navigate into the application you want. Two practical points follow from the way the repository is built. First, these are examples rather than a supported API, so an example is a snapshot of how something was done with a particular DepthAI version, and when you copy one into a product you are taking on the maintenance of it yourself. Second, most of them need hardware, an OAK camera, and a few need particular firmware or a particular network setup, so the time you spend on a laptop without the device is time spent reading rather than running. The project publishes no GitHub releases, and the last push was on 2026-10-17, so the collection moves with the SDK rather than on a schedule of its own.

Editorial conclusion

The repository is worth cloning if you are building on DepthAI and OAK devices, because the streaming, camera control and depth examples save the days of setup that hardware usually costs, and the C++ category gives you a working host build and an on-device deployment path. It is the wrong place to look for a library to depend on, since nothing here is packaged, and it is the wrong place to look for a stable API, since the examples track a fast moving SDK. Before you start, check that the example you need matches the DepthAI version your device firmware expects, read EXAMPLE_AUTHORING.md if you plan to contribute one, and remember that the project publishes no releases, so the last push date of 2026-10-17 is your freshness signal.

Frequently asked questions

Official sources

1. Issues
2. License: Apache-2.0
3. luxonis/oak-examples on GitHub
4. README