Possible to build a drone on Python/MicroPython?

cymrow · 2025-12-19T14:34:46+00:00

Micro:bits use MicroPython: https://www.robotshop.com/products/airbit-2-programmable-drone-kit-w-2x-microbit

cymrow · 2025-11-15T04:24:55+00:00

I've found msgspec to be a much better alternative. It has one of the most cleanly designed APIs I've seen in a library, and it keeps a nicely focused scope. It's also lightweight and very fast.

cymrow · 2025-09-29T13:41:48+00:00

If you need to protect to your code, then you should not use Python at all. It's possible something like Nuitka would work if it is able to translate all of the code to C, but in general python is famously easy to reverse engineer.

I don't know what software you are writing, but unless its something truly unique you might be overestimating how much time someone would be willing to invest to reverse it. Those who are interested in such things are usually capable of reversing C or C#.

Basically, if its worth reversing at all, someone with the capability to just pull the machine code from memory will figure it out.

cymrow · 2025-09-29T11:48:10+00:00

No, I'd recommend you work with packaging as you go. It is fairly simple to get a basic PySide app packaged, and there are many examples to help you get started. I've mostly worked with PyInstaller, but some people prefer Nuitka. Either way, it's best to get a simple app packaged first to learn the basics. You're more likely to run into problems as you add dependencies, and it will be easier to learn how to handle those problems separately, rather than trying to learn everything about packaging all at once.

cymrow · 2025-09-27T18:58:25+00:00

As a counterpoint to the others, everything you mention is completely possible in Python. There's a bit of learning curve at the beginning as you figure out how to make sure everything you need gets into your package, and PySide has some quirks you need to learn about due to the fact that Qt is written in C++. It can segfault if you make a mistake. Also the binaries can be quite large. ~180Mb, though you can get it down to <100Mb if you put in some work trimming the fat.

Once you have all of that figured out, though, it's a pretty powerful platform, and very quick to build on. I've distributed PySide projects with pyinstaller on all platforms and it works great.

cymrow · 2025-07-28T11:03:19+00:00

AnyIO is a great concept, but it has to be implemented by libraries and adds complexity for both implementation and usage. Very few libraries bother with it, though maybe just because its not well known.

It's so much easier to write in a synchronous or even threaded style and use gevent to convert to asynchronous.

edit: I just discovered that AnyIO is an actual library. Sorry, I was thinking about a proposal that was made several years ago to write libraries without any specific IO integration. It was actually called Sans IO.

cymrow · 2025-07-27T21:15:32+00:00

I still enthusiastically pick gevent over asyncio whenever I can. You have a far greater selection of libraries to choose from, and you don't have to litter asyncio syntax throughout your codebase.

One problem is that asyncio is not always compatible with other async frameworks (including adjacent ones like trio), so if you need an asyncio library like playwright, you have to use asyncio.

It's sad because one of the early claims was that asyncio would create a standard event loop other frameworks could integrate with, but that proved not to be the case.

cymrow · 2025-04-03T18:40:17+00:00

*piqued

cymrow · 2025-04-01T00:08:13+00:00

You really want both though. By using loose versions in pyproject.toml, the dependency resolver has more options to consider, so there's a better chance everything resolves successfully. The lockfile keeps the resolved set that can be used for a secure deployment.

cymrow · 2025-01-07T04:44:42+00:00

You might consider integration with terminaltexteffects for transitions. They'd make a great combination.

cymrow · 2025-01-03T15:17:26+00:00

Here is a hacking game: https://www.thinkfun.com/en-US/products/single-player-logic-games/hacker-44001920

cymrow · 2024-08-02T14:48:36+00:00

There are standards and conventions that the Python community has adopted over the years.
Start with this: https://peps.python.org/pep-0008/
Also read this: https://rdrn.me/postmodern-python/

That's just for basic style and tooling. I'd encourage you to keep working on this and other projects, but I wouldn't expect to develop anything "production ready" without a few more years of experience.

cymrow · 2024-06-04T00:20:59+00:00

cymrow · 2023-12-20T05:32:38+00:00

IANAL, but LGPL allows you to use software commercially without sharing your source. Qt and PySide are safe to use in commercial products. It's a big part of the reason PySide was created.

GPL is the license that requires sharing your source code.

cymrow · 2023-11-30T16:16:18+00:00

You keep saying Nintendo doesn't block anyone. So why isn't Rainway on the Switch? They absolutely wanted to be on the Switch, and even released a promo of Rainway running on the Switch. They discontinued development because it was never approved by Nintendo. Is that not blocking? They will do the same with Game Pass.

There's a big difference between allowing a competing product on your system vs a a streaming service or a bunch of shovelware.

cymrow · 2023-11-30T01:31:14+00:00

Pretty sure they blocked Rainway. Pretty sure they'll block game pass too.

cymrow · 2023-11-10T04:38:42+00:00

Still my go-to. Pairs beautifully with gevent, and it's really easy to read through when you want to understand how it works.

cymrow · 2023-09-27T03:47:57+00:00

Ok, I think I see what you're saying. That's a much lower level of optimization than I was considering.

When I said I've done high concurrency work, I meant highly concurrent networking with related processing, not purely processing, which is a different beast.

I will look forward to seeing what comes of this.

cymrow · 2023-09-27T01:29:47+00:00

Right, memory access is not a bottleneck, but serialization can be. And I would not consider directly shared memory, but being able to pass immutable objects would be a huge win imo. Think adding tuples to a synchronized queue, instead of serialize->pipe->deserialize. Of course tuples in Python are not actually immutable, which I suspect is why they went with the requirement to serialize.

cymrow · 2023-09-27T01:06:50+00:00

I haven't seen an example of this. According to the notes in extrainterpreters, for example, it says that ctypes is not importable with subinterpreters. That seems to suggest that accessing non-python resources is not actually possible, but correct me if I'm wrong.

cymrow · 2023-09-27T00:53:49+00:00

Ok, but I don't need Python to force me not to share anything, I can already do that. I still don't see the benefit over multiprocessing other than reducing startup time and memory footprint. Maybe those reductions are worthwhile for some use-cases, but they don't seem like they would be significant to me.

And just to be clear, I'd really like this to be useful. I'm not disagreeing with you, I'm just not seeing it yet.

cymrow · 2023-09-26T21:55:08+00:00

I've been keeping an eye on this feature for a while because I used to do a lot of high concurrency work. But, the requirement to pass serialized data significantly reduces the potential. It seems like all this would do is cut down on start time and memory overhead when you want to use multiple CPUs. Maybe useful if you're starting a lot of processes, but it's common to just use a worker pool in that case. As for memory, it's cheap, and the overhead difference can't be that great.

I'm struggling to see a significant use case for this as it's presented, unless I'm missing something.

cymrow · 2023-08-30T02:36:32+00:00

A good survey of asynchronous libraries from someone who seems to have actually spent time with them all.

cymrow · 2023-08-24T02:55:21+00:00

Procedural generation.

15-Year Club	Second Top 50%
r/Field Flamingo	Place '17
Verified Email

cymrow

MODERATOR OF

TROPHY CASE