STCPv2 is a secure transport architecture built to give applications one communication model across Linux, Raspberry Pi and Zephyr-based embedded systems. The design separates application protocols from platform-specific networking while keeping the transport implementation close to the operating system where appropriate.
STCPv2 is not an application protocol such as MQTT or CoAP. It is the secure transport layer underneath them. Applications can retain familiar communication semantics while STCP handles secure peer transport and platform-specific integration.
The Linux implementation integrates with the kernel socket layer as AF_STCP / PF_STCP = 45. The socket interface implements familiar operations including bind, listen, accept, connect, send and receive.
Protocol logic is implemented in a shared Rust core rather than duplicated for every target. Linux and Raspberry Pi use the kernel integration around that core, while embedded targets expose the same architecture through their platform layer.
Security belongs to the transport architecture instead of being added independently by every application. This lets higher-level protocols use one common secure communication substrate.
The STCP core is separated from the underlying carrier. Carrier implementations can map STCP traffic onto available network transports without changing the application-facing STCP model.
The STCP SDK is structured around a common API with target-specific platform implementations. The same SDK application is intended to build for x86 Linux, Raspberry Pi Linux and nRF9151 / Zephyr.
MQTT, CoAP and peer-to-peer software sit above STCP. They are consumers of the transport layer, not part of the transport itself, keeping application logic independent from platform networking details.
The architecture has a stable application-facing layer and isolates the parts that must differ between operating systems and embedded platforms. On Linux, STCP is exposed through the native socket subsystem; on embedded systems, the same protocol architecture is reached through the SDK platform implementation.
Native kernel module and AF_STCP socket API for development, profiling and production-style host testing.
Linux kernel integration using the same STCP architecture on an ARM64 edge platform.
Embedded implementation for constrained devices and cellular/IoT deployment scenarios.
On Linux, STCP behaves like a native networking facility rather than a userspace wrapper around an unrelated application API.
Applications use the Linux socket model. The STCP kernel module connects socket operations to the shared STCP core and maintains connection, accept and receive state.
The Rust core contains shared STCP behavior and is called by the platform integration for lifecycle, connection, send/receive and carrier processing operations.
Higher-level integrations demonstrate how existing application protocols can use STCP as their transport foundation.
Publish/subscribe communication for telemetry and command channels using STCP underneath the MQTT application layer.
Open MQTT integration →Constrained application messaging using the same STCP transport model and SDK architecture.
Open CoAP integration →Benchmark pages contain measured TCP, UDP, TLS and STCP datasets where available. Claims on this site are kept separate from future or planned work.
View benchmarks →