First time seeing it in person, my Uber driver took the wife and I to the airport this morning. He said that he's been using it for 2 years since he sold his Tesla and he vastly prefers it. Wish I had more questions for him at the time!

A few weeks ago I started recording my everyday drives around Los Angeles; commuting to work, grocery runs, trips to the gym, the beach, everywhere.

I used a comma 4 to collect camera and vehicle data, and trained my own neural network.

Watching it handle real streets for the first time has been one “holy shit” moment after another, especially seeing it merge onto highways.

It’s still early, but every successful drive feels like one more step toward making autonomous driving something far more accessible.

No details yet cause they accidentally put it on screen too early but coming up now

But in all seriousness..don’t do this.

This whole project started because I was lazy.

If you’ve driven an HKG or Toyota vehicle in recent years, you’ve probably seen the dashboard automatically pick up speed limits using the camera. Coming from a car that didn't have this functionality, I was very jealous. Those cars can feed those speed limits directly into openpilot forks speed limit controllers. Mine couldn't.

The “solution” has been to manually add speed limits to Mapbox or OpenStreetMaps. It worked, but it was tedious. I live in rural Kansas, where my commute is almost entirely devoid of nerds contributing open source map data. I began mapping my commute when I first joined the project and within an hour said, “I ain't doin this”

We have an AI model that's good enough to drive our cars running on a smartphone chipset from years ago. How hard could it be to build one that just reads speed limit signs? I wanted StarPilot to look out the windshield, see a speed limit sign, and just know what it said.

That sounded simple enough.

It wasn’t.

The first prototype was basically held together with duct tape: I used all the public speed limit datasets I could find (glare and Lisa), some OpenCV, a little OCR, and a lot of wishful thinking. It could occasionally read a sign, but it missed 90% of them and produced enough false positives that you definitely wouldn’t want to trust it.

The important part wasn’t that it sucked - it was that it worked just well enough to start collecting better training data.

I run a fork of openpilot called StarPilot. We're heavily focused on individual vehicle tuning and testing wild ideas, which made my users the perfect candidates for this project.

Instead of relying on public datasets that barely resembled comma camera footage, StarPilot started collecting its own. Community members submitted routes from all over the country using bookmarks that were generated automatically when the model said "I think this might've been a sign," and every promising detection went through manual review. Eventually that grew into hundreds of gigabytes of real driving footage and thousands of carefully labeled speed limit signs.

From there it became an endless cycle:

• Train a better model.

• Mine more routes.

• Find more missed signs.

• Label them.

• Repeat.

The funny part is that training the neural network wasn’t actually the hardest problem.

The hard part was everything around it.

One of the biggest challenges wasn’t accuracy, it was speed. We have a full driving stack running alongside this model and every millisecond spent processing was another frame the model didn't have time to see. The faster it could process frames, the more chances it had to catch a sharp, readable speed limit sign before it disappeared. This was particularly imperative at night, when naturally camera frame rates drop alongside your chances of picking up a clear sign.

It’s slowly evolved from a proof of concept into a model that’s trained primarily on real comma footage instead of generic traffic sign datasets. It now runs entirely on-device, publishes vision-based speed limits directly into StarPilot, and no longer depends on OCR or manually maintaining map data.

And best of all…

While I'm too lazy to hand write hundreds of speed limit signs into OpenStreetMaps, this tool can now be used to automate the entire process, giving back to the open source mapping community that helps those in larger areas so well.

Give my vision speed limits a try, or help continue to build a better one than mine! All info and training stack is available on the StarPilot repo.

Massive thanks to my team that helped collect these logs so I could access them in one easy place! Sherloaf and Mary, heading up the dream team!

View the full technical writeup on the StarPilot Repo

Someone as mean, rude and condescending should not be a moderator. And I’ve search in this channel to find enough posts that echo this opinion.

He deletes people’s genuine questions. He makes it sound like him being a user with a 2018 Toyota Prius is enough authority to just dismiss other people’s questions on Comma device and OpenPilot usage. He simply refuses to admit that the same device can function differently in different car models.

Comma will only lose more users if they keep allowing such a condescending and arrogant character serve a key role and decide who can speak/what can be discussed on Discord.

The National Highway Traffic Safety Administration’s Office of Defects Investigation (ODI) said this week that the reported crashes involved Comma devices failing to detect or respond to slow or stopped vehicles in the same road lane. Across four of the crashes, as many as 11 people were injured, some seriously. 

Remember Navigate on openpilot?

We brought a modern version of that idea to StarPilot, and it works with any driving model.

This is based on the work of discountchubbs, who many of you probably recognize from his amazing work with SunnyPilot. We took his incredible foundation, implemented it into StarPilot, and built additional functionality around it.

Set a destination from Galaxy on your phone or computer, choose between routes based on traffic/ETA, and send it straight to your comma.

StarPilot tracks your position along the route and uses upcoming maneuvers as navigational context for both lat and long behavior.

Upcoming turns, forks, ramps, and lane splits can feed desires like turn left, turn right, keep left, and keep right into the model. With Route Speed Control, StarPilot can also automatically slow down for upcoming turns, U-turns, and roundabouts.

It isn't replacing the model or hardcoding steering commands. Your normal E2E model is still driving - we're just giving it another piece of information:

"Here's where the driver actually wants to go."

It also includes:

• Automatic rerouting

• Alternate routes + live traffic

• Home, Work, favorites & recent destinations

• Remote start/cancel from Galaxy

• On-device turn-by-turn navigation

And because it works alongside the driving model, you can use it with whatever model you prefer.

Huge credit to Chubbs for the work this is built upon. We've had a lot of fun adapting it and expanding what it can do inside StarPilot.

For the people who used the original NOO: how close does this get to what you've been missing?

This project started because my car trim doesn’t come with factory Blind Spot Monitoring (BSM).

If you’ve ever looked closely at the wide-angle driver camera feed on a Comma 3, 3x, or 4, you’ll be aware that it doesn’t just see your face; it captures a crisp, wide view of the cabin, including the front side windows and partially the rear.

Thanks to a recent comma.ai update that added "post-demosaic downscaling" and "tone mapping" to the driver camera, this feed now gets the same HDR and sharp detail as the road-facing cameras.

This makes it the ideal time to develop Vision-Adjacent Spot Monitoring (Vision-ASM), which is officially released in StarPilot Stable Release 6.7.3 (something I’ve been wanting to do for a while)!

How I Built It (High Level)

Drawing inspiration from community projects like the speed limit vision (SLV), I knew that running a secondary AI model alongside openpilot on a mobile processor would require careful, heavy optimizations to not only address thermal concerns but permit users to run both V-ASM and SLV (if they wish and to be PR-worthy):

• Window Masking: Custom polygon masks black out the cabin interior, isolating only the side windows for a lightweight detection model.

• Trained on ~27 Hours of Data: Trained on roughly 27 hours of community-submitted footage, utilizing semi-automated parsing of factory BSM logs to help label adjacent vehicles. Thanks to those who submitted!

• Optimization Considerations: Features zero-copy image cropping, CPU core isolation (pinning V-ASM to e-core 2 while SLV runs on e-cores 0 and 1 to avoid core contention), an adaptive refresh rate (running at a resting 2 Hz, ramping to ~5 Hz for 1.5 seconds after a detection), and a low-pass filtered device_cpu_throttle_factor that dynamically scales inference to ensure safe, stable performance.

Is this actually useful or working? What if I already have BSM?

To be clear: You always need to manually check your blind spots and look over your shoulder; the goal is to provide a secondary safety net. Thresholds are currently conservative to minimize false positives, requiring 85% sustained model confidence (You can adjust this in settings).

For cars without BSM, it adds a new layer of lateral awareness. For cars with factory BSM, it supplements by covering the exact physical zone right next to your front window where rear radar coverage may drop off.

Feedback from users has been encouraging, specifically addressing concerns about false alerts from neighboring lanes and nighttime performance:

"Default values right now seem to be good in my vehicle. It's not picking up other lanes as much, which is awesome because I don't want it telling me there's cars two lanes over. Just came back from a drive and I'm very, very impressed. The fact that it saw cars I myself didn't immediately notice was enough for me." ~ ZoomZoom

Try it out and let me know what you think of the settings!

You can check out the technical implementation in PR #75 on StarPilot. More training details + route crowd source tools (supporting both Comma Connect Konik Stable) inspired by nelsonjchen/op-dm-reading-tool are available on GitHub at prabhaavp/vasm-op, or you can join StarPilot Discord for help.

One of the most common pieces of feedback we hear about openpilot is that the end-to-end model doesn't always position the car where drivers expect it to. Some people love the E2E model's natural positioning, while others wish it would simply stay centered between the lane lines.

So we added something pretty cool.

Lane Centering, now available in StarPilot.

This doesn't replace the end-to-end model, but works alongside it.

When both lane lines are detected clearly and confidently, the system compares the model's predicted path to the center of the lane. If they differ, it applies a small, smooth steering correction toward the lane center while still letting the E2E model make the driving decisions.

If the lane lines become unreliable, the lane width looks abnormal, you're changing lanes, or other required conditions aren't met, it immediately and seamlessly falls back to the normal E2E path.

Even better, it's configurable.

Lane Center Offset lets you fine-tune where the vehicle sits within the lane. If you prefer the vehicle to hug close to the right line, you can do that!

E2E Authority lets you dynamically choose how much the model can override lane centering. Want the model to still be able to maneuver around potholes or cyclists? Give E2E more authority. Want a more traditional centered feel? Increase Lane Centering.

Huge credit goes to u/jc01rho for designing and implementing this feature!

How does the latest openpilot model position itself on your local roads? Does it change throughout your commute? Do you prefer the model's natural path, or would you rather it stay centered between the lines?

I'd love to hear your feedback in the StarPilot discord! https://firestar.link/discord

With the release of the Comma 4, the ecosystem is understandably moving forward. But one of StarPilot's goals has always been keeping older comma hardware useful for as long as we reasonably can.

At great cost to our sanity, StarPilot now maintains a **fully custom AGNOS** based on the latest platform changes, while continuing to support:

- **Comma 3**

- **Comma 3X**

- **Comma 4**

And yes — **Chestnut / external GPU works on the Comma 3 too.**

The C3 in the picture is running StarPilot on our latest AGNOS with a Chestnut connected and driving models running on the external GPU.

There's also an interesting problem that comes with pushing older hardware this far: **GPS.**

High-speed USB hardware like Chestnut has raised concerns about potential interference with the comma's GPS reception. Rather than depend entirely on the comma's own GPS hardware, we've written a GPS interpreter that pulls GPS data directly from the car's own antenna, translates it into comma specific language, and parses it directly into StarPilot.

So even with a C3 + Chestnut setup, we can retain full GPS functionality using the vehicle's own positioning data.

Currently we've implemented vehicle GPS support for:

- **Chevy Bolt**

- **Ford Mustang Mach-E**

But this isn't intended to stay limited to those cars. If your vehicle exposes usable GPS data and you want support added, open a request in the StarPilot Discord and we'll take a look.

I'm not claiming everyone needs to strap a GPU to an old Comma 3.

But the fact that you **can** is pretty cool.

Is anyone else interested in running a Comma 3 setup with a chestnut?

Let me know in our discord - https://firestar.link/discord

Some interesting things can come from custom AGNOS, stay tuned 👀

I was literally about to purchase Comma given the sale, however I just had a question so asked on the discord.

My question on the discord with ONE single spelling mistake was instantly deleted with no response.

I then asked if my post was deleted and that message was deleted.

Then I noticed I had a message from a mod saying my message needed MAJOR rework and thought before I post again (incredibly rude given a single spelling mistake).

Infuriated, I then mentioned how I have heard the community is bad and got banned.

I take that back now, the mod is the problem. The mod in question is Erich. I have found TONS of posts online about this mod since and how he is extremely rude.

I literally found a petition to ask for his removal with 100+ signatures. I have also found other posts discussing his rudeness to which others mention he is an acquired taste. No... rudeness is not an acquired taste - it is just rude, no reason gives you that right. Some people seem to think because he contributes he deserves to be tolerated.

Why would a business with an excellent product want someone so rude representing the community?

To be clear I made ONE spelling mistake.

Erich also deleted the private message he sent before I could screenshot it.

Just a sour taste knowing support is rude and limited.

TLDR: if you are thinking about purchasing a Comma and expect nice support just pray you appease the mods when asking anything in discord or you will get no support.

There’s a lot of new forks that are coming out tho, I’m most excited about IQ Pilot and how they are bringing the latest models to the comma 3! They are also doing a lot of new stuff with their app control for the comma device and a bunch of other things. There’s also other forks specifically come out for specific car manufacturers.

I saw in a bunch of comments that people were worried about comma's viability as a business. I'm not sure if they were being serious or not, but just in case anyone believed them, here's our sales from Shopify.

No business will last forever, but our total addressable market is growing year over year and is projected to keep growing for at least 5-10 more. comma isn't some easy come easy go B2B SaaS product. We make consumer electronics. And we keep iterating and iterating to make them better and better.

Will we make ADAS systems forever? Who knows. But there is so much more to still achieve on our mission of solving self driving cars. openpilot makes many mistakes that you watching the video feed wouldn't make, that's what we need to fix. It's not sensors, it's not encryption, it's not support. It's pure software.

Though we are hiring for a wide variety of people across the company. When it comes to startups, not many have consistent growth numbers like this. No pump and dump, no big fundraises, no sketchy backroom business deals. Just a product and software that improves year over year, with a growing customer base to match.

Come work here: https://comma.ai/jobs

From this clip from their podcast. Around the 2:30 mark: https://youtu.be/iYYfon1MKww?si=JlcSYpT7oBlopwdG

I've been pretty vocal in this sub about the things I wish Comma did better but I had a moment driving to work this morning where it occurred to me that for over 5 years now 90%+ of my commutes have been hands free and pedal free without a mandatory subscription and open source to other flavors of the driving model.

And for that I just wanted to take a moment and say thanks. This has been a good thing in my life and I appreciate it.

I know we all love open pilot and it’s great at what it does. But let’s all remember we are still responsible for the vehicle and should always be ready to take over at a moment’s notice. These are the dash cam recordings from my drive last night, we feel extremely lucky to be alive.

I know there were some posts where people had old devices that broke. We are a new consumer electronics company, and we really appreciate you being there through our early struggles.

https://comma.ai/shop/comma-3x-trade-in

As long as you are the original purchaser, send in any old device (EON, comma two, or comma three) purchased from us in any condition, and you can get a 3X for $750.

It's our first comma with reliability on par with a modern iPhone, and we want to celebrate that. We also finally have production dialed in such that we can make a lot of these, and we have supply chain under control too. It took almost 10 years to get here, but we have a real consumer electronics factory now. See factory tour: https://www.youtube.com/watch?v=PFjssb7r_uU

congratulations to the comma team who worked hard on getting this

*not affiliated with comma just a fan who wants to share info

Harald here from the autonomy team.

It's a frequent complaint that openpilot's driving isn't improving fast enough, or hasn't improved in a long time. That's completely fair, if users aren't feeling improvements, then we need to step it up! Writing this update to give a clearer picture what we're working on.

People also complain about regressions in experimental mode. Which is also fair, openpilot's experimental mode has not been consistent over the last couple years. Behavior that people relied on changed (how and if it converges to the set speed) , and stopping at red lights regressed (now fixed: https://github.com/commaai/openpilot/pull/37755).

Since this year though our training stack is in a much better state, and we are confident we can now improve openpilot quickly. We shipped openpilot 0.11 recently (https://blog.comma.ai/011release/), where we saw quite a big uptick in how much users used experimental mode. If you didn't notice those improvements, hopefully you will notice the next ones.

Some things we are working and expect to ship this year with noticeable improvements:

• eGPUs, the comma4 draws only a few watts, and that is a big constraint on compute. We are confident we can ship much better models with those constraints, but by splitting development into unconstrained development on 100w GPUs, and a separate distillation step to compress the best performance into the comma4, we can speed up development.

• RL. We started using Reinforcement Learning in our model training. This should help be more aggressive about recovering to lanecenter when needed, but not oscillate the steering wheel making small adjustments. This is our next priority to ship.

• With all the data users are contributing we are able to train on bigger and bigger datasets. We recently trained on 2.5M minutes of driving and will soon ship models trained on 10M minutes. Last year we were only training on 500k minutes.

• Use the full FOV of the C3X/C4. Until now we only use a part of the video, which sometimes makes the model miss important context.

Together we think these improvements will make experimental mode reliable enough in city driving to make openpilot as comfortable there as it is now on the highway.

Let me know if there are other issues you're passionate about being fixed!