# OpenThread: Google's BSD-licensed Thread stack, and what it takes to build a network with it

> OpenThread is an open-source implementation of the Thread networking protocol, OS and platform agnostic, supporting both SoC and NCP designs. This article covers what the stack includes, how the repository is organised, and where the boundary between OpenThread and a working Thread network actually sits.

**openthread/openthread** — OpenThread released by Google is an open-source implementation of the Thread networking protocol.

- Repository: https://github.com/openthread/openthread
- Website: https://openthread.io
- Stars: 4,036 · Forks: 1,220
- Language: C++
- License: BSD-3-Clause
- Published: 2026-08-08 · Updated: 2026-08-18 · Language: en
- Canonical page: https://hysenlabs.com/projects/openthread-openthread

## What OpenThread actually is, and who the repository is for

OpenThread is not a product. It is an implementation of the Thread networking protocol, released by Google Nest so that the technology used in Nest products is available to other developers. The README states it is OS and platform agnostic, with a narrow platform abstraction layer and a small memory footprint, and that it supports both system-on-chip (SoC) and network co-processor (NCP) designs. That sentence defines the audience precisely: firmware engineers who have a radio and a microcontroller and need the Thread layers above them, not application developers looking for a smart-home SDK.

The scope of the implementation is spelled out in the same README. It is a Thread Certified Component implementing all features defined in the Thread 1.4.0 specification, including all Thread networking layers: IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, and Mesh Routing, plus device roles and Border Router support. The Border Router itself is not in this repository; the README links to openthread/ot-br-posix for that. This split matters more than it first appears, because most of the search traffic around OpenThread is about Border Routers, and the code for that lives somewhere else.

If you are deciding whether to adopt it, the honest framing is this: you are adopting a protocol stack and a porting surface. Everything above the stack, from commissioning UX to cloud connectivity to a Home Assistant integration, is your problem or another project's problem.

## The architecture: platform abstraction, SoC versus NCP, and where the RCP fits

The repository layout tells you how the abstraction is organised. Alongside src/, include/ and tests/, there is an examples/ directory containing apps/, config/ and platforms/. That is the porting surface: the stack lives in src/ and include/, and each supported radio platform has an entry under examples/platforms. The README describes a narrow platform abstraction layer, and the directory structure is consistent with that claim, since platform-specific code is kept out of the core and collected under examples.

The two design modes named in the README are SoC and NCP. In an SoC design, the Thread stack runs on the same chip as the radio. In an NCP design, the host processor runs the application and talks to a separate radio co-processor. The related searches show people also ask about RCP, the radio co-processor, and about RCP versus NCP. The README does not define those terms or explain the difference, so treat that as documentation you have to find at openthread.io rather than something the README settles.

What is confirmable from the repository is the breadth of platform support implied by the examples/platforms directory and by the long list of supporting companies in the README, which includes silicon vendors such as Nordic Semiconductor, NXP, Qorvo, Qualcomm, Silicon Labs, STMicroelectronics, Texas Instruments, Espressif and Telink, alongside Google, Samsung, Arm and others. That list is a support statement, not a compatibility guarantee, and the README does not map companies to specific example platforms.

## Where the build instructions actually live

The README does not contain install or build instructions, and it does not contain any commands. It states plainly that all end-user documentation and guides are located at openthread.io, and lists what you would go there for: learning about features, using OpenThread in products, building and configuring a Thread network, porting to a new platform, building an application on top of OpenThread, and certifying a product. So the honest answer to how you install this is that the repository points you to openthread.io, and the repository itself gives you the source tree and the examples.

What the repository does give you is a CMake-based build. CMakeLists.txt and CMakePresets.json sit at the top level, and examples/CMakeLists.txt plus examples/apps/ hold the sample applications. The exact preset names, target names and resulting binary names are defined in those files, not in the README, so read CMakePresets.json and the examples directory rather than trusting a command quoted from a third-party article. This is a case where the project's documentation site is the install path and the repository is the source of truth for build configuration.

For anything involving an actual radio, the path runs through examples/platforms. The README does not give per-platform build commands, and it does not document flashing or the RCP firmware build, so those steps have to come from openthread.io or from the platform vendor. If a tutorial gives you a specific flash command for OpenThread without naming the platform, it is not describing this repository.

## The Border Router is a separate repository, and that is the real limitation

The single most important constraint for anyone arriving from a smart-home search is that this repository is not the Border Router. The README links Border Router support to github.com/openthread/ot-br-posix. If your goal is a Thread border router for Home Assistant, this repository gives you the Thread stack that the border router is built on, not the border router itself. Searching for OpenThread and finding this repo is a common way to end up one layer below where you wanted to be.

The second limitation is documentation placement. The README is deliberately short and routes nearly everything to openthread.io, with a note that end-user documentation for users in China is available at openthread.google.cn. That is a reasonable choice for a project with a large documentation site, but it means the repository alone will not tell you how to configure a network, how to port to a new platform, or how to certify. Anyone evaluating OpenThread from the repository page without opening openthread.io will come away with an incomplete picture, and the gap is not a sign the project is undocumented; it is a sign the documentation lives elsewhere.

The third limitation is scope of support. The README lists many supporting companies and states the project is platform agnostic, but it does not enumerate supported example platforms in prose. Porting effort is therefore something you estimate from examples/platforms and from the platform abstraction layer, not from a compatibility table in the README.

## OpenThread compared with Zigbee and with Matter

People search for OpenThread versus Zigbee and OpenThread versus Matter, and the README answers only part of that. It positions OpenThread as an implementation of Thread, and Thread is a mesh networking protocol over IEEE 802.15.4, with IPv6 and 6LoWPAN named among the layers implemented. Zigbee is a different protocol stack, and the README does not compare the two, so any detailed comparison has to come from elsewhere. What can be said from this repository is that OpenThread's stated layer set is IP-based: IPv6, 6LoWPAN, IEEE 802.15.4 with MAC security, Mesh Link Establishment, Mesh Routing.

The Matter comparison is a category difference rather than a rivalry. Matter is an application-layer standard, and OpenThread is a network-layer implementation. The README does not mention Matter at all, so nothing in this repository tells you how the two combine. If you see a guide that treats them as alternatives, it is not reflecting this README.

There is also a question people ask about the difference between OpenThread and Thread itself. The README is clear on this: Thread is the protocol, defined by the Thread Group, and OpenThread is an open-source implementation of it that is a Thread Certified Component. Thread is a registered trademark of the Thread Group. That distinction explains the licence note at the bottom of the README: use the OpenThread name and marks only when accurately referencing this software distribution, and do not imply endorsement by or affiliation with Nest, Google, or The Thread Group.

## Licence, release cadence and the cost of staying current

OpenThread is released under the BSD 3-Clause licence, and the README points to the LICENSE file for details. BSD-3-Clause is permissive, which is why silicon vendors can ship it inside their SDKs. The one condition worth reading carefully is not a legal subtlety but a branding one: the README asks that the OpenThread name and marks be used only when accurately referencing this software distribution, and not in a way suggesting endorsement by or affiliation with Nest, Google, or The Thread Group. If your product page says it is powered by OpenThread, that statement needs to be accurate. This is not legal advice; read LICENSE and NOTICE in the repository and take your own counsel.

On maintenance, the repository is not archived, and the last push to main was on 2026-08-01. The release history shows a monthly cadence: v2026.06.0, v2026.07.0 and v2026.08.0, each tagged at the start of its month. That rhythm is the upgrade cost in practice. Vendors who ship OpenThread inside an SDK pin a version, and the SDK's release schedule, not OpenThread's, determines when you move. If you build from source against main, you are choosing the monthly cadence.

The repository also carries the machinery of a project that expects outside contributors: CONTRIBUTING.md, CODE_OF_CONDUCT.md, STYLE_GUIDE.md, SECURITY.md, a .clang-format and .clang-tidy configuration, and an AGENTS.md file at the top level. For a team planning to carry local patches, the style guide and clang configuration mean your patches will be held to a defined format, which is a real cost if you intend to upstream.

## Conclusion

Adopt OpenThread if you are building a Thread device or a Border Router and you want a Thread Certified Component implementing Thread 1.4.0 under BSD-3-Clause, with a narrow platform abstraction layer you can port. Do not adopt it expecting a finished consumer product: the repository ships the stack, examples and tests, while end-user documentation and product guides live at openthread.io, and the Border Router lives in the separate ot-br-posix repository. Verify two things before committing: that your chosen radio platform is already covered under examples/platforms, and that your certification path is clear, because the README points to openthread.io for certifying a product using OpenThread rather than describing it here. The last push to main was on 2026-08-01.

## FAQ

### What is OpenThread?

It is an open-source implementation of the Thread networking protocol, released by Google Nest, that is OS and platform agnostic and supports both SoC and NCP designs. It is a Thread Certified Component implementing the features defined in the Thread 1.4.0 specification.

### What is the difference between OpenThread and Thread?

Thread is the networking protocol defined by the Thread Group; OpenThread is an open-source implementation of that protocol. The README describes OpenThread as a Thread Certified Component that implements all features defined in the Thread 1.4.0 specification.

### What is the OpenThread Border Router?

Border Router support is part of what OpenThread implements, but the Border Router itself lives in a separate repository, openthread/ot-br-posix, which the README links to. This repository provides the Thread stack that the border router builds on.

### How do I install the OpenThread Border Router?

The README does not contain install or build instructions; it states that all end-user documentation and guides are at openthread.io, including how to build and configure a Thread network and how to port OpenThread to a new platform. The repository itself provides the source tree, a CMake build, and example applications under examples/apps/.

### What is an OpenThread RCP?

The README does not define RCP or explain how it differs from NCP, so this repository is silent on the distinction. What the README does state is that OpenThread supports both system-on-chip (SoC) and network co-processor (NCP) designs.

### How do I use OpenThread?

The README directs users to openthread.io for using OpenThread in products, building and configuring a Thread network, porting to a new platform, and building an application on top of it. In the repository, the starting points are the CMake build files at the top level and the example applications under examples/apps/ and examples/platforms/.

## Sources

- [Official documentation](https://openthread.io)
- [Official README](https://github.com/openthread/openthread#readme)
- [Project repository](https://github.com/openthread/openthread)
- [Release notes](https://github.com/openthread/openthread/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/openthread-openthread