Exploring Uncut - December 6th, 2025

Introduction

I’ve had drafts of Exploring Uncut posts on my computer for months now. They contain bullet points of things I wanted to talk about, sometimes with additional notes, sometimes a draft of a few paragraphs. But as time went by, the potential post only became bigger and the time it would take me to finish it would only grow.

So here’s a new post focusing on what I’m working on right now. I’ll tackle those other topics when the time is right.

Mandelbrot

The goal

While preparing the talk I did at SwiftLeeds on Open-Source packages Apple offers, I wanted to find a nice use case for Swift Numerics. As it includes a module to handle complex numbers, I thought drawing a Mandelbrot set would fit nicely.

And as I also wanted to show the package could work on Embedded, I opened a PR to the Swift Numerics repository to ensure it would compile in that mode. Nothing major, disabling Codable and CustomDebugStringConvertible conformance under Embedded Swift.

Once this was done, I created a quick test to generate a Mandelbrot set based on the stm32-lcd-logo example from the swift-embedded-examples GitHub repository. It compiled just fine but when executing on my STM32F746G-DISCO board, it just crashed.

Investigating the issue

To investigate the issue, I worked on a minimal test case, starting from the stm32-uart-echo example.
In that test, I’m evaluating the sequence of the typical f(z) = z² + c function for only one given complex number and with a very limited number of iterations.

  let maxIterations: UInt8 = 5

  let c = Complex<Float>(-1.0, 1.0)
  var z = Complex<Float>.zero
  var iterations: UInt8 = 0

  while iterations < maxIterations && z.magnitude < 2.0 {
	z = z * z + c
	iterations += 1
  }
  print(iterations)

Before going into more details, let’s do the math manually. The sequence of values for z go like

As you can see, we get out of the loop as soon as iterations equals 3 because of the magnitude test.
Building and running the above code on the board worked fine and printed the value of 3.
But changing maxIterations to a bigger value, starting at 9, would make the program crash.

That left me scratching my head, in both cases, as we’ve seen above, the program should only go through the loop 3 times, as the condition on the magnitude would make it exit, not the condition on the number of iterations.
What I also observed was that the final application binary had different sizes based on that value. So the generated code was different.
I did take a quick look at the assembly but I need to take a refresher and learn ARM assembly. The last time I worked with assembly was in the previous century on 68k and x86 processors.
I tried several flags but could only make it crash more often, not make it work.

I posted about this on the “The Swift Programming Language” Discord server, in the embedded channel and after some back and forth, got an answer from CMD that, based on the assembly output, indicated I probably needed to initialize the FPU coprocessor.
This was confirmed soon after by Rauhul, pointing me to sample code for performing that.
And this fixed my problem. A huge thank you to both of them for the help.

Although I understand the reason for the crash and the fix, I’m at loss as to how to get there when faced with the initial problem.
I suppose learning ARM assembly and the tools to inspect a binary build and reading the ARM / STMicro technical documentation would help but that seems like a huge learning curve to get a simple example working.

On to the next one

Now that I had this fixed, I could proceed with my initial project, but it still crashed.
So back to the test snippet and I embedded the above calculation in a loop.

let maxIterations: UInt8 = 100

for _ in 0..<2 {
  let c = Complex<Float>(-1.0, 1.0)
  var z = Complex<Float>.zero
  var iterations: UInt8 = 0

  while iterations < maxIterations && z.magnitude < 2.0 {
	z = z * z + c
	iterations += 1
  }
  print(iterations)
}

And this crashes.

As said above, I’m again not sure where to start to investigate that problem.
I can change some bits of the code, maybe not use Swift Numerics and Complex types but do the math using only Float types.
And I’ll definitely read more on ARM assembly and technical literature on the board, as it anyway interests me to know more about that, but I think trying to get an actual debugger working with Embedded Swift and the different boards I’m using would be the bigger win.

The Egg Project

Background

In May 2025, Jony Ive and Sam Altman announced that io Products joined OpenAI.
The team is working on a new kind of product, incorporating OpenAI technology in a new form factor.
Not much is really known about it, just a lot of rumors.

In Episode 640, the ATP podcast team discussed the announcement at length and speculated on what the device could be.
Marco Arment was going for a watch while John Siracusa proposed a potato (or more specifically that if the product delivers on its features, it could be shaped like a potato and still be great).

In Episode 641 they reviewed information that was now available, mainly from the rumor mill.
That includes the fact that it’s not a phone, it’s not glasses, and Jony Ive was not keen on a wearable device. That device would probably have cameras and microphones for environmental detection.
And this is where the egg form factor idea came from.

After that first mention of the egg, I thought about creating such a device.
But the idea of creating a 3D printed egg with electronics fitted inside made me think it wasn’t an appropriate shape.
I then considered an “all-seeing eye pyramid” as both an easier shape to model and an appropriate symbol for a device that would capture your environment. And then I moved on.

But as I was listening to Episode 667, where they discussed the latest news (not much) and reiterated the egg idea, I thought “Why not?”.
And so that’s one more project on the list.

The project

I’ll disclose as much information on the project as io Products does 😉.
It’s an egg,
it uses Swift as much as possible,
and it’s fully open source.

You can find the repository on GitHub at The Egg Project.

Egg Modeler

The first step is to model an egg for 3D printing.

After a quick search, I discovered there was ample literature on the subject and many equations available to model an egg.
So I created a SwiftUI-based app to play around with different equations, their parameters, and come up with a shape I liked.
It can generate a 3D model using Cadova, a Swift library made for that purpose. I discovered it only a few weeks ago and used it for several small prints and I’m loving it. I’ll definitely dedicate a post to it.

As for the egg modelling equations, I based the math in that tool on The Universal Egg Equation and A “universal” formula for egg shape.

What’s next

The UI can certainly use a little more polish and the code a bit of cleaning.
But the main focus at this stage will be on the 3D model improvements, as it needs to be updated to support integrating the different electronic components.

Meta

Two pieces of news about Meta this week caught my attention.

The first is about Alan Dye leaving Apple for Meta. As reported by Bloomberg in Apple’s Top Designer Alan Dye Poached by Meta in Major Coup - Bloomberg.

From the Apple side, as discussed by the community (see Daring Fireball: Alan Dye Was in Tim Cook’s Blind Spot or ATP 668: So Happy for All Parties Involved — Accidental Tech Podcast), many people caring about the Apple platforms, myself included, consider this very good news.

Meta Platforms Inc. has poached Apple Inc.’s most prominent design executive in a major coup that underscores a push by the social networking giant into AI-equipped consumer devices.

From the Meta side, as this quote from Mark Gurman indicates, this is part of the push towards delivering AI-enabled consumer devices.

The second piece of news this week is about Meta acquiring Limitless (formerly known as Rewind), see Meta acquiring AI wearable company Limitless and the current home page of Limitless.

I first started looking into Rewind when they announced their initial product. A desktop application for macOS that would capture all the information you manipulate on your Mac, be it text or voice and allow you to search through it and chat with it using AI (much like what Microsoft wanted to do with Recall).
I signed up to test it, even got a Pro subscription for a while (through a free offer they ran), downloaded it but never installed it. Although the company was very open about the privacy measures in place, it still worried me.
And maybe I was right, because even if Rewind/Limitless was caring a lot about privacy, now that it’s part of Meta, I don’t know what would happen to my data.

I could not help but be cynical when I read part of the e-mail Dan Siroker, Limitless CEO, sent to all registered users.

Whether you choose to continue to use the Pendant or not, your data will remain safe. We just launched a feature to make it easy to export all of your data. And of course, if you want to delete all of your data, that is also very easy to do within the app.

Stating your data is safe but then immediately explaining how to export and delete your data in the same paragraph strikes me as deeply ironic (and suspicious, and worrying).

Looking at these two moves from Meta and renewed bits of (non-)information about the work of the io Products team, I am convinced we will see a few of those AI-powered consumer devices coming to the market.
After the Humane and Rabbit R1 fiascos, will this next iteration of such products be useful or will we need one (or more) other rounds ?
And will I trust any of them enough to give them a try ?
I don’t know, though certain safeguards like local AI models or end-to-end encryption could help.

Regardless of whether I’ll use them or not, I’m very keen to see what awaits us.