#003: Pebble's Code is Free: Three Former Pebble Engineers Discuss Why It's Important (PART 1/2)

02/11/25 • 49 min

In this episode of Coredump, three former Pebble engineers reunite to dive deep into the technical quirks, philosophies, and brilliant hacks behind Pebble OS. From crashing on purpose to building a single codebase that powered every watch, they share war stories, bugs, and what made Pebble’s firmware both rare and remarkable. If you love embedded systems, software-forward thinking, or startup grit— this one’s for you.

Key topics:

Pebble intentionally crashed devices to collect core dumps and improve reliability.
All Pebble devices ran on a single codebase, which simplified development and updates.
The open-sourcing of Pebble OS is a rare opportunity to study real, commercial firmware.
A platform mindset—supporting all devices and apps consistently—shaped major engineering decisions.
Pebble’s app sandbox isolated bad code without crashing the OS, improving developer experience.
The team built a custom NOR flash file system to overcome constraints in size and endurance.
Core dumps and analytics were essential for tracking bugs, deadlocks, and field issues.
Collaborations between hardware and firmware engineers led to better debugging tools and smoother development.

Chapters:

00:00 Episode Teasers & Intro01:10 Meet the Team: Pebble Engineers Reunite01:13 Meet the Hosts + Why Pebble Still Matters03:47 Why Open-Sourcing Pebble OS Is a Big Deal06:20 The Startup Firmware Mentality08:44 One OS, All Devices: Pebble’s Platform Bet12:30 App Compatibility and the KEMU Emulator14:51 Sandboxing, Syscalls, and Crashing with Grace20:25 Pebble File System: Built from Scratch (and Why)23:32 From Dumb to Smart: The Iterative Codebase Ethos26:09 Core Dumps: Crashing Is a Feature30:45 How Firmware Shaped Hardware Decisions33:56 Rust, Easter Eggs, and Favorite Bugs36:09 Wear-Level Failures, Security Exploits & Font Hacks39:42 Why We Chose WAF (and Regret Nothing?)42:41 What We’d Do Differently Next Time47:00 Final Q&A: Open Hardware, Protocols, and Part Two?

Join the Interrupt Slack ⁠⁠

⁠⁠Watch this episode on YouTube⁠⁠

Follow Memfault

Other ways to listen:

⁠⁠Visit our website

Key topics:

Pebble intentionally crashed devices to collect core dumps and improve reliability.
All Pebble devices ran on a single codebase, which simplified development and updates.
The open-sourcing of Pebble OS is a rare opportunity to study real, commercial firmware.
A platform mindset—supporting all devices and apps consistently—shaped major engineering decisions.
Pebble’s app sandbox isolated bad code without crashing the OS, improving developer experience.
The team built a custom NOR flash file system to overcome constraints in size and endurance.
Core dumps and analytics were essential for tracking bugs, deadlocks, and field issues.
Collaborations between hardware and firmware engineers led to better debugging tools and smoother development.

Chapters:

Join the Interrupt Slack ⁠⁠

⁠⁠Watch this episode on YouTube⁠⁠

Follow Memfault

Other ways to listen:

⁠⁠Visit our website

Previous Episode

#002: The secrets to building secure & scalable OTA infrastructure with Nick Sinas

In today’s Coredump Session, the team dives deep into the world of over-the-air (OTA) updates—why they matter, how they break, and what it takes to get them right. From horror stories involving IR updates in a snowstorm to best practices for deploying secure firmware across medical devices, this conversation covers the full stack of OTA: device, cloud, process, and people. It's equal parts cautionary tale and technical masterclass.

Key Takeaways:

OTA is essential for modern hardware—without it, even small bugs can require massive field operations.
Good OTA starts early, ideally at the product design and architecture phase.
Bootloaders, memory maps, and security keys must be carefully planned to avoid long-term issues.
Staged rollouts and cohorts help mitigate fleet-wide disasters.
Signing keys and root certificates should be treated like firmware—versioned, updatable, and secure.
Real-world constraints (medical, smart home, etc.) make OTA more complex—but not optional.
Testing both the update and the update mechanism itself is critical before going live.
When OTA fails, fallback plans (like dual banks or A/B slots) can be the difference between a patch and a catastrophe.

Chapters:

00:00 Episode Teasers & Intro

03:29 Meet the Guests + OTA Gut Reactions

05:33 Why OTA Is Non-Negotiable

03:29 The OTA Wake-Up Call: Why You Need It

09:31 Building OTA into Hardware from Day One

16:49 Cloud-Side OTA: Cohorts, Load, and Timing

21:53 OTA in Regulated Industries

30:10 When OTA Breaks Itself

34:44 Minimizing OTA Risk: The Defensive Playbook

41:18 OTA and the Matter Standard

47:17 Networking Stacks, Constraints, and Reliability

51:11 Security, Scale, and the OTA Future

⁠⁠⁠⁠Join the Interrupt Slack

Watch this episode on YouTube

Follow Memfault

Other ways to listen:

⁠⁠Visit our website

Next Episode

#004: The Future of Edge AI and What it Means for Device Makers

In today’s Coredump Session, we dive into the fast-evolving world of Edge AI and its real implications for device makers. From robots that detect humans to welding machines that hear errors, we explore the rise of intelligent features at the hardware level. The conversation spans practical tools, common developer traps, and why on-device AI might be the most underrated revolution in embedded systems today.

Key Takeaways:

Edge AI means real-time inference on embedded devices, not just “AI at the edge of the network.”
Privacy, latency, and power efficiency are core reasons to use Edge AI over cloud processing.
Hardware accelerators like the Cortex-M55 + U55 combo have unlocked GPU-like performance in microcontrollers.
Battery-powered AI devices are not only possible—they're already shipping.
Data collection and labeling are major bottlenecks, especially in real-world form factors.
Start projects with data acquisition firmware and plan ahead for memory, power, and future use cases.
Edge AI applications are expanding in healthcare, wearables, and consumer robotics.
Business models are shifting, with AI driving recurring revenue and service-based offerings for hardware products.

Chapters:

00:00 Episode Teasers & Intro02:57 What Is Edge AI Anyway?06:42 Tiny Models, Tiny Devices, Big Impact10:15 The Hardware Leap: From M4 to M55 + U5515:21 Real-World Use Cases: From ECGs to Welding Bots17:47 Spec’ing Your Hardware for AI24:15 Firmware + Inference Frameworks: How It Actually Works26:07 Why Data Is the Hard Part34:21 Where Edge AI Will—and Won’t—Take Off First37:40 Hybrid Edge + Cloud Models40:38 Business Model Shifts: AI as a Service44:20 Live Q&A: Compatibility, Labeling, On-Device Training56:48 Final Advice: Think of AI as Part of the Product

Join the Interrupt Slack

⁠⁠⁠Watch this episode on YouTube⁠

Follow Memfault

Other ways to listen:

⁠⁠Visit our website