Pigweed Embedded Libraries: Google’s Open Source

Yes, Google open-sourced Pigweed, a collection of embedded libraries and tools designed to make microcontroller development more productive and reliable. You can find it on GitHub under the Apache 2.0 license, and it’s actively maintained by Google and contributors. Pigweed focuses on modularity, allowing you to use only the pieces you need, and it brings modern software practices like unit testing, logging, and build system integration to resource-constrained devices.

What Is Pigweed Exactly?

Pigweed is not a single library or an operating system; it’s an ecosystem of independent modules. Each module addresses a common pain point in embedded development, from low-level hardware abstraction to host-side tooling. The name comes from the idea that small, fast-growing plants (like pigweed) can thrive in harsh environments—much like these libraries are designed for the constrained world of microcontrollers.

Originally developed internally at Google for use in products like the Google Nest Hub and other consumer devices, Pigweed was publicly released in 2020. Since then, it has grown to include over 60 modules, each with its own documentation and examples. The project’s philosophy is to provide production-ready code that you can adopt incrementally, without forcing you to rewrite your entire codebase.

Key Modules and What They Do

Pigweed’s power lies in its modular design. Here are some of the most commonly used modules and their purposes:

• pw_unit_test: A lightweight unit testing framework designed for embedded targets. It runs on both host and device, making it easy to test logic without hardware.
• pw_log: A flexible logging system with compile-time filtering. You can adjust log levels per module, and it works even when space is tight.
• pw_assert: A robust assertion library that provides detailed failure messages without bloating your binary.
• pw_protobuf: A code generator and runtime for Protocol Buffers, optimized for memory-constrained devices. It’s much smaller than the standard protobuf implementation.
• pw_rpc: A remote procedure call framework that lets you communicate with a device over serial, BLE, or other transports. It’s often paired with pw_console for debugging.
• pw_console: A Python-based terminal UI that gives you a rich interface for interacting with devices—think logs, RPC calls, and even a Python REPL.
• pw_watch: A build helper that watches your source files, rebuilds on changes, and runs tests automatically. It’s a huge time-saver during development.

These modules are just the tip of the iceberg. There are also modules for tokenized strings, memory allocation, CRC computation, and more. You can mix and match them freely.

How Pigweed Works: Build System and Tooling

Pigweed is built around the GN (Generate Ninja) build system, which is also used by Chromium and Fuchsia. GN generates Ninja build files, which are fast and efficient for large projects. However, Pigweed also provides CMake support for those who prefer a more traditional workflow. The project includes a Python-based toolchain that handles cross-compilation for many common architectures like ARM Cortex-M, RISC-V, and x86.

One of the standout features is the pw_watch tool. You run it once, and it continuously rebuilds and runs tests whenever you save a file. This immediate feedback loop is something many embedded developers aren’t used to, but it dramatically speeds up iteration. Additionally, pw_console gives you a rich terminal interface to connect to your device via serial, view logs, and even invoke RPC calls—all without leaving your terminal.

For debugging, Pigweed integrates with OpenOCD and J-Link, allowing you to flash and debug from the command line. There’s also pw_ide, a module that generates configuration files for VS Code or other IDEs, so you get IntelliSense and debugging support out of the box.

When to Use Pigweed (and When Not To)

Pigweed shines in several scenarios, but it’s not a one-size-fits-all solution. Here’s a quick guide:

• Use it if: You’re starting a new embedded project and want a modern development experience with strong testing and debugging support. You’re working with a supported MCU (like STM32, nRF52, ESP32) and you’re comfortable with the GN build system (or willing to learn).
• Use it if: You need to implement RPC or Protocol Buffers on a device with limited RAM/Flash. Pigweed’s implementations are significantly smaller than alternatives.
• Avoid it if: Your project is a tiny 8-bit MCU (like an ATmega328P) with just a few KB of RAM. Pigweed is designed for 32-bit ARM and RISC-V cores with at least 16KB of RAM—though some modules can work on smaller, it’s not the sweet spot.
• Avoid it if: You’re maintaining a legacy codebase with a custom build system. Pigweed can be integrated incrementally, but it’s easiest when you adopt its build system from the start.

If you’re just experimenting or making a simple hobby project, the learning curve might not be worth it. But for professional product development, Pigweed can save you a lot of time and headaches.

Common Problems and Misconceptions

One common misconception is that Pigweed is an RTOS (Real-Time Operating System). It’s not. It works alongside any RTOS (like FreeRTOS, Zephyr, or bare metal). You can use Pigweed’s logging and assertion modules with your existing scheduler.

Another issue newcomers face is the build system. GN is not as widely known as CMake, so there’s a learning curve. However, the documentation is thorough, and the project provides many examples to get you started. If you run into trouble, the community is active on the Pigweed Discord and mailing list.

Some users complain that Pigweed’s Python tooling requires a specific Python version (3.8+). This can be a hassle if your system has an older version, but you can use a virtual environment. Also, because Pigweed is evolving quickly, APIs can change between releases. It’s wise to pin a specific version if you’re building a product.

Alternatives to Pigweed

Pigweed is not the only option for modern embedded development. Here are some alternatives, each with its own strengths:

• Zephyr RTOS: A full-featured RTOS with a rich ecosystem. It includes its own logging, shell, and device model. If you need a full OS, Zephyr is a strong choice, but it’s heavier than Pigweed.
• FreeRTOS: The most popular RTOS, but it’s just a kernel—you’ll need to bring your own libraries for logging, testing, etc. Pigweed can complement FreeRTOS.
• PlatformIO: An IDE and build system that supports many platforms. It’s easier to set up than Pigweed, but it doesn’t provide the same level of embedded-specific tooling (like RPC or tokenized logging).
• Mbed OS: An RTOS and HAL from Arm. It’s user-friendly but has a larger footprint and is less modular.

If you’re looking for a lightweight, modular set of libraries that you can integrate into any project, Pigweed is unique. If you want a complete OS, Zephyr or Mbed might be better.

Getting Started with Pigweed

To start using Pigweed, you’ll need to set up your environment. Here’s a high-level overview:

1. Install dependencies: Python 3.8+, Git, and a compatible compiler (like GCC for ARM).
2. Clone the repository: git clone https://pigweed.googlesource.com/pigweed/pigweed (or the GitHub mirror).
3. Bootstrap the environment: Run . bootstrap.sh (or bootstrap.bat on Windows). This downloads the toolchain and sets up a virtual environment.
4. Build an example: Navigate to examples/hello_world and run pw watch to build and run tests.
5. Explore the docs: The official documentation at pigweed.dev has guides for each module, plus tutorials for common boards like the STM32F429 Discovery.

If you’re using a board that’s not officially supported, you may need to write a small target file that defines the linker script and startup code. The community has contributed support for many boards, so check the existing targets first.

Frequently Asked Questions

Is Pigweed free to use? Yes, Pigweed is open source under the Apache 2.0 license, which allows commercial use, modification, and distribution with attribution. You can use it in proprietary products without paying royalties.

Does Pigweed support my microcontroller? Pigweed is architecture-agnostic, but the provided toolchain supports ARM Cortex-M, RISC-V, and x86. For specific boards, you may need to write a target file. The community has added support for many popular boards like STM32, nRF52, and ESP32, but not all are officially tested.

Can I use Pigweed with an RTOS? Absolutely. Pigweed is designed to be RTOS-agnostic. It works with bare metal, FreeRTOS, Zephyr, and others. You just need to provide a few hooks for the modules that need them (like pw_chrono for time).

Is Pigweed production-ready? Yes, many modules are used in production at Google and other companies. However, the project is still evolving, and some modules are marked as experimental. Check the module’s documentation for its status.

How does Pigweed compare to Zephyr? Zephyr is a full RTOS with a kernel, while Pigweed is a set of libraries. You can use them together. Zephyr gives you scheduling and device drivers, while Pigweed provides better tooling for testing, logging, and RPC. If you need an OS, Zephyr is the way to go; if you want to keep your code lightweight, Pigweed is a better fit.

What programming languages does Pigweed support? The core libraries are written in C++17, but there are also Python modules for host-side tools. The RPC system supports C++ and Python, and there’s experimental support for other languages like Rust.

Related

• Home Assistant Update Fear: The One Rule That Fixes It
• KDE Tiling Extension: Does It Make KDE a WM?
• MKV Converter: What It Does and How to Use One