After my first experiments with CaRadio, the project gradually reached the point where it was no longer just a prototype sitting on a desk, but a head unit I actually use in my car.
The system is still based on a Raspberry Pi running Linux. I added a Waveshare HDMI touchscreen and Carlinkit, which provides Apple CarPlay.
In everyday use, everything is quite simple: I get into the car, the phone connects automatically, CarPlay appears on the screen, I open Google Maps, start YouTube Music and drive.
But behind that familiar interface is still a completely DIY system.
Raspberry Pi and Linux
Raspberry Pi has been at the heart of CaRadio almost from the beginning.
It's a convenient platform for a project like this: it provides everything needed to connect a display, external devices and the car's electronics, while Linux gives me full control over how the system works.
That's one of the reasons I didn't use a ready-made Android head unit. I wanted to decide for myself how the system starts, what the interface looks like and what features can be added later.
The CaRadio application itself is written in C++ using SDL3 and runs directly on Linux.
Over time, however, it became clear that there wasn't much point in building my own navigation, music interface and full smartphone integration just to reproduce something that already exists.
CarPlay already provides all of that.
Waveshare Display
For the new version of CaRadio, I used a 7-inch Waveshare HDMI touchscreen with a resolution of 1024×600.
It's compact enough to install in a car while still providing enough screen space for both the CaRadio interface and CarPlay.
CaRadio has already covered several thousand kilometres with this display and has spent many hours running continuously in the car.
Real-world use has, of course, revealed some drawbacks. The main one is brightness. I would like it to be brighter in direct sunlight. I may replace the display eventually, but for now it does its job well enough.
Carlinkit and CarPlay
Carlinkit became the next part of the system.
It's a small USB dongle that the iPhone connects to. Carlinkit itself is connected to the Raspberry Pi and effectively acts as a bridge between the phone and my head unit.
Most of the development work on CaRadio was done with a wired connection. On the desk, that wasn't a problem at all: plug the phone in with a cable and start working.
But before installing CaRadio in the car, I started thinking about how inconvenient it would be to connect the phone with a cable every time I got in.
I wanted something different: start the car, let the phone connect automatically, wait for CarPlay to appear on the screen — and drive.
After changing my iPhone, there was another reason to find a different solution. The old Carlinkit still launched CarPlay with the new phone, but it stopped passing audio through.
I needed another solution.
U2W
That's how U2W entered the project.
When I bought it, I assumed it would simply replace the old Carlinkit and give me wireless CarPlay.
But after connecting it, I discovered that it worked in a completely different way.
U2W doesn't replace Carlinkit. It connects where the iPhone used to connect and, from Carlinkit's point of view, effectively behaves like a phone connected by cable. The real iPhone then connects wirelessly to U2W.
So instead of one device, I ended up with a chain of two:
Raspberry Pi → Carlinkit → U2W → iPhone
At first glance, the setup looks a little strange, but it solved both problems at once: the audio worked again, and I no longer had to connect the phone with a cable.
This is the configuration that eventually went into the car.
Now I just start the car and wait a moment. The phone connects automatically, CarPlay appears on the screen, and I can open navigation or start playing music.
The phone can stay in my pocket the entire time.
That was exactly the result I wanted.
From Prototype to a Working Head Unit
At this point, CaRadio finally stopped feeling like an experiment that existed mainly for the sake of developing it.
It became something convenient enough to use every day.
Of course, the project didn't end there. There are still issues with the display, integration with the car's electronics, the rear-view camera and plenty of other things to work on.
But I now have a working foundation around which the rest of the system can be built.
And U2W unexpectedly opened up another direction.
I bought it purely to get rid of the cable. But once I discovered that the device was effectively pretending to be a connected iPhone, I became curious about how it actually did that.
What happens after it's connected?
How does Carlinkit communicate with the software?
What data is exchanged between the devices?
And can its behaviour be reproduced independently?
From that point on, a straightforward CarPlay integration gradually turned into a very different kind of investigation.
But that's the next part of the story.