Overview

Relevant source files

• doc/ot_api_doc.h
• include/openthread/BUILD.gn
• include/openthread/instance.h
• include/openthread/thread.h
• include/openthread/thread_ftd.h
• src/cli/README.md
• src/cli/cli.cpp
• src/cli/cli.hpp
• src/core/BUILD.gn
• src/core/CMakeLists.txt
• src/core/api/thread_api.cpp
• src/core/api/thread_ftd_api.cpp
• src/core/common/callback.hpp
• src/core/common/notifier.cpp
• src/core/common/notifier.hpp
• src/core/instance/instance.cpp
• src/core/instance/instance.hpp
• src/core/thread/child_table.cpp
• src/core/thread/child_table.hpp
• src/core/thread/mle.cpp
• src/core/thread/mle.hpp
• src/core/thread/mle_types.cpp
• src/core/thread/mle_types.hpp
• src/core/thread/router_table.cpp
• src/core/thread/router_table.hpp
• src/core/thread/thread_netif.cpp
• src/core/thread/thread_netif.hpp
• tests/scripts/thread-cert/border_router/test_publish_meshcop_service.py
• tests/scripts/thread-cert/node.py
• tests/unit/test_child.cpp
• tests/unit/test_child_table.cpp

Purpose and Scope

OpenThread is an open-source implementation of the Thread networking protocol. This page provides an architectural overview of the codebase, including the layered protocol stack, core subsystems (ot::Mle::Mle, ot::MeshForwarder, ot::Mac::Mac), device type variants (FTD/MTD/RCP), and application entry points (C API, CLI, NCP/Spinel).

Related pages:

• Device roles and network topology: Device Roles and Network Topology
• Core architecture patterns: Core Architecture and Component Organization
• Thread protocol layers: Thread Protocol Stack
• Application interfaces: Application Interfaces
• Border Router capabilities: Border Router Capabilities

What is OpenThread?

OpenThread is an open-source Thread networking protocol stack written in C++. The codebase is located at https://github.com/openthread/openthread and provides a complete implementation of Thread specifications from 1.1 through 1.4.

Repository Structure:

• src/core/ - Core protocol implementation (C++)
• include/openthread/ - Public C API headers
• src/cli/ - Command-line interface (ot::Cli::Interpreter)
• examples/platforms/ - Hardware platform abstraction layer
• tests/ - Unit tests, certification tests, simulation framework

Core Capabilities:

• Thread Protocol Versions - 1.1, 1.2, 1.3, 1.4 (configure via OPENTHREAD_CONFIG_THREAD_VERSION)
• Device Types - MTD (OPENTHREAD_MTD=1), FTD (OPENTHREAD_FTD=1), RCP (OPENTHREAD_RADIO=1)
• IPv6 Stack - ot::Ip6::Ip6, ot::Lowpan::Lowpan (6LoWPAN), ot::MeshForwarder
• Security - ot::Crypto::AesCcm, ot::KeyManager, ot::MeshCoP::SecureTransport
• Border Router - ot::BorderRouter::RoutingManager, ot::BorderRouter::InfraIf

The central abstraction is ot::Instance (defined in src/core/instance/instance.hpp380-520), which provides service locator access to all subsystems via Get<T>() methods.

Sources: include/openthread/instance.h1-180 src/core/instance/instance.hpp1-200 src/core/BUILD.gn1-300 src/core/CMakeLists.txt1-100

Thread Protocol Stack Overview

OpenThread implements the Thread protocol as a layered architecture, with each layer building upon the functionality of lower layers:

Thread Protocol Stack with Code Entities

Sources: src/core/thread/mle.cpp1-300 src/core/thread/mesh_forwarder.cpp1-200 src/core/net/ip6.cpp1-200 src/core/mac/mac.cpp1-200 src/core/thread/lowpan.cpp1-200 src/core/BUILD.gn29-280

Device Types and Roles

OpenThread supports multiple device configurations, each using a different subset of the protocol stack:

Device Type	Description	Key Components	Build Flag
MTD (Minimal Thread Device)	Sleepy end device, cannot route traffic	ot::Mle::Mle (child mode only), ot::Parent	OPENTHREAD_MTD=1
FTD (Full Thread Device)	Can operate as Child, Router, or Leader	ot::Mle::Mle, ot::RouterTable, ot::ChildTable, ot::MeshForwarder	OPENTHREAD_FTD=1
RCP (Radio Co-Processor)	Offloads MAC/Radio to separate processor	ot::Mac::Mac, ot::Mac::SubMac, Spinel protocol	OPENTHREAD_RADIO=1
Border Router	FTD with infrastructure integration	All FTD components + ot::BorderRouter::RoutingManager, ot::BorderRouter::InfraIf	OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE=1

Thread Device Roles (runtime state managed by ot::Mle::Mle::mRole):

• Disabled (kRoleDisabled) - Thread stack is disabled
• Detached (kRoleDetached) - Not participating in a network
• Child (kRoleChild) - Attached to a parent router, cannot route
• Router (kRoleRouter) - Routes traffic, maintains child table
• Leader (kRoleLeader) - Manages network data, router ID allocation

Sources: src/core/thread/mle.hpp244-291 include/openthread/thread.h76-85 src/core/thread/mle.cpp50-160

Core Architecture: The Instance and Service Locator Pattern

OpenThread uses a service locator pattern where all components access each other through a central ot::Instance object:

Instance and Service Locator Pattern

All components inherit from ot::InstanceLocator and use Get<T>() to access other components. This pattern:

• Eliminates circular dependencies
• Provides centralized component lifecycle management
• Enables easy component replacement for testing

Key Instance Methods:

• otInstance *otInstanceInit(void *aInstanceBuffer, size_t *aInstanceBufferSize) - Initialize instance include/openthread/instance.h87
• otInstance *otInstanceInitSingle(void) - Initialize single static instance include/openthread/instance.h99
• void otInstanceFinalize(otInstance *aInstance) - Shutdown and cleanup include/openthread/instance.h180
• template <typename Type> inline Type &Get(void) - Service locator access src/core/common/locator.hpp108-113

Key Classes:

• ot::Instance - Central service locator src/core/instance/instance.hpp380-520
• ot::InstanceLocator - Base class for all components src/core/common/locator.hpp60-120
• Component initialization: src/core/instance/instance.cpp48-150

Sources: src/core/instance/instance.hpp1-200 src/core/instance/instance.cpp1-150 include/openthread/instance.h1-180 src/core/common/locator.hpp60-120

Major Subsystems

MLE (Mesh Link Establishment) Protocol

ot::Mle::Mle is the core Thread protocol engine managing device roles, network attachment, and neighbor relationships.

Key State Variables:

• DeviceRole mRole - Current role: kRoleDisabled, kRoleDetached, kRoleChild, kRoleRouter, kRoleLeader src/core/thread/mle.hpp251
• Parent mParent - Parent router information src/core/thread/mle.hpp419
• uint16_t mRloc16 - Device's Routing Locator src/core/thread/mle.hpp497
• LeaderData mLeaderData - Network leader information src/core/thread/mle.hpp602

Key Methods:

• Error Start(StartMode aMode) - Start MLE protocol src/core/thread/mle.cpp194-222
• void Stop(StopMode aMode) - Stop MLE protocol src/core/thread/mle.cpp224-248
• void SetRole(DeviceRole aRole) - Change device role src/core/thread/mle.cpp297-358
• void SetStateChild(uint16_t aRloc16) - Transition to child state src/core/thread/mle.cpp608-650
• Error SendChildUpdateRequestToParent() - Send Child Update Request src/core/thread/mle.cpp1154-1230

Key Components:

• mAttacher - Handles network attachment process src/core/thread/mle.hpp70
• mDetacher - Handles graceful detach src/core/thread/mle.hpp71
• mDelayedSender - Queues delayed MLE messages src/core/thread/mle.hpp67
• mNeighborTable - Manages neighbor entries src/core/thread/mle.hpp66

Sources: src/core/thread/mle.cpp50-650 src/core/thread/mle.hpp121-700 src/core/thread/mle_types.hpp70-110

Router and Child Table Management (FTD Only)

ot::RouterTable and ot::ChildTable manage network topology for Full Thread Devices.

RouterTable src/core/thread/router_table.cpp:

• Array<Router, kMaxRouters> mRouters - Array of up to 64 router entries src/core/thread/router_table.hpp270
• RouterIdMap mRouterIdMap - Maps Router ID (0-62) to array index src/core/thread/router_table.hpp271
• Router *Allocate(void) - Allocate a new Router ID src/core/thread/router_table.cpp127-163
• void RemoveRouter(Router &aRouter) - Remove router from table src/core/thread/router_table.cpp101-124
• uint8_t mRouterIdSequence - Increments on topology changes src/core/thread/router_table.hpp274

ChildTable src/core/thread/child_table.cpp:

• Child mChildren[kMaxChildren] - Fixed array of child entries src/core/thread/child_table.hpp165
• Child *GetNewChild(void) - Find available slot for new child src/core/thread/child_table.cpp87-107
• uint16_t GetNumChildren(ChildState aState) - Count children by state src/core/thread/child_table.cpp49-62
• Maximum children configured via OPENTHREAD_CONFIG_MLE_MAX_CHILDREN src/core/thread/mle_types.hpp83

Sources: src/core/thread/router_table.cpp39-177 src/core/thread/router_table.hpp80-280 src/core/thread/child_table.cpp43-140 src/core/thread/child_table.hpp60-180

Mesh Forwarder

ot::MeshForwarder handles packet routing, queuing, and transmission.

Key Message Queues:

• MessageQueue mSendQueue - Outbound direct transmission queue src/core/thread/mesh_forwarder.hpp392
• MessageQueue mReassemblyList - Fragment reassembly tracking src/core/thread/mesh_forwarder.hpp394
• PriorityQueue mSendQueue (FTD) - Priority-based send queue src/core/thread/mesh_forwarder_ftd.cpp60
• IndirectSender mIndirectSender (FTD) - Queue for sleepy children src/core/thread/mesh_forwarder.hpp401

Key Methods:

• Error SendMessage(Message &aMessage) - Queue message for transmission src/core/thread/mesh_forwarder.cpp300-350
• void HandleReceivedFrame(Mac::RxFrame &aFrame) - Process received frame src/core/thread/mesh_forwarder.cpp600-700
• Error PrepareDataFrame(Mac::TxFrame &aFrame) - Build MAC frame src/core/thread/mesh_forwarder.cpp1100-1200
• Error SendEmptyFrame(Mac::TxFrame &aFrame, bool aAckRequest) - Send ACK or keepalive src/core/thread/mesh_forwarder.cpp950-1000

Sources: src/core/thread/mesh_forwarder.cpp1-500 src/core/thread/mesh_forwarder.hpp100-400 src/core/thread/mesh_forwarder_ftd.cpp1-100

Event Notification System

ot::Notifier provides event-driven state change notifications.

Event Types (defined in src/core/common/notifier.hpp60-100):

• kEventThreadRoleChanged - Device role transition
• kEventThreadNetdataChanged - Network Data updated
• kEventIp6AddressAdded / kEventIp6AddressRemoved - Address changes
• kEventThreadChildAdded / kEventThreadChildRemoved - Child table changes

Key Methods:

• void Signal(Event aEvent) - Signal single event src/core/common/notifier.cpp56-66
• void SignalIfFirst(Event aEvent) - Signal only if first occurrence src/core/common/notifier.cpp68-78
• Error RegisterCallback(Callback &aCallback) - Register listener src/core/common/notifier.cpp42-54
• otError otSetStateChangedCallback(otInstance *, otStateChangedCallback, void *) - External C API include/openthread/instance.h272

Notification Flow:

1. Component calls Get<Notifier>().Signal(kEventX)
2. Event added to mFlagsToSignal bitfield src/core/common/notifier.hpp180
3. Tasklet scheduled via mTask.Post() src/core/common/notifier.cpp60
4. Notifier::HandleStateChanged() invokes all registered callbacks src/core/common/notifier.cpp83-115

Sources: src/core/common/notifier.cpp42-150 src/core/common/notifier.hpp50-200 include/openthread/instance.h214-282

Thread Network Interface

ot::ThreadNetif manages Thread network interface lifecycle and address management.

Key Methods:

• void Up(void) - Bring up the Thread interface src/core/thread/thread_netif.cpp46-75

  • Enables ot::Mac::Mac via SetEnabled(true)
  • Starts ot::MeshForwarder via Start()
  • Enables ot::Mle::Mle via Enable()
  • Starts ot::Tmf::Agent, ot::Dns::ServiceDiscovery::Server, ot::Dns::Client
  • Subscribes to all-nodes multicast addresses

• void Down(void) - Take down the Thread interface src/core/thread/thread_netif.cpp78-106

  • Stops DNS client, DNS-SD server, TMF agent
  • Disables MLE via Disable()
  • Removes all external unicast addresses
  • Unsubscribes from multicast addresses
  • Stops mesh forwarder

State Variable:

• bool mIsUp - Tracks whether interface is up src/core/thread/thread_netif.hpp65

Sources: src/core/thread/thread_netif.cpp40-106 src/core/thread/thread_netif.hpp40-70

Application Entry Points

OpenThread provides three primary interfaces for applications:

Application Entry Points and Data Flow

1. C API (Programmatic Access)

The Public C API provides programmatic access to OpenThread functionality.

Thread Control Functions include/openthread/thread.h:

• otError otThreadSetEnabled(otInstance *aInstance, bool aEnabled) - Enable/disable Thread stack include/openthread/thread.h216-226
• uint32_t otThreadGetChildTimeout(otInstance *aInstance) - Get child timeout include/openthread/thread.h237
• otError otThreadSetLinkMode(otInstance *aInstance, otLinkModeConfig aConfig) - Set device mode include/openthread/thread.h253
• otDeviceRole otThreadGetDeviceRole(otInstance *aInstance) - Get current role include/openthread/thread.h233

Implementation Pattern: All C API functions follow the pattern:

// Public C API (include/openthread/thread.h)
otError otThreadSetEnabled(otInstance *aInstance, bool aEnabled);

// Implementation (src/core/api/thread_api.cpp:42-47)
otError otThreadSetEnabled(otInstance *aInstance, bool aEnabled) {
    return AsCoreType(aInstance).Get<Mle::Mle>().SetEnabled(aEnabled);
}

API Categories:

• thread_api.cpp - Thread network operations src/core/api/thread_api.cpp42-200
• instance_api.cpp - Instance management src/core/api/instance_api.cpp
• ip6_api.cpp - IPv6 operations src/core/api/ip6_api.cpp
• commissioner_api.cpp - Commissioner operations src/core/api/commissioner_api.cpp

Sources: include/openthread/thread.h1-250 src/core/api/thread_api.cpp1-200 include/openthread/instance.h1-180

2. CLI (Command-Line Interface)

The CLI (ot::Cli::Interpreter) provides interactive command-line control.

Command Processing Flow:

1. void ProcessLine(char *aLine) - Entry point for command string src/cli/cli.cpp295-371
2. Utils::CmdLineParser::ParseCmd(aLine, args, kMaxArgs) - Parse into arguments src/cli/cli.cpp311
3. ProcessCommand(Arg aArgs[]) - Dispatch to command handler src/cli/cli.cpp210-365
4. template <CommandId kCommandId> Error Process(Arg aArgs[]) - Execute specific command src/cli/cli.cpp194-261

Example Command Implementations:

• Process<Cmd("channel")>(Arg aArgs[]) - Get/set radio channel src/cli/cli.cpp
• Process<Cmd("thread")>(Arg aArgs[]) - Thread start/stop src/cli/cli.cpp
• Process<Cmd("state")>(Arg aArgs[]) - Get device role state src/cli/cli.cpp

Modular Sub-Commands:

• ot::Cli::Dataset - dataset command src/cli/cli_dataset.cpp
• ot::Cli::NetworkData - netdata command src/cli/cli_network_data.cpp
• ot::Cli::Br - br (Border Router) command src/cli/cli_br.cpp
• ot::Cli::Commissioner - commissioner command src/cli/cli_commissioner.cpp

User Command Extension:

• otError SetUserCommands(const otCliCommand *, uint8_t, void *) - Register custom commands src/cli/cli.cpp395-413

Sources: src/cli/cli.cpp76-413 src/cli/cli.hpp107-200 src/cli/README.md1-150

3. NCP/Spinel (Radio Co-Processor)

The NCP interface implements the Spinel protocol for host-RCP communication.

Spinel Protocol Basics:

• Frame Format: [Header(2 bytes)][Command(1-3 bytes)][Property ID(1-3 bytes)][Payload]
• Commands: SPINEL_CMD_PROP_VALUE_GET, SPINEL_CMD_PROP_VALUE_SET, SPINEL_CMD_PROP_VALUE_INSERT, SPINEL_CMD_PROP_VALUE_REMOVE
• Properties: Identified by constants like SPINEL_PROP_NET_IF_UP, SPINEL_PROP_NET_STATE, SPINEL_PROP_MAC_15_4_PANID

NCP Base Class (ot::Ncp::NcpBase) src/ncp/ncp_base.cpp:

• Error HandleCommand(uint8_t aHeader) - Dispatch Spinel commands src/ncp/ncp_base.cpp400-500
• Error HandlePropertyGet(uint8_t aHeader, spinel_prop_key_t aKey) - Handle GET request src/ncp/ncp_base.cpp600-700
• Error HandlePropertySet(uint8_t aHeader, spinel_prop_key_t aKey, const uint8_t *, uint16_t) - Handle SET request src/ncp/ncp_base.cpp800-900

Property Handler Example:

// Spinel property: SPINEL_PROP_NET_IF_UP
// Maps to: otIp6SetEnabled(GetInstance(), enabled)

Transport Layer:

• ot::Spinel::SpinelEncoder - Encode Spinel frames src/lib/spinel/spinel_encoder.cpp
• ot::Spinel::SpinelDecoder - Decode Spinel frames src/lib/spinel/spinel_decoder.cpp
• Platform callbacks: otPlatUartSend(), otPlatUartReceived() for UART transport

See Network Co-Processor (NCP) Architecture for detailed information.

Sources: src/ncp/ncp_base.cpp1-500 src/ncp/ncp_base.hpp1-200 src/lib/spinel/spinel.h1-200

Sources: src/cli/cli.cpp1-200 include/openthread/instance.h1-180 src/core/api/thread_api.cpp1-100

Build System and Configuration

OpenThread supports CMake, GN, and Automake build systems with extensive compile-time configuration.

Build Systems

CMake (primary) - CMakeLists.txt:

• Options: ot_option(OT_BORDER_ROUTER "enable Border Router" OFF) CMakeLists.txt50-150
• Set via: cmake -DOT_BORDER_ROUTER=ON
• Generates: libopenthread-ftd.a, libopenthread-mtd.a, ot-cli-ftd, etc.

GN (Generate Ninja) - BUILD.gn etc/gn/openthread.gni:

• Options: openthread_config_border_router_enable = false etc/gn/openthread.gni20-100
• Set via: gn args out --args='openthread_config_border_router_enable=true'

Automake - Makefile.am:

• Options: --enable-border-router, --enable-ftd, --enable-mtd

Configuration Layers

Configuration is applied through a hierarchy:

1. Build System Flags → OPENTHREAD_FTD=1, OPENTHREAD_MTD=1, OPENTHREAD_RADIO=1
2. CMake/GN Options → OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE=1
3. Project Config File → Define OPENTHREAD_PROJECT_CORE_CONFIG_FILE="project-config.h" src/core/BUILD.gn297-299
4. Core Config → src/core/config/ directory with feature-specific headers
5. Component Defaults → Each component's header file

Configuration Macro Examples src/core/BUILD.gn33-242:

• OPENTHREAD_CONFIG_THREAD_VERSION - Set Thread version (1.1, 1.2, 1.3, 1.4)
• OPENTHREAD_CONFIG_MLE_MAX_CHILDREN - Maximum children per router (default varies)
• OPENTHREAD_CONFIG_BORDER_ROUTING_ENABLE - Enable Border Router features
• OPENTHREAD_CONFIG_LOG_OUTPUT - Log output destination (none, debug_uart, app)

Build Targets

Target	Description	Build Flag
libopenthread-ftd	FTD core library	OPENTHREAD_FTD=1
libopenthread-mtd	MTD core library	OPENTHREAD_MTD=1
libopenthread-radio	RCP radio library	OPENTHREAD_RADIO=1
ot-cli-ftd	CLI with FTD stack	OPENTHREAD_FTD=1 + CLI
ot-cli-mtd	CLI with MTD stack	OPENTHREAD_MTD=1 + CLI
ot-rcp	Radio Co-Processor	OPENTHREAD_RADIO=1 + Spinel
ot-ncp-ftd	NCP with FTD stack	OPENTHREAD_FTD=1 + Spinel

Sources: src/core/BUILD.gn1-300 src/core/CMakeLists.txt1-280 etc/gn/openthread.gni1-150

Thread Network Lifecycle

A typical Thread device lifecycle managed by ot::Mle::Mle:

Thread Device State Machine

Key Role Transition Functions:

• void SetRole(DeviceRole aRole) - Core role change handler src/core/thread/mle.cpp297-358
• void SetStateDetached(void) - Transition to detached state src/core/thread/mle.cpp579-606
• void SetStateChild(uint16_t aRloc16) - Transition to child state src/core/thread/mle.cpp608-650
• void SetStateRouter(uint16_t aRloc16) - Transition to router state (FTD) src/core/thread/mle_router.cpp
• void SetStateLeader(uint16_t aRloc16) - Transition to leader state (FTD) src/core/thread/mle_router.cpp

Role Transition Triggers:

• Error Start(StartMode aMode) - Start MLE, begin attachment src/core/thread/mle.cpp194-222
• Error BecomeChild(void) - Initiate attach as child src/core/thread/mle.cpp551-562
• Error BecomeDetached(void) - Force detach from network src/core/thread/mle.cpp519-549
• Error BecomeRouter(ThreadStatusTlv::Status aStatus) - Upgrade to router (FTD) src/core/thread/mle_router.cpp
• Error BecomeLeader(void) - Upgrade to leader (FTD) src/core/thread/mle_router.cpp

Sources: src/core/thread/mle.cpp194-650 src/core/thread/mle.hpp244-299 include/openthread/thread.h76-85

Testing Infrastructure

OpenThread includes comprehensive testing infrastructure across multiple frameworks.

Unit Tests (GTest)

Location: tests/unit/ directory

Test Structure:

• Framework: Google Test (GTest) tests/unit/test_child.cpp1-50
• Execution: ./tests/unit/ot-test-core or ninja test
• Coverage: Component-level tests for core classes

Example Tests:

• test_child.cpp - Tests ot::Child class tests/unit/test_child.cpp1-300
• test_child_table.cpp - Tests ot::ChildTable class tests/unit/test_child_table.cpp1-400
• test_lowpan.cpp - Tests 6LoWPAN compression tests/unit/test_lowpan.cpp

Thread Certification Tests

Location: tests/scripts/thread-cert/ directory

Framework: Python-based test scripts using pexpect for CLI automation

Key Classes:

• Node - Represents a Thread device under test tests/scripts/thread-cert/node.py59-500
• OtbrDocker - Docker-based Border Router node tests/scripts/thread-cert/node.py59-267
• Test execution via ./script/test orchestrator

Example Test: tests/scripts/thread-cert/border_router/test_publish_meshcop_service.py

Simulation Framework

Virtual Time Support:

• Enable via OPENTHREAD_CONFIG_VIRTUAL_TIME=1 src/core/config/misc.h
• Synchronized time across simulated nodes
• Deterministic test execution

OTNS Integration:

• OpenThread Network Simulator (OTNS)
• Visual network topology and traffic analysis
• Workflow: .github/workflows/otns.yml

CI/CD Pipelines

GitHub Actions Workflows (.github/workflows/):

• build.yml - Multi-compiler, multi-platform builds
• simulation-1.2.yml, simulation-1.4.yml - Thread compliance tests
• posix.yml - POSIX platform tests
• otbr.yml - Border Router integration tests
• codeql.yml - Static analysis and security scanning
• size-tracking.yml - Binary size regression detection

Test Orchestration:

• Central script: ./script/test script/test
• Executes: build variants, unit tests, certification tests
• Generates: code coverage reports via lcov

Sources: tests/scripts/thread-cert/node.py1-500 tests/unit/test_child.cpp1-100 tests/unit/test_child_table.cpp1-100 tests/scripts/thread-cert/border_router/test_publish_meshcop_service.py1-150

Key Files Reference

Component	Key Files	Description
Instance	src/core/instance/instance.hpp src/core/instance/instance.cpp	Service locator and lifecycle
MLE	src/core/thread/mle.cpp src/core/thread/mle.hpp	Core protocol implementation
Router Table	src/core/thread/router_table.cpp src/core/thread/router_table.hpp	FTD routing (importance: 55.92)
Child Table	src/core/thread/child_table.cpp src/core/thread/child_table.hpp	FTD child management
Notifier	src/core/common/notifier.cpp src/core/common/notifier.hpp	Event system
Thread Netif	src/core/thread/thread_netif.cpp src/core/thread/thread_netif.hpp	Network interface
CLI	src/cli/cli.cpp src/cli/cli.hpp	Command-line interface (importance: 393.79)
C API	src/core/api/thread_api.cpp include/openthread/thread.h	Public API
Build	src/core/BUILD.gn src/core/CMakeLists.txt	Build configuration

Summary

OpenThread is a modular, standards-compliant Thread protocol stack organized around:

• A layered architecture (Application → Thread Network → MAC → Radio)
• A service locator pattern (ot::Instance) for component access
• Multiple device types (MTD, FTD, RCP, Border Router) sharing a common codebase
• Three application interfaces (C API, CLI, NCP/Spinel)
• Extensive configurability via CMake/GN options and preprocessor macros

The most actively developed subsystems are MLE protocol (importance: 619.97), CLI interface (importance: 393.79), and router management (importance: 55.92), reflecting the core functionality and user interaction points.

For detailed information on specific subsystems, continue to the linked sections above.

Sources: src/core/thread/mle.cpp1-160 src/core/instance/instance.hpp1-100 src/cli/cli.cpp1-200 src/core/BUILD.gn1-160